claude-mpm 4.25.10__py3-none-any.whl → 5.1.8__py3-none-any.whl

claude_mpm/skills/bundled/infrastructure/env-manager/references/validation.md

@@ -1,420 +0,0 @@
-# Environment Validation Workflows
-
-> **Part of**: [env-manager](../SKILL.md)
-> **Category**: infrastructure
-> **Reading Level**: Intermediate
-
-## Purpose
-
-Complete validation workflows for environment variables: structure checks, completeness verification, naming conventions, and framework-specific validation patterns.
-
-## Validation Hierarchy
-
-### Level 1: Structure Validation (Basic)
-Validates file format and syntax.
-
-### Level 2: Semantic Validation (Intermediate)
-Validates naming, completeness, framework conventions.
-
-### Level 3: Integration Validation (Advanced)
-Validates across environments, platforms, and services.
-
-## Structure Validation
-
-### Check 1: Valid Key-Value Format
-
-**What to Check:**
-```bash
-# Valid formats:
-KEY=value
-KEY="value with spaces"
-KEY='single quoted'
-KEY=
-
-# Invalid formats:
-key=value              # lowercase
-KEY = value            # spaces around =
-KEY=value # comment    # inline comments (parser-dependent)
-=value                 # missing key
-KEY                    # missing =
-```
-
-**Validation Script:**
-```python
-import re
-from pathlib import Path
-
-def validate_structure(env_file: Path) -> list[str]:
-    """Validate .env file structure."""
-    errors = []
-    valid_line_pattern = re.compile(r'^[A-Z_][A-Z0-9_]*=.*$')
-
-    with open(env_file) as f:
-        for line_num, line in enumerate(f, 1):
-            line = line.strip()
-
-            # Skip empty lines and comments
-            if not line or line.startswith('#'):
-                continue
-
-            # Check format
-            if not valid_line_pattern.match(line):
-                errors.append(f"Line {line_num}: Invalid format: {line}")
-
-            # Check for inline comments (warning)
-            if '#' in line and not line.startswith('#'):
-                # Check if # is inside quotes
-                key, value = line.split('=', 1)
-                if '#' in value and not (value.startswith('"') or value.startswith("'")):
-                    errors.append(f"Line {line_num}: WARNING: Possible inline comment: {line}")
-
-    return errors
-```
-
-### Check 2: No Duplicate Keys
-
-**Issue:**
-```bash
-# .env file
-DATABASE_URL=postgres://local
-DATABASE_URL=postgres://production  # Duplicate! Which wins?
-```
-
-**Validation:**
-```python
-def check_duplicates(env_file: Path) -> dict[str, list[int]]:
-    """Find duplicate keys and their line numbers."""
-    keys = {}
-
-    with open(env_file) as f:
-        for line_num, line in enumerate(f, 1):
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-
-            if '=' in line:
-                key = line.split('=', 1)[0]
-                if key in keys:
-                    keys[key].append(line_num)
-                else:
-                    keys[key] = [line_num]
-
-    # Return only duplicates
-    return {k: v for k, v in keys.items() if len(v) > 1}
-```
-
-### Check 3: Proper Quoting
-
-**Valid Quoting Patterns:**
-```bash
-# No quotes needed
-SIMPLE_VALUE=hello
-
-# Quotes required for spaces
-WITH_SPACES="hello world"
-
-# Quotes required for special chars
-SPECIAL_CHARS="value with = or # chars"
-
-# Escape quotes inside quotes
-ESCAPED="He said \"hello\""
-ESCAPED_SINGLE='It'\''s working'
-```
-
-**Validation:**
-```python
-def validate_quoting(env_file: Path) -> list[str]:
-    """Check for proper quoting."""
-    warnings = []
-
-    with open(env_file) as f:
-        for line_num, line in enumerate(f, 1):
-            line = line.strip()
-            if not line or line.startswith('#') or '=' not in line:
-                continue
-
-            key, value = line.split('=', 1)
-
-            # Check for spaces without quotes
-            if ' ' in value and not (value.startswith('"') or value.startswith("'")):
-                warnings.append(f"Line {line_num}: Value with spaces should be quoted: {key}")
-
-            # Check for special chars without quotes
-            if any(char in value for char in ['#', '=', '$']) and not value.startswith(('"', "'")):
-                warnings.append(f"Line {line_num}: Value with special chars should be quoted: {key}")
-
-    return warnings
-```
-
-## Completeness Validation
-
-### Compare Against .env.example
-
-**Workflow:**
-```python
-def compare_env_files(env_file: Path, example_file: Path) -> dict:
-    """Compare .env against .env.example."""
-
-    def parse_keys(file_path: Path) -> set[str]:
-        keys = set()
-        with open(file_path) as f:
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith('#') and '=' in line:
-                    key = line.split('=', 1)[0]
-                    keys.add(key)
-        return keys
-
-    env_keys = parse_keys(env_file)
-    example_keys = parse_keys(example_file)
-
-    return {
-        'missing': example_keys - env_keys,  # Required but missing
-        'extra': env_keys - example_keys,    # Present but not documented
-        'common': env_keys & example_keys    # Properly documented
-    }
-```
-
-**Usage:**
-```bash
-# Find missing required variables
-python validate_env.py .env --compare .env.example
-
-# Output:
-# Missing variables (in .env.example but not .env):
-#   - DATABASE_URL
-#   - JWT_SECRET
-#   - SMTP_HOST
-#
-# Extra variables (in .env but not documented):
-#   - DEBUG_MODE
-#   - TEMP_API_KEY
-```
-
-### Check Required Variables by Environment
-
-**Pattern:**
-```python
-REQUIRED_VARS = {
-    'development': [
-        'NODE_ENV',
-        'DATABASE_URL',
-        'PORT'
-    ],
-    'production': [
-        'NODE_ENV',
-        'DATABASE_URL',
-        'PORT',
-        'JWT_SECRET',
-        'API_KEY',
-        'REDIS_URL'
-    ],
-    'test': [
-        'NODE_ENV',
-        'TEST_DATABASE_URL'
-    ]
-}
-
-def validate_required_vars(env_file: Path, environment: str) -> list[str]:
-    """Check if all required variables are present."""
-    required = REQUIRED_VARS.get(environment, [])
-    present = parse_keys(env_file)
-
-    missing = [var for var in required if var not in present]
-    return missing
-```
-
-## Naming Convention Validation
-
-### Standard Conventions
-
-**Valid Names:**
-```bash
-# Standard format: UPPERCASE_WITH_UNDERSCORES
-DATABASE_URL=value
-API_KEY=value
-MAX_CONNECTIONS=10
-
-# Framework-specific prefixes
-NEXT_PUBLIC_API_URL=value       # Next.js client-side
-VITE_API_URL=value              # Vite client-side
-REACT_APP_API_URL=value         # Create React App
-```
-
-**Invalid Names:**
-```bash
-# Bad patterns
-databaseUrl=value          # camelCase
-database-url=value         # kebab-case
-database.url=value         # dots
-123_KEY=value              # starts with number
-_PRIVATE_KEY=value         # leading underscore (convention warning)
-```
-
-**Validation:**
-```python
-import re
-
-def validate_naming_conventions(env_file: Path, framework: str = None) -> list[str]:
-    """Validate variable naming conventions."""
-    errors = []
-
-    # Standard pattern
-    standard_pattern = re.compile(r'^[A-Z][A-Z0-9_]*$')
-
-    # Framework-specific patterns
-    framework_patterns = {
-        'nextjs': re.compile(r'^(NEXT_PUBLIC_|NEXT_)[A-Z0-9_]+$'),
-        'vite': re.compile(r'^(VITE_)?[A-Z0-9_]+$'),
-        'react': re.compile(r'^(REACT_APP_)?[A-Z0-9_]+$'),
-    }
-
-    with open(env_file) as f:
-        for line_num, line in enumerate(f, 1):
-            line = line.strip()
-            if not line or line.startswith('#') or '=' not in line:
-                continue
-
-            key = line.split('=', 1)[0]
-
-            # Check standard pattern
-            if not standard_pattern.match(key):
-                errors.append(f"Line {line_num}: Invalid naming: {key} (use UPPERCASE_WITH_UNDERSCORES)")
-
-            # Check framework-specific patterns
-            if framework and framework in framework_patterns:
-                pattern = framework_patterns[framework]
-                if not pattern.match(key):
-                    errors.append(f"Line {line_num}: {framework} convention violation: {key}")
-
-    return errors
-```
-
-## Framework-Specific Validation
-
-### Next.js Validation
-
-**Rules:**
-```python
-def validate_nextjs_env(env_file: Path) -> list[str]:
-    """Validate Next.js environment variables."""
-    errors = []
-    warnings = []
-
-    with open(env_file) as f:
-        for line_num, line in enumerate(f, 1):
-            line = line.strip()
-            if not line or line.startswith('#') or '=' not in line:
-                continue
-
-            key, value = line.split('=', 1)
-
-            # Check NEXT_PUBLIC_ prefix rules
-            if key.startswith('NEXT_PUBLIC_'):
-                # Warn about secrets in public vars
-                if any(secret in key.lower() for secret in ['secret', 'key', 'password', 'token']):
-                    errors.append(f"Line {line_num}: SECURITY: Secret in NEXT_PUBLIC_ var: {key}")
-
-            # Check for client-side vars without NEXT_PUBLIC_
-            if any(client in key.lower() for client in ['api_url', 'api_endpoint']):
-                if not key.startswith('NEXT_PUBLIC_'):
-                    warnings.append(f"Line {line_num}: Client-side var without NEXT_PUBLIC_: {key}")
-
-    return errors, warnings
-```
-
-**File Precedence Check:**
-```python
-def check_nextjs_file_precedence(project_dir: Path) -> dict:
-    """Check Next.js .env file precedence."""
-    env_files = [
-        '.env.local',
-        '.env.development.local',
-        '.env.production.local',
-        '.env.development',
-        '.env.production',
-        '.env'
-    ]
-
-    found_files = []
-    for env_file in env_files:
-        if (project_dir / env_file).exists():
-            found_files.append(env_file)
-
-    # Parse and check for conflicts
-    all_vars = {}
-    for env_file in found_files:
-        vars_in_file = parse_env_file(project_dir / env_file)
-        for key, value in vars_in_file.items():
-            if key in all_vars:
-                all_vars[key].append((env_file, value))
-            else:
-                all_vars[key] = [(env_file, value)]
-
-    # Find variables defined in multiple files
-    conflicts = {k: v for k, v in all_vars.items() if len(v) > 1}
-
-    return {
-        'files_found': found_files,
-        'conflicts': conflicts,
-        'precedence_order': env_files
-    }
-```
-
-### Express/Node.js Validation
-
-**Standard Variables:**
-```python
-NODE_STANDARD_VARS = {
-    'NODE_ENV': ['development', 'production', 'test'],
-    'PORT': r'^\d+$',  # Must be a number
-    'DATABASE_URL': r'^postgres://|mysql://|mongodb://',  # Must be valid connection string
-}
-
-def validate_nodejs_env(env_file: Path) -> list[str]:
-    """Validate Node.js environment variables."""
-    errors = []
-    vars_dict = parse_env_file(env_file)
-
-    for key, value in vars_dict.items():
-        if key in NODE_STANDARD_VARS:
-            expected = NODE_STANDARD_VARS[key]
-
-            if isinstance(expected, list):
-                # Check enumeration
-                if value not in expected:
-                    errors.append(f"{key}: Invalid value '{value}', expected one of {expected}")
-            elif isinstance(expected, str):
-                # Check regex pattern
-                if not re.match(expected, value):
-                    errors.append(f"{key}: Value doesn't match expected format")
-
-    return errors
-```
-
-## Summary
-
-**Validation Workflow:**
-1. **Structure**: Valid format, no duplicates, proper quoting
-2. **Completeness**: All required vars present, compare with .env.example
-3. **Naming**: UPPERCASE_WITH_UNDERSCORES, framework prefixes
-4. **Framework**: Next.js NEXT_PUBLIC_, file precedence
-5. **Platform**: Vercel/Railway/Heroku conventions
-
-**Key Validations:**
-- ✅ Valid key-value format
-- ✅ No duplicate keys
-- ✅ Proper quoting for spaces/special chars
-- ✅ All required variables present
-- ✅ Consistent naming conventions
-- ✅ Framework-specific rules followed
-- ✅ No secrets in client-side vars (NEXT_PUBLIC_)
-
-## Related References
-
-- [Security](security.md): Secret scanning and exposure detection
-- [Synchronization](synchronization.md): Platform sync validation
-- [Frameworks](frameworks.md): Complete framework patterns
-
----
-**Lines**: 285 ✓ 150-300 range

claude_mpm/skills/bundled/main/artifacts-builder/LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.