FruitSalad 0.1.0__tar.gz

fruitsalad-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fruitsalad-0.1.0/MANIFEST.in

@@ -0,0 +1,15 @@
+global-exclude *.ts
+global-exclude *.tsbuildinfo
+global-exclude *.map
+prune src/FruitSalad/.vscode-extension/node_modules
+prune src/FruitSalad/.vscode-extension/src
+prune src/FruitSalad/.vscode-extension/out
+recursive-exclude src/FruitSalad/.vscode-extension *.js
+recursive-exclude src/FruitSalad/.vscode-extension *.d.ts
+recursive-exclude src/FruitSalad/.vscode-extension package-lock.json
+recursive-exclude src/FruitSalad/.vscode-extension tsconfig.json
+include src/FruitSalad/.vscode-extension/package.json
+include src/FruitSalad/.vscode-extension/icons/*
+include src/FruitSalad/.vscode-extension/snippets/*
+include src/FruitSalad/.vscode-extension/syntaxes/*
+include src/FruitSalad/.vscode-extension/language-configuration.json

fruitsalad-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: FruitSalad
+Version: 0.1.0
+Summary: A fruit salad project
+Author: FruitSalad Contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/your-username/FruitSalad
+Project-URL: Repository, https://github.com/your-username/FruitSalad
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: blake3
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# FruitSalad
+
+A Python toolkit for working with `.cucumber` and `.melon` file formats, with VS Code extension support for syntax highlighting and file icons.
+
+## Features
+
+- **Cucumber format** — Human-readable config files with BLAKE3 integrity verification
+- **Melon format** — Binary serialization using TLV (Type-Length-Value) pattern with BLAKE3 checksums
+- **Conversion** — Convert between `.cucumber`, `.melon`, `.json`, and `.yaml` formats
+- **VS Code extension** — Syntax highlighting, snippets, and file icons for `.cucumber` and `.melon` files
+
+## Installation
+
+```bash
+pip install FruitSalad
+```
+
+## CLI Usage
+
+```bash
+# Convert between formats
+fruitsalad convert input.cucumber output.json
+
+# Install VS Code extension and configure file icons
+fruitsalad vscode
+
+# Convert specific formats
+fruitsalad to-json input.cucumber
+fruitsalad to-yaml input.cucumber
+fruitsalad to-cucumber input.json
+fruitsalad to-melon input.json
+```
+
+## Python API
+
+```python
+from FruitSalad import load, save, reseal, test_file
+
+# Load a .cucumber file
+data = load("config.cucumber")
+print(data)
+
+# Save data
+save("output.cucumber", data)
+
+# Re-seal after manual edits
+reseal("config.cucumber")
+
+# Generate a test file
+test_file("test.cucumber")
+```
+
+## License
+
+MIT

fruitsalad-0.1.0/README.md

@@ -0,0 +1,55 @@
+# FruitSalad
+
+A Python toolkit for working with `.cucumber` and `.melon` file formats, with VS Code extension support for syntax highlighting and file icons.
+
+## Features
+
+- **Cucumber format** — Human-readable config files with BLAKE3 integrity verification
+- **Melon format** — Binary serialization using TLV (Type-Length-Value) pattern with BLAKE3 checksums
+- **Conversion** — Convert between `.cucumber`, `.melon`, `.json`, and `.yaml` formats
+- **VS Code extension** — Syntax highlighting, snippets, and file icons for `.cucumber` and `.melon` files
+
+## Installation
+
+```bash
+pip install FruitSalad
+```
+
+## CLI Usage
+
+```bash
+# Convert between formats
+fruitsalad convert input.cucumber output.json
+
+# Install VS Code extension and configure file icons
+fruitsalad vscode
+
+# Convert specific formats
+fruitsalad to-json input.cucumber
+fruitsalad to-yaml input.cucumber
+fruitsalad to-cucumber input.json
+fruitsalad to-melon input.json
+```
+
+## Python API
+
+```python
+from FruitSalad import load, save, reseal, test_file
+
+# Load a .cucumber file
+data = load("config.cucumber")
+print(data)
+
+# Save data
+save("output.cucumber", data)
+
+# Re-seal after manual edits
+reseal("config.cucumber")
+
+# Generate a test file
+test_file("test.cucumber")
+```
+
+## License
+
+MIT

fruitsalad-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta:__legacy__"
+
+[project]
+name = "FruitSalad"
+version = "0.1.0"
+description = "A fruit salad project"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    {name = "FruitSalad Contributors"},
+]
+requires-python = ">=3.10"
+dependencies = [
+    "blake3",
+    "pyyaml",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+Homepage = "https://github.com/your-username/FruitSalad"
+Repository = "https://github.com/your-username/FruitSalad"
+
+[project.scripts]
+fruitsalad = "FruitSalad.cli:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+FruitSalad = [".vscode-extension/**"]

fruitsalad-0.1.0/setup.cfg

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

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/icons/cucumber.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <g transform="scale(1.7) translate(-21 -21)">
+    <circle cx="50" cy="50" r="40" fill="#388e3c" />
+    <circle cx="50" cy="50" r="32" fill="#a5d6a7" />
+    
+    <g fill="#1b5e20" opacity="0.8">
+      <ellipse cx="50" cy="35" rx="4" ry="7" />
+      <ellipse cx="35" cy="50" rx="7" ry="4" />
+      <ellipse cx="65" cy="50" rx="7" ry="4" />
+      <ellipse cx="50" cy="65" rx="4" ry="7" />
+    </g>
+    
+    <circle cx="50" cy="50" r="5" fill="#ffffff" opacity="0.15" />
+  </g>
+</svg>

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/icons/melon.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="32 34 36 26">
+<g transform="translate(50, 42) scale(1.7)">
+<path d="M -18 -8 A 22 22 0 0 0 18 -8 L 0 18 Z" fill="#1b5e20"/>
+<path d="M -15 -8 A 19 19 0 0 0 15 -8 L 0 15 Z" fill="#a5d6a7"/>
+<path d="M -12 -8 A 16 16 0 0 0 12 -8 L 0 12 Z" fill="#e53935"/>
+<circle cx="-4" cy="-1" r="1.8" fill="#1a1a1a"/>
+<circle cx="4" cy="-1" r="1.8" fill="#1a1a1a"/>
+<circle cx="0" cy="5" r="1.8" fill="#1a1a1a"/>
+</g>
+</svg>

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/language-configuration.json

@@ -0,0 +1,8 @@
+{
+  "comments": {
+    "lineComment": "#"
+  },
+  "brackets": [],
+  "autoClosingPairs": [],
+  "surroundingPairs": []
+}

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "FruitSalad",
+  "displayName": "FruitSalad",
+  "description": "Language support for .cucumber and .melon files — syntax highlighting, auto-complete, BLAKE3 integrity validation, and file icons.",
+  "version": "0.1.0",
+  "publisher": "fruit-salad",
+  "license": "MIT",
+  "engines": {
+    "vscode": "^1.125.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Snippets",
+    "Other"
+  ],
+  "activationEvents": [
+    "onLanguage:cucumber"
+  ],
+  "main": "./out/extension.js",
+  "contributes": {
+    "languages": [
+      {
+        "id": "cucumber",
+        "aliases": [
+          "Cucumber",
+          "cucumber"
+        ],
+        "extensions": [
+          ".cucumber"
+        ],
+        "icon": "./icons/cucumber.svg",
+        "configuration": "./language-configuration.json"
+      },
+      {
+        "id": "melon",
+        "aliases": [
+          "Melon",
+          "melon"
+        ],
+        "extensions": [
+          ".melon"
+        ],
+        "icon": "./icons/melon.svg"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "cucumber",
+        "scopeName": "source.cucumber",
+        "path": "./syntaxes/cucumber.tmLanguage.json"
+      }
+    ],
+    "snippets": [
+      {
+        "language": "cucumber",
+        "path": "./snippets/cucumber.json"
+      }
+    ],
+    "commands": [
+      {
+        "command": "fruit-salad.verify",
+        "title": "FruitSalad: Verify hash"
+      },
+      {
+        "command": "fruit-salad.reseal",
+        "title": "FruitSalad: Reseal (update hash)"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "@types/vscode": "^1.125.0",
+    "typescript": "^6.0.3"
+  }
+}

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/snippets/cucumber.json

@@ -0,0 +1,61 @@
+{
+  "Header block": {
+    "prefix": ["header", "hdr"],
+    "body": [
+      "--h-- Auto-Generated by FruitSalad --h--",
+      "--h-- BLAKE3: $1 --h--",
+      "$0"
+    ],
+    "description": "Insert the standard .cucumber header with BLAKE3 hash placeholder"
+  },
+  "Section block": {
+    "prefix": ["section", "sec"],
+    "body": [
+      "${1:section_name}",
+      "\t${2:key} | ${3:value}",
+      "$0"
+    ],
+    "description": "Insert a new section block with a key-value pair"
+  },
+  "Key-value pair": {
+    "prefix": ["kv", "keyvalue"],
+    "body": [
+      "${1:key} | ${2:value}",
+      "$0"
+    ],
+    "description": "Insert a key-value pair"
+  },
+  "Test metadata section": {
+    "prefix": ["test_meta", "metadata"],
+    "body": [
+      "test_meta",
+      "\tdate | $CURRENT_YEAR-$CURRENT_MONTH-$CURRENT_DATE",
+      "\ttime | $CURRENT_HOUR:$CURRENT_MINUTE:$CURRENT_SECOND",
+      "\tdevice | ${1:hostname}",
+      "$0"
+    ],
+    "description": "Insert a standard test_meta section"
+  },
+  "Server config section": {
+    "prefix": ["server", "servers"],
+    "body": [
+      "servers",
+      "\t${1:host} | ${2:10.0.0.1}",
+      "\t${3:port} | ${4:8080}",
+      "\t${5:ssl} | ${6:true}",
+      "$0"
+    ],
+    "description": "Insert a server configuration section"
+  },
+  "Database config section": {
+    "prefix": ["database", "db"],
+    "body": [
+      "database",
+      "\t${1:host} | ${2:localhost}",
+      "\t${3:port} | ${4:5432}",
+      "\t${5:name} | ${6:mydb}",
+      "$0"
+    ],
+    "description": "Insert a database configuration section"
+  }
+}

fruitsalad-0.1.0/src/FruitSalad/.vscode-extension/syntaxes/cucumber.tmLanguage.json

@@ -0,0 +1,43 @@
+{
+  "scopeName": "source.cucumber",
+  "name": "Cucumber",
+  "fileTypes": [".cucumber"],
+  "patterns": [
+    { "include": "#header" },
+    { "include": "#comments" },
+    { "include": "#key-value" },
+    { "include": "#section" }
+  ],
+  "repository": {
+    "header": {
+      "match": "^--h--.*--h--$",
+      "name": "comment.block.header.cucumber"
+    },
+    "comments": {
+      "match": "^#.*$",
+      "name": "comment.line.number-sign.cucumber"
+    },
+    "section": {
+      "match": "^[a-zA-Z_][a-zA-Z0-9_]*$",
+      "name": "entity.name.section.cucumber"
+    },
+    "key-value": {
+      "begin": "^([ \\t]*)([a-zA-Z_][a-zA-Z0-9_ ]*)\\s*(\\|)",
+      "beginCaptures": {
+        "2": { "name": "variable.other.key.cucumber" },
+        "3": { "name": "punctuation.separator.key-value.cucumber" }
+      },
+      "end": "$",
+      "patterns": [
+        {
+          "match": "\\b(true|false)\\b",
+          "name": "constant.language.boolean.cucumber"
+        },
+        {
+          "match": "\\b\\d+(\\.\\d+)?\\b",
+          "name": "constant.numeric.cucumber"
+        }
+      ]
+    }
+  }
+}

fruitsalad-0.1.0/src/FruitSalad/__init__.py

@@ -0,0 +1,3 @@
+from .cucumber import CucumberParser, load, save, reseal, test_file
+from .melon import MelonSerializer
+from .utils import convert, to_json, to_yaml, to_cucumber, to_melon

fruitsalad-0.1.0/src/FruitSalad/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

fruitsalad-0.1.0/src/FruitSalad/cli.py

@@ -0,0 +1,192 @@
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+
+def find_extension_dir():
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    ext_dir = os.path.join(pkg_dir, ".vscode-extension")
+    if os.path.isdir(ext_dir):
+        return ext_dir
+    return None
+
+
+def find_vsix(ext_dir):
+    for f in os.listdir(ext_dir):
+        if f.endswith(".vsix"):
+            return os.path.join(ext_dir, f)
+    return None
+
+
+def get_user_vscode_settings_path():
+    if sys.platform == "win32":
+        base = os.environ.get("APPDATA", os.path.join(os.path.expanduser("~"), "AppData", "Roaming"))
+    elif sys.platform == "darwin":
+        base = os.path.join(os.path.expanduser("~"), "Library", "Application Support")
+    else:
+        base = os.path.join(os.path.expanduser("~"), ".config")
+    return os.path.join(base, "Code", "User", "settings.json")
+
+
+def install_icons(ext_dir):
+    """Copy icon SVGs to the VS Code extensions icons directory."""
+    icons_src = os.path.join(ext_dir, "icons")
+    if not os.path.isdir(icons_src):
+        print("Warning: icons directory not found in extension", file=sys.stderr)
+        return
+
+    # Target: C:\Users\User\.vscode\extensions\icons\
+    vscode_ext_icons = os.path.join(os.path.expanduser("~"), ".vscode", "extensions", "icons")
+    os.makedirs(vscode_ext_icons, exist_ok=True)
+
+    icon_mappings = {
+        "cucumber.svg": "fruit-cucumber.svg",
+        "melon.svg": "fruit-melon.svg",
+    }
+
+    for src_name, dst_name in icon_mappings.items():
+        src_path = os.path.join(icons_src, src_name)
+        dst_path = os.path.join(vscode_ext_icons, dst_name)
+        if os.path.exists(src_path):
+            shutil.copy2(src_path, dst_path)
+            print(f"Installed icon: {dst_path}")
+        else:
+            print(f"Warning: source icon not found: {src_path}", file=sys.stderr)
+
+
+def update_user_settings():
+    """Append material-icon-theme.files.associations to the global VS Code user settings."""
+    settings_path = get_user_vscode_settings_path()
+    if not os.path.exists(settings_path):
+        print(f"Warning: user settings not found at {settings_path}", file=sys.stderr)
+        return
+
+    with open(settings_path, "r") as f:
+        settings = json.load(f)
+
+    settings.setdefault("material-icon-theme.files.associations", {}).update({
+        "*.cucumber": "../../icons/fruit-cucumber",
+        "*.melon": "../../icons/fruit-melon",
+    })
+
+    with open(settings_path, "w") as f:
+        json.dump(settings, f, indent=4)
+        f.write("\n")
+
+    print(f"Updated icon settings in global user settings: {settings_path}")
+
+
+def cmd_vscode(args):
+    ext_dir = find_extension_dir()
+    if ext_dir is None:
+        print("Error: .vscode-extension directory not found", file=sys.stderr)
+        sys.exit(1)
+
+    vsix = find_vsix(ext_dir)
+    if vsix is None:
+        print("Error: No .vsix file found in .vscode-extension", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Installing VS Code extension: {vsix}")
+    try:
+        result = subprocess.run(
+            ["code", "--install-extension", vsix],
+            capture_output=True, text=True, timeout=30
+        )
+        if result.returncode == 0:
+            print(result.stdout.strip() or "Extension installed successfully")
+        else:
+            print(f"Warning: extension install may have failed:\n{result.stderr}", file=sys.stderr)
+    except FileNotFoundError:
+        print("Warning: 'code' command not found. Install VS Code and add it to PATH.", file=sys.stderr)
+    except subprocess.TimeoutExpired:
+        print("Warning: extension install timed out.", file=sys.stderr)
+
+    # Install icon files to the correct location
+    install_icons(ext_dir)
+
+    # Update global VS Code user settings
+    update_user_settings()
+
+    # Update workspace .vscode/settings.json
+    vscode_dir = os.path.join(os.getcwd(), ".vscode")
+    os.makedirs(vscode_dir, exist_ok=True)
+
+    settings_path = os.path.join(vscode_dir, "settings.json")
+    settings = {}
+    if os.path.exists(settings_path):
+        with open(settings_path, "r") as f:
+            settings = json.load(f)
+
+    settings.setdefault("files.associations", {}).update({
+        "*.cucumber": "cucumber",
+        "*.melon": "melon",
+    })
+    settings.setdefault("material-icon-theme.files.associations", {}).update({
+        "*.cucumber": "../../icons/fruit-cucumber",
+        "*.melon": "../../icons/fruit-melon",
+    })
+    settings.setdefault("material-icon-theme.languages.associations", {}).update({
+        "cucumber": "../../icons/fruit-cucumber",
+        "melon": "../../icons/fruit-melon",
+    })
+
+    with open(settings_path, "w") as f:
+        json.dump(settings, f, indent=2)
+        f.write("\n")
+
+    print(f"Updated icon settings in {settings_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="fruitsalad", description="FruitSalad CLI")
+    sub = parser.add_subparsers(dest="command")
+
+    vscode_parser = sub.add_parser("vscode", help="Install VS Code extension and set icons")
+    vscode_parser.set_defaults(func=cmd_vscode)
+
+    convert_parser = sub.add_parser("convert", help="Convert between file formats")
+    convert_parser.add_argument("in_path", help="Input file path")
+    convert_parser.add_argument("out_path", help="Output file path")
+    convert_parser.set_defaults(func=lambda a: from_utils("convert", a.in_path, a.out_path))
+
+    for name, help_text in [
+        ("to-json", "Convert to JSON"),
+        ("to-yaml", "Convert to YAML"),
+        ("to-cucumber", "Convert to .cucumber"),
+        ("to-melon", "Convert to .melon"),
+    ]:
+        p = sub.add_parser(name, help=help_text)
+        p.add_argument("in_path", help="Input file path")
+        p.add_argument("out_path", nargs="?", default=None, help="Output file path (optional)")
+        p.set_defaults(func=lambda a, _name=name.replace("-", "_"): from_utils(_name, a.in_path, a.out_path))
+
+    args = parser.parse_args()
+    if args.command is None:
+        parser.print_help()
+        sys.exit(1)
+    args.func(args)
+
+
+def from_utils(func_name, in_path, out_path=None):
+    """Bridge to call utility functions from CLI."""
+    from .utils import convert, to_json, to_yaml, to_cucumber, to_melon
+    mapping = {
+        "convert": convert,
+        "to_json": to_json,
+        "to_yaml": to_yaml,
+        "to_cucumber": to_cucumber,
+        "to_melon": to_melon,
+    }
+    fn = mapping[func_name]
+    if out_path is not None:
+        fn(in_path, out_path)
+    else:
+        fn(in_path)
+
+
+if __name__ == "__main__":
+    main()

fruitsalad-0.1.0/src/FruitSalad/cucumber.py

@@ -0,0 +1,104 @@
+import blake3
+import os
+import datetime
+import platform
+
+class CucumberParser:
+    def __init__(self):
+        self.data = {}
+
+    def _verify_hash(self, lines):
+        header_line = lines[1]
+        if "BLAKE3:" not in header_line:
+            raise ValueError("Invalid format: Missing BLAKE3 header line.")
+        expected_hash = header_line.split("BLAKE3:")[1].split("--h--")[0].strip()
+        
+        content = "".join(lines[2:]).encode('utf-8')
+        actual_hash = blake3.blake3(content).hexdigest()
+        
+        if actual_hash != expected_hash:
+            raise ValueError(f"Integrity Check Failed! Expected {expected_hash}, got {actual_hash}")
+
+    def _cast_value(self, val):
+        val = val.strip()
+        if val.lower() == 'true': return True
+        if val.lower() == 'false': return False
+        try:
+            if '.' in val: return float(val)
+            return int(val)
+        except ValueError:
+            return val
+
+    def load(self, filepath):
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Config file {filepath} not found.")
+
+        with open(filepath, 'r') as f:
+            lines = f.readlines()
+
+        self._verify_hash(lines)
+
+        current_section = self.data
+        for line in lines[2:]:
+            line = line.rstrip()
+            if not line or line.startswith('#'):
+                continue
+                
+            if '|' not in line:
+                self.data[line.strip()] = {}
+                current_section = self.data[line.strip()]
+            else:
+                key, value = [p.strip() for p in line.split('|', 1)]
+                current_section[key] = self._cast_value(value)
+        return self.data
+
+    def save(self, filepath, data):
+        lines = ["--h-- Auto-Generated by FruitSalad --h--", "--h-- BLAKE3: PLACEHOLDER --h--"]
+        
+        def format_dict(d, indent=""):
+            for k, v in d.items():
+                if isinstance(v, dict):
+                    lines.append(f"{indent}{k}")
+                    format_dict(v, indent + "    ")
+                else:
+                    lines.append(f"{indent}{k} | {v}")
+        
+        format_dict(data)
+        
+        content = "\n".join(lines[2:]) + "\n"
+        actual_hash = blake3.blake3(content.encode('utf-8')).hexdigest()
+        lines[1] = f"--h-- BLAKE3: {actual_hash} --h--"
+        
+        with open(filepath, 'w') as f:
+            f.write("\n".join(lines) + "\n")
+
+    def reseal(self, filepath):
+        """Re-calculates the BLAKE3 hash for an existing .cucumber file after manual edits."""
+        with open(filepath, 'r') as f:
+            lines = f.readlines()
+
+        content = "".join(lines[2:]).encode('utf-8')
+        new_hash = blake3.blake3(content).hexdigest()
+
+        lines[1] = f"--h-- BLAKE3: {new_hash} --h--\n"
+        with open(filepath, 'w') as f:
+            f.writelines(lines)
+        print(f"Re-sealed {filepath} with hash: {new_hash}")
+
+    def test_file(self, filepath):
+        """Creates a diagnostic file with system metadata."""
+        test_data = {
+            "test_meta": {
+                "date": datetime.datetime.now().strftime("%Y-%m-%d"),
+                "time": datetime.datetime.now().strftime("%H:%M:%S"),
+                "device": platform.node()
+            }
+        }
+        self.save(filepath, test_data)
+        print(f"Test file generated at: {filepath}")
+
+# Convenience functions
+def load(filepath): return CucumberParser().load(filepath)
+def save(filepath, data): CucumberParser().save(filepath, data)
+def reseal(filepath): CucumberParser().reseal(filepath)
+def test_file(filepath): CucumberParser().test_file(filepath)

fruitsalad-0.1.0/src/FruitSalad/melon.py

@@ -0,0 +1,74 @@
+import struct
+import blake3
+import os
+
+# TLV Tag Definitions
+TAG_NODE_ID = 0x01
+TAG_NEIGHBOR = 0x02
+TAG_KSIZE = 0x03
+
+class MelonSerializer:
+    """
+    Handles binary serialization using TLV pattern:
+    [Magic:4][Version:1][Checksum:32][Payload:...]
+    """
+    MAGIC = b"MELN"
+    VERSION = 1
+
+    def save(self, filepath, data_dict):
+        """
+        Serializes a dictionary into a .melon file.
+        Example data_dict: {'node_id': b'...', 'ksize': 20}
+        """
+        payload = b""
+        
+        # Packing simple types (Example logic)
+        if 'node_id' in data_dict:
+            val = data_dict['node_id']
+            payload += struct.pack(f"BB{len(val)}s", TAG_NODE_ID, len(val), val)
+            
+        if 'ksize' in data_dict:
+            val = data_dict['ksize']
+            payload += struct.pack("BBB", TAG_KSIZE, 1, val)
+
+        # Integrity
+        checksum = blake3.blake3(payload).digest()
+        header = struct.pack(">4sB32s", self.MAGIC, self.VERSION, checksum)
+
+        with open(filepath, "wb") as f:
+            f.write(header + payload)
+
+    def load(self, filepath):
+        """Reads and deserializes a .melon file."""
+        with open(filepath, "rb") as f:
+            header = f.read(37)
+            magic, version, stored_checksum = struct.unpack(">4sB32s", header)
+            
+            if magic != self.MAGIC:
+                raise ValueError("Not a valid .melon file")
+                
+            payload = f.read()
+            
+            # Verify Integrity
+            if blake3.blake3(payload).digest() != stored_checksum:
+                raise ValueError("Corrupted .melon file: Hash mismatch!")
+            
+            # Parsing Payload (TLV loop)
+            data = {}
+            offset = 0
+            while offset < len(payload):
+                tag = payload[offset]
+                length = payload[offset + 1]
+                val = payload[offset + 2 : offset + 2 + length]
+                
+                if tag == TAG_NODE_ID:
+                    data['node_id'] = val
+                elif tag == TAG_KSIZE:
+                    data['ksize'] = struct.unpack("B", val)[0]
+                
+                offset += 2 + length
+            return data
+
+# Convenience functions
+def save(filepath, data): MelonSerializer().save(filepath, data)
+def load(filepath): return MelonSerializer().load(filepath)

fruitsalad-0.1.0/src/FruitSalad/utils.py

@@ -0,0 +1,90 @@
+import json
+import os
+from .cucumber import CucumberParser
+from .melon import MelonSerializer
+
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+EXT_FORMAT_MAP = {
+    '.cucumber': 'cucumber',
+    '.melon': 'melon',
+    '.json': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+}
+
+
+def read_data(filepath):
+    ext = os.path.splitext(filepath)[1].lower()
+    if ext == '.cucumber':
+        return CucumberParser().load(filepath)
+    elif ext == '.melon':
+        return MelonSerializer().load(filepath)
+    elif ext == '.json':
+        with open(filepath, 'r') as f:
+            return json.load(f)
+    elif ext in ('.yaml', '.yml'):
+        if not HAS_YAML:
+            raise ImportError("pyyaml is required to read YAML files")
+        with open(filepath, 'r') as f:
+            return yaml.safe_load(f)
+    else:
+        raise ValueError(f"Unknown format: {ext}")
+
+
+def write_data(filepath, data):
+    ext = os.path.splitext(filepath)[1].lower()
+    if ext == '.cucumber':
+        CucumberParser().save(filepath, data)
+    elif ext == '.melon':
+        MelonSerializer().save(filepath, data)
+    elif ext == '.json':
+        with open(filepath, 'w') as f:
+            json.dump(data, f, indent=2)
+    elif ext in ('.yaml', '.yml'):
+        if not HAS_YAML:
+            raise ImportError("pyyaml is required to write YAML files")
+        with open(filepath, 'w') as f:
+            yaml.dump(data, f, default_flow_style=False)
+    else:
+        raise ValueError(f"Unknown format: {ext}")
+
+
+def convert(in_path, out_path):
+    data = read_data(in_path)
+    write_data(out_path, data)
+    print(f"Converted {in_path} -> {out_path}")
+    return data
+
+
+def to_json(in_path, out_path=None):
+    if out_path is None:
+        base, _ = os.path.splitext(in_path)
+        out_path = base + '.json'
+    return convert(in_path, out_path)
+
+
+def to_yaml(in_path, out_path=None):
+    if out_path is None:
+        base, _ = os.path.splitext(in_path)
+        out_path = base + '.yaml'
+    return convert(in_path, out_path)
+
+
+def to_cucumber(in_path, out_path=None):
+    if out_path is None:
+        base, _ = os.path.splitext(in_path)
+        out_path = base + '.cucumber'
+    return convert(in_path, out_path)
+
+
+def to_melon(in_path, out_path=None):
+    if out_path is None:
+        base, _ = os.path.splitext(in_path)
+        out_path = base + '.melon'
+    return convert(in_path, out_path)

fruitsalad-0.1.0/src/FruitSalad.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: FruitSalad
+Version: 0.1.0
+Summary: A fruit salad project
+Author: FruitSalad Contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/your-username/FruitSalad
+Project-URL: Repository, https://github.com/your-username/FruitSalad
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: blake3
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# FruitSalad
+
+A Python toolkit for working with `.cucumber` and `.melon` file formats, with VS Code extension support for syntax highlighting and file icons.
+
+## Features
+
+- **Cucumber format** — Human-readable config files with BLAKE3 integrity verification
+- **Melon format** — Binary serialization using TLV (Type-Length-Value) pattern with BLAKE3 checksums
+- **Conversion** — Convert between `.cucumber`, `.melon`, `.json`, and `.yaml` formats
+- **VS Code extension** — Syntax highlighting, snippets, and file icons for `.cucumber` and `.melon` files
+
+## Installation
+
+```bash
+pip install FruitSalad
+```
+
+## CLI Usage
+
+```bash
+# Convert between formats
+fruitsalad convert input.cucumber output.json
+
+# Install VS Code extension and configure file icons
+fruitsalad vscode
+
+# Convert specific formats
+fruitsalad to-json input.cucumber
+fruitsalad to-yaml input.cucumber
+fruitsalad to-cucumber input.json
+fruitsalad to-melon input.json
+```
+
+## Python API
+
+```python
+from FruitSalad import load, save, reseal, test_file
+
+# Load a .cucumber file
+data = load("config.cucumber")
+print(data)
+
+# Save data
+save("output.cucumber", data)
+
+# Re-seal after manual edits
+reseal("config.cucumber")
+
+# Generate a test file
+test_file("test.cucumber")
+```
+
+## License
+
+MIT

fruitsalad-0.1.0/src/FruitSalad.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/FruitSalad/__init__.py
+src/FruitSalad/__main__.py
+src/FruitSalad/cli.py
+src/FruitSalad/cucumber.py
+src/FruitSalad/melon.py
+src/FruitSalad/utils.py
+src/FruitSalad.egg-info/PKG-INFO
+src/FruitSalad.egg-info/SOURCES.txt
+src/FruitSalad.egg-info/dependency_links.txt
+src/FruitSalad.egg-info/entry_points.txt
+src/FruitSalad.egg-info/requires.txt
+src/FruitSalad.egg-info/top_level.txt
+src/FruitSalad/.vscode-extension/fruit-salad-0.1.0.vsix
+src/FruitSalad/.vscode-extension/language-configuration.json
+src/FruitSalad/.vscode-extension/package.json
+src/FruitSalad/.vscode-extension/icons/cucumber.svg
+src/FruitSalad/.vscode-extension/icons/melon.svg
+src/FruitSalad/.vscode-extension/snippets/cucumber.json
+src/FruitSalad/.vscode-extension/syntaxes/cucumber.tmLanguage.json
+tests/test_parsing.py

fruitsalad-0.1.0/src/FruitSalad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fruitsalad-0.1.0/src/FruitSalad.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fruitsalad = FruitSalad.cli:main

fruitsalad-0.1.0/src/FruitSalad.egg-info/requires.txt

@@ -0,0 +1,2 @@
+blake3
+pyyaml

fruitsalad-0.1.0/src/FruitSalad.egg-info/top_level.txt

@@ -0,0 +1 @@
+FruitSalad