create-living-architecture 1.0.8 → 2.0.0

package/src/domain/validate-execution.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+validate-execution.py - R1 Execution Pattern Validator
+Validates I/O ownership, state machines, flow paths.
+Pure functions — content passed in by R2, no file I/O here.
+"""
+
+import sys
+import re
+import json
+
+
+def check_io_ownership(filepath, content):
+    """Check for I/O operations and ownership."""
+    io_patterns = {
+        'stdout':  [r'print\(', r'console\.log', r'echo\s'],
+        'stderr':  [r'console\.error', r'sys\.stderr'],
+        'file':    [r'open\(', r'fs\.', r'File\('],
+        'network': [r'fetch\(', r'axios', r'requests\.'],
+    }
+    operations = []
+    for io_type, patterns in io_patterns.items():
+        for pattern in patterns:
+            if re.findall(pattern, content):
+                operations.append({'type': io_type})
+    return {
+        'has_io':     len(operations) > 0,
+        'operations': operations,
+        'valid':      len(operations) <= 2
+    }
+
+
+def check_state_machines(filepath, content):
+    """Check for state machine completeness."""
+    has_state       = bool(re.search(r'state\s*=|setState|this\.state', content))
+    has_transitions = bool(re.search(r'switch|if.*state|case\s', content))
+    if has_state:
+        return {
+            'has_state_machine': True,
+            'has_transitions':   has_transitions,
+            'valid':             has_transitions
+        }
+    return {'has_state_machine': False, 'valid': True}
+
+
+def check_flow_paths(filepath, content):
+    """Check for deep relative imports (circular risk)."""
+    imports = []
+    for line in content.split('\n'):
+        match = re.search(r'(?:from|import)\s+([^\s]+)', line)
+        if match:
+            imports.append(match.group(1))
+    bad_imports = [imp for imp in imports if imp.count('..') > 2]
+    return {
+        'imports':       imports,
+        'circular_risk': len(bad_imports) > 0,
+        'valid':         len(bad_imports) == 0
+    }
+
+
+def validate(filepath, content):
+    """
+    Main validation function.
+    R2 reads the file via file-io and passes content here.
+    """
+    io_result    = check_io_ownership(filepath, content)
+    state_result = check_state_machines(filepath, content)
+    flow_result  = check_flow_paths(filepath, content)
+    all_valid = io_result['valid'] and state_result['valid'] and flow_result['valid']
+    return {
+        'valid':          all_valid,
+        'filepath':       filepath,
+        'io_ownership':   io_result,
+        'state_machines': state_result,
+        'flow_paths':     flow_result
+    }
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        filepath = sys.argv[1]
+        try:
+            with open(filepath) as f:
+                content = f.read()
+        except Exception as e:
+            print(f'Cannot read file: {e}')
+            sys.exit(1)
+        result = validate(filepath, content)
+        print(json.dumps(result, indent=2))
+    else:
+        print('Usage: validate-execution.py <filepath>')

package/src/domain/validate-f-tags.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+validate-f-tags.py - R1 F-tag Completeness Validator
+Validates that F-tags are complete across R-layers
+Config-driven: reads rules from src/config/f-tags.json
+"""
+
+import json
+import re
+import sys
+import subprocess
+from pathlib import Path
+from config_loader import load_f_tag_rules, load_r_layers
+
+
+def extract_ftag_from_message(message):
+    """Extract F-tag and R-layer from commit message [F-name/R#/C#]."""
+    match = re.search(r'\[F-([a-z][a-z0-9-]*)/R([0-4])/C[1-5]\]', message)
+    if match:
+        return f"F-{match.group(1)}", f"R{match.group(2)}"
+    return None, None
+
+
+def get_layers_from_history(f_tag):
+    """Get R-layers already committed for this F-tag from git history."""
+    try:
+        result = subprocess.run(
+            ['git', 'log', '--all', '--pretty=format:%s'],
+            capture_output=True, text=True
+        )
+        layers = set()
+        for line in result.stdout.split('\n'):
+            match = re.search(rf'\[{re.escape(f_tag)}/R([0-4])/C[1-5]\]', line)
+            if match:
+                layers.add(f"R{match.group(1)}")
+        return layers
+    except:
+        return set()
+
+
+def validate_ftag_completeness(f_tag):
+    """Validate that F-tag has required R-layers (config-driven)."""
+    config = load_f_tag_rules()
+    required = set(config['completeness']['required_layers'])
+
+    layers_present = get_layers_from_history(f_tag)
+    missing = required - layers_present
+
+    return {
+        'complete': len(missing) == 0,
+        'f_tag': f_tag,
+        'layers_present': sorted(layers_present),
+        'layers_required': sorted(required),
+        'layers_missing': sorted(missing),
+    }
+
+
+def validate(commit_message):
+    """Main validation function (config-driven)."""
+    config = load_f_tag_rules()
+    f_tag, current_layer = extract_ftag_from_message(commit_message)
+
+    if not f_tag:
+        return {'valid': False, 'error': 'No F-tag found in commit message'}
+
+    if not re.match(config['format']['pattern'], f_tag):
+        return {'valid': False, 'error': f'Invalid F-tag format: {f_tag}'}
+
+    # Include current commit's layer in completeness check
+    result = validate_ftag_completeness(f_tag)
+    layers_present = set(result['layers_present'])
+    if current_layer:
+        layers_present.add(current_layer)
+
+    required = set(config['completeness']['required_layers'])
+    missing = sorted(required - layers_present)
+
+    return {
+        'valid': True,
+        'complete': len(missing) == 0,
+        'f_tag': f_tag,
+        'layers_present': sorted(layers_present),
+        'layers_missing': missing
+    }
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        result = validate(sys.argv[1])
+        print(json.dumps(result, indent=2))
+    else:
+        print("Usage: validate-f-tags.py '<commit message>'")
+

package/src/domain/validate-operations.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+validate-operations.py - R1 O-rule (QC) Validator
+Checks O1, O3, O6, O7 safety rules via pattern matching.
+Pure functions — content passed in by R2, no file I/O here.
+"""
+
+import re
+import sys
+import json
+from config_loader import load_o_rules
+
+
+def check_o1_access_control(filepath, content):
+    """O1: API endpoints must have authentication."""
+    violations = []
+    if '@app.route' in content or '@api.route' in content:
+        if '@auth.require' not in content and '@login_required' not in content:
+            violations.append('O1: API endpoint missing authentication decorator')
+    return violations
+
+
+def check_o3_reliability(filepath, content):
+    """O3: Network calls must have error handling."""
+    violations = []
+    network_patterns = [r'requests\.(get|post|put|delete)', r'fetch\(', r'axios\.']
+    for pattern in network_patterns:
+        if re.search(pattern, content):
+            if 'try:' not in content and 'except' not in content:
+                violations.append('O3: Network call without error handling')
+            break
+    return violations
+
+
+def check_o6_configuration(filepath, content):
+    """O6: No hardcoded secrets."""
+    violations = []
+    secret_patterns = [
+        r'API_KEY\s*=\s*["\']sk-',
+        r'PASSWORD\s*=\s*["\'].+["\']',
+        r'SECRET\s*=\s*["\'].+["\']',
+    ]
+    for pattern in secret_patterns:
+        if re.search(pattern, content):
+            violations.append('O6: Hardcoded secret detected (use environment variables)')
+            break
+    return violations
+
+
+def check_o7_data_safety(filepath, content):
+    """O7: No SQL injection risk."""
+    violations = []
+    sql_patterns = [
+        r'execute\(f["\'].*{.*}.*["\']',
+        r'execute\(["\'].*%s.*["\'].*%',
+        r'execute\(.*\+.*\)',
+    ]
+    for pattern in sql_patterns:
+        if re.search(pattern, content):
+            violations.append('O7: Possible SQL injection (use parameterized queries)')
+            break
+    return violations
+
+
+def validate(filepath, content):
+    """
+    Main validation function.
+    R2 reads the file via file-io and passes content here.
+    """
+    violations = []
+    violations.extend(check_o1_access_control(filepath, content))
+    violations.extend(check_o3_reliability(filepath, content))
+    violations.extend(check_o6_configuration(filepath, content))
+    violations.extend(check_o7_data_safety(filepath, content))
+    return {
+        'valid':      len(violations) == 0,
+        'filepath':   filepath,
+        'violations': violations
+    }
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        filepath = sys.argv[1]
+        try:
+            with open(filepath) as f:
+                content = f.read()
+        except Exception as e:
+            print(f'Cannot read file: {e}')
+            sys.exit(1)
+        result = validate(filepath, content)
+        if result['valid']:
+            print('✓ No O-rule violations')
+        else:
+            print('✗ O-rule violations:')
+            for v in result['violations']:
+                print(f'  - {v}')
+            sys.exit(1)
+    else:
+        print('Usage: validate-operations.py <filepath>')

package/src/domain/validate-r-layers.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Living Architecture - Dependency Direction Validator
+Validates that code doesn't violate R-layer dependency rules.
+NOW INCLUDES: Circular dependency detection within R-layers
+"""
+
+import sys
+import re
+from pathlib import Path
+from collections import defaultdict, deque
+
+
+def detect_circular_dependencies(files_with_imports):
+    """
+    Detect circular import dependencies.
+    Returns list of cycles if found.
+    """
+    # Build dependency graph
+    graph = defaultdict(set)
+    for filepath, imports in files_with_imports.items():
+        for imp in imports:
+            graph[filepath].add(imp)
+    
+    # Detect cycles using DFS
+    def has_cycle(node, visited, rec_stack, path):
+        visited.add(node)
+        rec_stack.add(node)
+        path.append(node)
+        
+        for neighbor in graph.get(node, []):
+            if neighbor not in visited:
+                if has_cycle(neighbor, visited, rec_stack, path):
+                    return True
+            elif neighbor in rec_stack:
+                # Found cycle
+                cycle_start = path.index(neighbor)
+                return path[cycle_start:] + [neighbor]
+        
+        path.pop()
+        rec_stack.remove(node)
+        return False
+    
+    visited = set()
+    cycles = []
+    
+    for node in graph:
+        if node not in visited:
+            rec_stack = set()
+            path = []
+            cycle = has_cycle(node, visited, rec_stack, path)
+            if cycle:
+                cycles.append(cycle)
+    
+    return cycles
+
+
+def _load_r_layer_rules():
+    """
+    Load dependency rules from R0 config (r-layers.json).
+    Returns (forbidden_deps, r_group_patterns, r_group_names) keyed by directory name.
+    """
+    import json
+    config_path = Path(__file__).parent.parent / 'config' / 'r-layers.json'
+    with open(config_path) as f:
+        config = json.load(f)
+
+    layers = config['layers']        # e.g. {"R0": {"name": "Config", "directory": "config"}}
+    deps   = config['dependencies']  # e.g. {"R0": {"forbidden": ["R1", ...]}}
+
+    # Map directory name → list of forbidden directory names
+    forbidden_deps = {}
+    r_group_patterns = {}
+    r_group_names = {}
+
+    for r_id, layer in layers.items():
+        dirname = layer['directory']
+        forbidden_r_ids = deps.get(r_id, {}).get('forbidden', [])
+        forbidden_dirs  = [layers[r]['directory'] for r in forbidden_r_ids if r in layers]
+
+        forbidden_deps[dirname]    = forbidden_dirs
+        r_group_patterns[dirname]  = [dirname]
+        r_group_names[dirname]     = f"{r_id} {layer['name']}"
+
+    return forbidden_deps, r_group_patterns, r_group_names
+
+
+FORBIDDEN_DEPS, R_GROUP_PATTERNS, R_GROUP_NAMES = _load_r_layer_rules()
+
+def detect_r_group(filepath):
+    """Determine R-group from file path."""
+    path_str = str(filepath).lower()
+
+    for r_group, patterns in R_GROUP_PATTERNS.items():
+        for pattern in patterns:
+            if f'/{pattern}/' in path_str or f'\\{pattern}\\' in path_str:
+                return r_group
+
+    return None
+
+def extract_import_target(line):
+    """Extract the imported module/package path from an import statement."""
+    patterns = [
+        r'from\s+["\']?([^"\']+)["\']?\s+import',     # Python: from X import
+        r'import\s+["\']?([^"\']+)["\']?',             # Python/JS: import X
+        r'require\(["\']([^"\']+)["\']\)',              # JS: require('X')
+        r'use\s+([^;]+);',                             # Rust: use X;
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, line)
+        if match:
+            return match.group(1)
+
+    return None
+
+def detect_import_r_group(import_path):
+    """Determine which R-group an import is targeting."""
+    import_lower = import_path.lower()
+
+    for r_group, patterns in R_GROUP_PATTERNS.items():
+        for pattern in patterns:
+            if pattern in import_lower:
+                return r_group
+
+    return None
+
+def check_file(filepath, content):
+    """
+    Check a single file for dependency violations.
+    R2 reads the file via file-io and passes content here.
+    """
+    violations = []
+
+    source_r_group = detect_r_group(filepath)
+    if not source_r_group:
+        return []
+
+    for line_num, line in enumerate(content.split('\n'), 1):
+        if line.strip().startswith(('#', '//', '/*', '*')):
+            continue
+
+        if any(keyword in line for keyword in ['import', 'from', 'require', 'use']):
+            import_target = extract_import_target(line)
+            if not import_target:
+                continue
+
+            target_r_group = detect_import_r_group(import_target)
+            if not target_r_group:
+                continue
+
+            forbidden = FORBIDDEN_DEPS.get(source_r_group, [])
+            if target_r_group in forbidden:
+                violations.append({
+                    'file':             str(filepath),
+                    'line':             line_num,
+                    'source_r_group':   source_r_group,
+                    'target_r_group':   target_r_group,
+                    'content':          line.strip()
+                })
+
+    return violations
+
+def main():
+    """Scan all source files for dependency violations."""
+    print("Checking dependency direction (D2)")
+    print()
+
+    violations = []
+    file_extensions = ['*.py', '*.js', '*.ts', '*.jsx', '*.tsx', '*.rs', '*.go', '*.java']
+
+    for ext in file_extensions:
+        for filepath in Path('.').rglob(ext):
+            if any(skip in str(filepath) for skip in ['node_modules', 'venv', '.venv', 'build', 'dist', '.git', '__init__.py', 'test-project']):
+                continue
+            violations.extend(check_file(filepath, filepath.read_text(encoding='utf-8', errors='ignore')))
+
+    if violations:
+        print("  ✗ Dependency Direction Violations Found (D2)")
+        print()
+        for v in violations:
+            source_name = R_GROUP_NAMES.get(v['source_r_group'], v['source_r_group'])
+            target_name = R_GROUP_NAMES.get(v['target_r_group'], v['target_r_group'])
+            print(f"  {v['file']}:{v['line']}")
+            print(f"    {source_name} cannot depend on {target_name}")
+            print(f"    > {v['content']}")
+            print()
+
+        print("  Forbidden dependencies:")
+        for source, targets in FORBIDDEN_DEPS.items():
+            source_name = R_GROUP_NAMES.get(source, source)
+            target_names = [R_GROUP_NAMES.get(t, t) for t in targets]
+            print(f"    {source_name}: cannot import from {', '.join(target_names)}")
+        print()
+
+        sys.exit(1)
+    else:
+        print("  ✓ No dependency violations found")
+        sys.exit(0)
+
+if __name__ == '__main__':
+    main()

package/src/exec/__init__.py

@@ -0,0 +1,21 @@
+"""R4 Execution package — auto-discovers .py modules, explicit .js"""
+import sys
+from pathlib import Path
+import importlib.util as _ilu
+
+_dir = Path(__file__).parent
+
+# Bootstrap module-loader first
+_spec = _ilu.spec_from_file_location('exec.module_loader', _dir / 'module-loader.py')
+_ml = _ilu.module_from_spec(_spec)
+sys.modules['exec.module_loader'] = _ml
+_spec.loader.exec_module(_ml)
+module_loader = _ml
+
+# Auto-discover all .py files (except __init__ and module-loader)
+for _f in sorted(_dir.glob('*.py')):
+    if _f.stem in ('__init__', 'module-loader'):
+        continue
+    _name = _f.stem.replace('-', '_')
+    _mod = _ml.load_module(f'exec.{_name}', _f)
+    globals()[_name] = _mod

package/src/exec/file-io.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+file-io.py - R4 File I/O Operations
+Handles file reading and code analysis
+"""
+
+import re
+from pathlib import Path
+
+
+def read_file(filepath):
+    """Read file content."""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.read()
+    except Exception as e:
+        return None
+
+
+def analyze_imports(filepath, language='auto'):
+    """Analyze import statements in a file."""
+    content = read_file(filepath)
+    if not content:
+        return []
+    
+    # Auto-detect language
+    if language == 'auto':
+        ext = Path(filepath).suffix
+        if ext == '.py':
+            language = 'python'
+        elif ext in ['.js', '.jsx', '.ts', '.tsx']:
+            language = 'javascript'
+        else:
+            return []
+    
+    imports = []
+    
+    if language == 'python':
+        # Match: import X, from X import Y
+        for line in content.split('\n'):
+            match = re.match(r'^(?:from\s+(\S+)|import\s+(\S+))', line.strip())
+            if match:
+                imports.append(match.group(1) or match.group(2))
+    
+    elif language == 'javascript':
+        # Match: import X from 'path', const X = require('path')
+        patterns = [
+            r"import\s+.+\s+from\s+['\"](.+)['\"]",
+            r"require\(['\"](.+)['\"]\)"
+        ]
+        for line in content.split('\n'):
+            for pattern in patterns:
+                matches = re.findall(pattern, line)
+                imports.extend(matches)
+    
+    return imports
+
+
+def detect_io_operations(filepath):
+    """Detect I/O operations in code."""
+    content = read_file(filepath)
+    if not content:
+        return []
+    
+    io_patterns = [
+        r'open\(',
+        r'read\(',
+        r'write\(',
+        r'fetch\(',
+        r'axios\.',
+        r'fs\.',
+        r'console\.log',
+        r'print\(',
+        r'document\.',
+        r'window\.',
+    ]
+    
+    operations = []
+    for i, line in enumerate(content.split('\n'), 1):
+        for pattern in io_patterns:
+            if re.search(pattern, line):
+                operations.append({
+                    'line': i,
+                    'type': pattern.strip('\\()'),
+                    'code': line.strip()
+                })
+    
+    return operations
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        filepath = sys.argv[1]
+        print(f"Analyzing: {filepath}")
+        print(f"Imports: {analyze_imports(filepath)}")
+        print(f"I/O ops: {len(detect_io_operations(filepath))}")
+    else:
+        print("Usage: file-io.py <filepath>")

package/src/exec/git-io.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+git-io.py - R4 Git I/O Operations
+Handles git operations needed by R2 validation-workflow.
+"""
+
+import subprocess
+import sys
+import os
+
+
+def run_git_command(args):
+    """Run a git command and return output."""
+    try:
+        result = subprocess.run(
+            ['git'] + args,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        print(f'Git error: {e.stderr}', file=sys.stderr)
+        return None
+
+
+def get_staged_files():
+    """Get list of staged files."""
+    output = run_git_command(['diff', '--staged', '--name-only'])
+    if output:
+        return [f for f in output.split('\n') if f]
+    return []
+
+
+def get_commit_message():
+    """
+    Get the commit message.
+    commit-msg hook passes file path via LA_COMMIT_MSG_FILE env var.
+    Falls back to COMMIT_EDITMSG for other contexts.
+    """
+    msg_file = os.environ.get('LA_COMMIT_MSG_FILE')
+    if msg_file and os.path.exists(msg_file):
+        try:
+            with open(msg_file, 'r') as f:
+                return f.read().strip()
+        except IOError:
+            pass
+
+    try:
+        with open('.git/COMMIT_EDITMSG', 'r') as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        return None
+
+
+if __name__ == '__main__':
+    print('Git I/O Operations')
+    print(f'Staged files: {get_staged_files()}')
+    print(f'Commit message: {get_commit_message()}')