create-living-architecture 1.0.8 → 2.0.0

package/src/config/r-layers.json

@@ -0,0 +1,111 @@
+{
+  "version": "2.0.0",
+  "enforcement_mode": "blocking",
+  "layers": {
+    "R0": {
+      "name": "Config",
+      "directory": "config",
+      "required": false
+    },
+    "R1": {
+      "name": "Domain",
+      "directory": "domain",
+      "required": false
+    },
+    "R2": {
+      "name": "Application",
+      "directory": "app",
+      "required": false
+    },
+    "R3": {
+      "name": "Contract",
+      "directory": "contract",
+      "required": true
+    },
+    "R4": {
+      "name": "Execution",
+      "directory": "exec",
+      "required": true
+    }
+  },
+  "dependencies": {
+    "R0": {
+      "allowed": [],
+      "forbidden": ["R1", "R2", "R3", "R4"]
+    },
+    "R1": {
+      "allowed": ["R0"],
+      "forbidden": ["R2", "R3", "R4"]
+    },
+    "R2": {
+      "allowed": ["R0", "R1", "R4"],
+      "forbidden": ["R3"]
+    },
+    "R3": {
+      "allowed": ["R0", "R1", "R2"],
+      "forbidden": ["R4"]
+    },
+    "R4": {
+      "allowed": ["R0"],
+      "forbidden": ["R1", "R2", "R3"]
+    }
+  },
+  "skip_matrix": {
+    "R0": {
+      "add_when": "configuration_concerns > 5",
+      "skip_if": "all config fits in .env"
+    },
+    "R1": {
+      "add_when": "business_rules > 10",
+      "skip_if": "simple CRUD app"
+    },
+    "R2": {
+      "add_when": "workflows > 3 or state_machines",
+      "skip_if": "direct handlers work"
+    },
+    "R3": {
+      "add_when": "always",
+      "skip_if": "never"
+    },
+    "R4": {
+      "add_when": "always",
+      "skip_if": "never"
+    }
+  },
+  "evolution_phases": [
+    {
+      "phase": "tiny",
+      "active": ["R3", "R4"]
+    },
+    {
+      "phase": "small",
+      "active": ["R1", "R2", "R3", "R4"]
+    },
+    {
+      "phase": "growing",
+      "active": ["R0", "R1", "R2", "R3", "R4"]
+    },
+    {
+      "phase": "enterprise",
+      "active": ["R0", "R1", "R2", "R3", "R4"]
+    }
+  ],
+  "commit_format": {
+    "pattern": "^\\[F-[a-z][a-z0-9-]*/R[0-4]/C[1-5]\\]",
+    "layer_codes": {
+      "R0": "Config",
+      "R1": "Domain",
+      "R2": "Application",
+      "R3": "Contract",
+      "R4": "Execution"
+    },
+    "classification_codes": {
+      "C1": "Internal",
+      "C2": "Feature",
+      "C3": "Contract",
+      "C4": "Structure",
+      "C5": "Migration"
+    },
+    "feature_tag": "required, F-kebab-case, groups commits into vertical slices"
+  }
+}

package/src/contract/cli/la-new.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+#
+# la-new.sh - R3 Contract (local installer)
+# Usage: ./la-new.sh <project-name>
+#
+
+LA_DIR="$(cd "$(dirname "$0")/../../.." && pwd)"
+
+BORDER="════════════════════════════════════════════════════════════"
+
+if [ -z "$1" ]; then
+    echo "Usage: ./la-new.sh <project-name>"
+    echo "Example: ./la-new.sh my-app"
+    exit 1
+fi
+
+PROJECT_NAME="$1"
+
+if [ -d "$PROJECT_NAME" ]; then
+    echo "✗ Directory '$PROJECT_NAME' already exists"
+    exit 1
+fi
+
+echo ""
+echo "$BORDER"
+printf "%*s\n" $(( (${#BORDER} + 18) / 2 )) "LIVING ARCHITECTURE"
+echo "$BORDER"
+echo ""
+echo "  Creating project: $PROJECT_NAME"
+
+# Copy LA structure
+mkdir -p "$PROJECT_NAME"
+cp -r "$LA_DIR/src"          "$PROJECT_NAME/src"
+cp -r "$LA_DIR/.living-arch" "$PROJECT_NAME/.living-arch"
+
+# Init git
+git init "$PROJECT_NAME" --quiet
+
+# Hook up pre-commit and commit-msg
+chmod +x "$PROJECT_NAME/src/contract/hooks/pre-commit"
+chmod +x "$PROJECT_NAME/src/contract/hooks/commit-msg"
+
+ln -sf "$(pwd)/$PROJECT_NAME/src/contract/hooks/pre-commit" \
+       "$PROJECT_NAME/.git/hooks/pre-commit"
+
+ln -sf "$(pwd)/$PROJECT_NAME/src/contract/hooks/commit-msg" \
+       "$PROJECT_NAME/.git/hooks/commit-msg"
+
+# Initial commit — skip validation, this is scaffolding not app code
+cd "$PROJECT_NAME"
+git add .
+git commit --no-verify -m "LA v2.0 scaffold" --quiet
+cd ..
+
+echo ""
+echo "  ✓ Project created: $PROJECT_NAME/"
+echo "  ✓ Git initialized"
+echo "  ✓ Hooks installed"
+echo "  ✓ Initial commit done"
+echo ""
+echo "  Ready:  cd $PROJECT_NAME"
+echo ""
+echo "$BORDER"
+echo ""

package/src/contract/cli/network-scan.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+network-scan.py - R3 CLI Interface
+Project health scanning with progressive zoom
+
+Usage:
+  network-scan.py                     # All features
+  network-scan.py F-counter           # Feature detail
+  network-scan.py F-counter R1        # Layer detail
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../..'))
+
+from domain import validate_f_tags, la_output
+from app import validation_workflow
+import re
+import subprocess
+
+# F-tags to exclude from feature scans (infrastructure, not features)
+EXCLUDED_TAGS = {'F-la'}
+
+
+def _git(args):
+    """Run a git command, return stripped stdout or empty string."""
+    try:
+        r = subprocess.run(['git'] + args, capture_output=True, text=True)
+        return r.stdout.strip()
+    except Exception:
+        return ''
+
+
+def _get_commits_with_ftag_and_layer(f_tag, r_layer):
+    pattern = f'\\[{f_tag}/{r_layer}/'
+    out = _git(['log', '--all', '--pretty=format:%h %s', '--grep', pattern])
+    return [l for l in out.split('\n') if l] if out else []
+
+
+def _get_commits_with_ftag(f_tag):
+    out = _git(['log', '--all', '--grep', f_tag, '--oneline'])
+    return [l for l in out.split('\n') if l] if out else []
+
+
+def _get_files_for_ftag_and_layer(f_tag, r_layer):
+    pattern = f'\\[{f_tag}/{r_layer}/'
+    out = _git(['log', '--all', '--pretty=format:', '--name-only', '--grep', pattern])
+    if out:
+        return sorted({l.strip() for l in out.split('\n') if l.strip()})
+    return []
+
+
+def get_all_ftags():
+    try:
+        result = subprocess.run(
+            ['git', 'log', '--all', '--pretty=format:%s'],
+            capture_output=True, text=True
+        )
+        f_tags = set()
+        for line in result.stdout.split('\n'):
+            match = re.search(r'\[F-([a-z][a-z0-9-]*)/R[0-4]/C[1-5]\]', line)
+            if match:
+                tag = f"F-{match.group(1)}"
+                if tag not in EXCLUDED_TAGS:
+                    f_tags.add(tag)
+        return sorted(f_tags)
+    except:
+        return []
+
+
+def scan_all_features():
+    print(la_output.header('NETWORK SCAN'))
+
+    f_tags = get_all_ftags()
+
+    if not f_tags:
+        print("  No features detected")
+    else:
+        for f_tag in f_tags:
+            result = validate_f_tags.validate_ftag_completeness(f_tag)
+            if result['complete']:
+                print(f"  {f_tag:20}{la_output.ok('complete')}")
+            else:
+                missing = ', '.join(result['layers_missing'])
+                print(f"  {f_tag:20}{la_output.warn(f'missing {missing}')}")
+
+    print()
+    print(f"  {len(f_tags)} feature{'s' if len(f_tags) != 1 else ''} detected")
+    print()
+    print(la_output.divider())
+
+
+def scan_feature(f_tag):
+    print(la_output.header(f'{f_tag.upper()} FEATURE'))
+
+    result = validate_f_tags.validate_ftag_completeness(f_tag)
+
+    # R-layers
+    if result['complete']:
+        print(f"  {'R-layers':14}{la_output.ok('complete')}")
+    else:
+        missing = ', '.join(result['layers_missing'])
+        present = len(result['layers_present'])
+        total   = len(result['layers_required'])
+        print(f"  {'R-layers':14}{la_output.warn(f'{present}/{total} — missing {missing}')}")
+
+    # Execution + QC — get real files for this feature, run validators via R2
+    feature_files = []
+    for layer in result['layers_present']:
+        feature_files.extend(_get_files_for_ftag_and_layer(f_tag, layer))
+    feature_files = sorted(set(feature_files))
+
+    val = validation_workflow.validate_files(feature_files)
+    exec_val = val['execution']
+    qc_val   = val['qc']
+
+    print(f"  {'Execution':14}{la_output.ok('') if exec_val['valid'] else la_output.err('')}")
+    if qc_val['valid']:
+        print(f"  {'QC':14}{la_output.ok('')}")
+    else:
+        violations = qc_val.get('violations', [])
+        print(f"  {'QC':14}{la_output.err(violations[0] if violations else 'violation')}")
+
+    # Activity
+    total_commits = _get_commits_with_ftag(f_tag)
+    n = len(total_commits)
+    print(f"  {'Activity':14}{n} commit{'s' if n != 1 else ''}")
+
+    print()
+
+    # Layer drill-down hints
+    for layer in sorted(result['layers_present']):
+        commits = _get_commits_with_ftag_and_layer(f_tag, layer)
+        print(f"  {layer:14}{len(commits)} commit{'s' if len(commits) != 1 else ''}"
+              f"  →  network-scan.py {f_tag} {layer}")
+
+    print()
+    print(la_output.divider())
+def get_layer_detail(f_tag, r_layer):
+    """Get files and commits for a specific F-tag + R-layer."""
+    commits = _get_commits_with_ftag_and_layer(f_tag, r_layer)
+    files   = _get_files_for_ftag_and_layer(f_tag, r_layer)
+    return {'f_tag': f_tag, 'r_layer': r_layer, 'commits': commits, 'files': files}
+
+
+def scan_layer(f_tag, r_layer):
+    print(la_output.header(f'{f_tag.upper()} / {r_layer}'))
+
+    detail = get_layer_detail(f_tag, r_layer)
+
+    # Files
+    if detail['files']:
+        print(f"  {'Files':14}")
+        for f in detail['files']:
+            print(f"    {f}")
+    else:
+        print(f"  {'Files':14}none found")
+
+    print()
+
+    # Commits
+    if detail['commits']:
+        print(f"  {'Commits':14}")
+        for c in detail['commits']:
+            print(f"    {c}")
+    else:
+        print(f"  {'Commits':14}none found")
+
+    print()
+    print(la_output.divider())
+
+
+def main():
+    if len(sys.argv) == 1:
+        scan_all_features()
+    elif len(sys.argv) == 2:
+        f_tag = sys.argv[1]
+        if not f_tag.startswith('F-'):
+            f_tag = f'F-{f_tag}'
+        scan_feature(f_tag)
+    elif len(sys.argv) == 3:
+        f_tag = sys.argv[1]
+        r_layer = sys.argv[2].upper()
+        if not f_tag.startswith('F-'):
+            f_tag = f'F-{f_tag}'
+        scan_layer(f_tag, r_layer)
+    else:
+        print("Usage:")
+        print("  network-scan.py                  # All features")
+        print("  network-scan.py F-counter        # Feature detail")
+        print("  network-scan.py F-counter R1     # Layer detail")
+
+
+if __name__ == "__main__":
+    main()

package/src/contract/hooks/commit-msg

@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# commit-msg - Living Architecture validation hook  
+# Receives commit message file as $1, validates format and F-tags
+#
+
+cd "$(git rev-parse --show-toplevel)" || exit 1
+
+if [ ! -f "src/app/validation-workflow.py" ]; then
+    exit 0
+fi
+
+# Pass message file path so workflow can read it
+export LA_COMMIT_MSG_FILE="$1"
+
+python3 src/app/validation-workflow.py
+exit $?

package/src/contract/hooks/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/bash
+# pre-commit - Living Architecture
+# Validation runs in commit-msg hook where message is available.
+exit 0

package/src/domain/__init__.py

@@ -0,0 +1,20 @@
+"""R1 Domain package — auto-discovers .py modules
+Bootstrap exception: imports module_loader from R4 (exec) to load hyphenated filenames.
+This is a package-init-only exception; no other R1 file may import from R4.
+"""
+import sys
+from pathlib import Path
+from exec import module_loader
+
+_dir = Path(__file__).parent
+
+if str(_dir) not in sys.path:
+    sys.path.insert(0, str(_dir))
+
+# Auto-discover all .py files (except __init__)
+for _f in sorted(_dir.glob('*.py')):
+    if _f.stem == '__init__':
+        continue
+    _name = _f.stem.replace('-', '_')
+    _mod = module_loader.load_module(f'domain.{_name}', _f)
+    globals()[_name] = _mod

package/src/domain/config_loader.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+config_loader.py - R1 Helper
+Loads configuration from R0 config files
+Validators use this to stay config-driven
+"""
+
+import json
+from pathlib import Path
+
+
+def load_r_layers():
+    """Load R-layer definitions from config"""
+    config_path = Path(__file__).parent.parent / 'config' / 'r-layers.json'
+    with open(config_path) as f:
+        config = json.load(f)
+    return config['layers']
+
+
+def get_valid_r_layer_ids():
+    """Get list of valid R-layer IDs"""
+    layers = load_r_layers()
+    return list(layers.keys())
+
+
+def load_f_tag_rules():
+    """Load F-tag format and completeness rules"""
+    config_path = Path(__file__).parent.parent / 'config' / 'f-tags.json'
+    with open(config_path) as f:
+        return json.load(f)
+
+
+def load_c_codes():
+    """Load C-code definitions"""
+    config_path = Path(__file__).parent.parent / 'config' / 'changes.json'
+    with open(config_path) as f:
+        return json.load(f)
+
+
+def get_valid_c_codes():
+    """Get list of valid C-codes"""
+    config = load_c_codes()
+    return list(config['codes'].keys())
+
+
+def load_o_rules():
+    """Load O-rule definitions"""
+    config_path = Path(__file__).parent.parent / 'config' / 'operations.json'
+    with open(config_path) as f:
+        return json.load(f)
+
+
+def load_module_config():
+    """Load module configuration"""
+    config_path = Path(__file__).parent.parent / 'config' / 'modules.json'
+    with open(config_path) as f:
+        return json.load(f)
+
+
+def get_module_from_filepath(filepath):
+    """
+    Extract module name from filepath using naming convention.
+    Convention: {module}-{component}.ext
+    
+    Examples:
+      auth-login.py → "M-auth"
+      payment-process.py → "M-payment"
+      user.py → None (no module prefix)
+    
+    Returns:
+      str: Module name (e.g., "M-auth") or None if no convention used
+    """
+    # Check if module detection is enabled
+    config = load_module_config()
+    if not config.get('enabled', False):
+        return None
+    
+    filename = Path(filepath).stem  # "auth-login.py" → "auth-login"
+    
+    if '-' in filename:
+        module = filename.split('-')[0]
+        return f"M-{module}"
+    
+    return None

package/src/domain/installer-logic.js

@@ -0,0 +1,30 @@
+/**
+ * installer-logic.js - R1 Domain
+ * Pure scaffold logic. No I/O. Determines what to create and where.
+ */
+
+function validateProjectName(name) {
+    if (!name || typeof name !== 'string') {
+        return { valid: false, error: 'Project name required' };
+    }
+    if (!/^[a-z0-9-_]+$/i.test(name)) {
+        return { valid: false, error: 'Project name must be alphanumeric (hyphens/underscores allowed)' };
+    }
+    return { valid: true };
+}
+
+function buildScaffoldPlan(projectName, laSourceDir) {
+    return {
+        projectName,
+        targetDir:  projectName,
+        laSourceDir,
+        hooks: {
+            preCommit: {
+                src:  `${laSourceDir}/src/contract/hooks/pre-commit`,
+                dest: `${projectName}/.git/hooks/pre-commit`
+            }
+        }
+    };
+}
+
+module.exports = { validateProjectName, buildScaffoldPlan };

package/src/domain/la-output.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+la-output.py - R1 Domain
+Standard output formatting for all LA interfaces.
+Single source of truth for borders, colors, width.
+"""
+
+WIDTH = 60
+BORDER = '═' * WIDTH
+
+# ANSI colors
+PURPLE = '\033[94m'
+BOLD   = '\033[1m'
+GREEN  = '\033[92m'
+YELLOW = '\033[93m'
+RED    = '\033[91m'
+RESET  = '\033[0m'
+
+
+def header(text):
+    """Centered header with double-line borders."""
+    return (
+        f"\n{PURPLE}{BOLD}{BORDER}{RESET}\n"
+        f"{PURPLE}{BOLD}{text:^{WIDTH}}{RESET}\n"
+        f"{PURPLE}{BOLD}{BORDER}{RESET}\n"
+    )
+
+
+def divider():
+    return f"{PURPLE}{BORDER}{RESET}"
+
+
+def ok(text):
+    return f"{GREEN}✓{RESET} {text}"
+
+
+def warn(text):
+    return f"{YELLOW}⚠{RESET} {text}"
+
+
+def err(text):
+    return f"{RED}✗{RESET} {text}"
+
+
+def bold(text):
+    return f"{BOLD}{text}{RESET}"

package/src/domain/validate-changes.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""
+validate-changes.py - R1 C-code Validator
+Validates C-code format in commit messages
+Config-driven: reads valid codes from src/config/changes.json
+"""
+
+import re
+import sys
+from config_loader import get_valid_c_codes
+
+
+def validate_c_code_format(commit_message):
+    """
+    Validate that commit message has valid C-code.
+    Only checks format (C1-C5), not semantic correctness.
+    """
+    # Extract C-code from message
+    match = re.search(r'/C([1-5])\]', commit_message)
+    
+    if not match:
+        return {
+            'valid': False,
+            'error': 'No C-code found in format [F-*/R*/C#]'
+        }
+    
+    c_code = f"C{match.group(1)}"
+    
+    # Check against config
+    valid_codes = get_valid_c_codes()
+    
+    if c_code not in valid_codes:
+        return {
+            'valid': False,
+            'error': f'Invalid C-code: {c_code}. Must be one of: {", ".join(valid_codes)}'
+        }
+    
+    return {
+        'valid': True,
+        'c_code': c_code
+    }
+
+
+def validate(commit_message):
+    """Main validation function (config-driven)"""
+    return validate_c_code_format(commit_message)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        message = sys.argv[1]
+        result = validate(message)
+        
+        if result['valid']:
+            print(f"✓ C-code valid: {result['c_code']}")
+        else:
+            print(f"✗ {result['error']}")
+            sys.exit(1)
+    else:
+        print("Usage: validate-changes.py '<commit message>'")