#!/usr/bin/env python3
"""
SMARTGoalValidator v1.2.0
Validates engineering goals against SMART criteria (Specific, Measurable, Achievable, Relevant, Time-bound)
Includes error handling for malformed goal JSON, logs validation results to stdout and file.
"""

import json
import re
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler("goal_validation.log")
    ]
)
logger = logging.getLogger(__name__)

class SMARTValidatorError(Exception):
    """Custom exception for validation failures"""
    pass

class SMARTGoalValidator:
    """Validates individual engineering goals against SMART framework"""

    def __init__(self, min_measurable_threshold: int = 2):
        """
        Args:
            min_measurable_threshold: Minimum number of measurable metrics required per goal
        """
        self.min_measurable = min_measurable_threshold
        self.validation_results: List[Dict] = []

    def _check_specific(self, goal: Dict) -> Tuple[bool, str]:
        """Check if goal is specific (no vague terms like 'improve', 'optimize')"""
        vague_terms = ["improve", "optimize", "enhance", "fix", "update"]
        description = goal.get("description", "").lower()
        for term in vague_terms:
            if term in description:
                return (False, f"Vague term '{term}' found in description")
        if len(description.split()) < 5:
            return (False, "Description too short (less than 5 words)")
        return (True, "Specific criteria met")

    def _check_measurable(self, goal: Dict) -> Tuple[bool, str]:
        """Check if goal has quantifiable metrics"""
        metrics = goal.get("metrics", [])
        if len(metrics) < self.min_measurable:
            return (False, f"Only {len(metrics)} metrics provided, minimum {self.min_measurable}")
        # Check each metric has a target value and unit
        for metric in metrics:
            if "target" not in metric or "unit" not in metric:
                return (False, f"Metric {metric.get('name', 'unknown')} missing target or unit")
            # Try to cast target to numeric
            try:
                float(metric["target"])
            except ValueError:
                return (False, f"Metric target {metric['target']} is not numeric")
        return (True, f"Measurable criteria met with {len(metrics)} metrics")

    def _check_achievable(self, goal: Dict) -> Tuple[bool, str]:
        """Check if goal has required resources allocated"""
        resources = goal.get("allocated_resources", {})
        required = ["headcount", "budget", "tool_access"]
        for req in required:
            if req not in resources:
                return (False, f"Missing required resource: {req}")
        # Check headcount is at least 1 if goal is team-based
        if goal.get("type") == "team" and resources["headcount"] < 1:
            return (False, "Team goal requires at least 1 headcount")
        return (True, "Achievable criteria met")

    def _check_relevant(self, goal: Dict) -> Tuple[bool, str]:
        """Check if goal aligns with team OKRs"""
        team_okrs = goal.get("team_okrs", [])
        goal_okr_id = goal.get("okr_id")
        if not goal_okr_id:
            return (False, "No OKR ID linked to goal")
        if goal_okr_id not in team_okrs:
            return (False, f"OKR ID {goal_okr_id} not in team OKRs")
        return (True, "Relevant criteria met")

    def _check_timebound(self, goal: Dict) -> Tuple[bool, str]:
        """Check if goal has a deadline within 6 months"""
        deadline_str = goal.get("deadline")
        if not deadline_str:
            return (False, "No deadline provided")
        try:
            deadline = datetime.fromisoformat(deadline_str)
        except ValueError:
            return (False, f"Invalid deadline format: {deadline_str}")
        if deadline < datetime.now():
            return (False, "Deadline is in the past")
        if (deadline - datetime.now()) > timedelta(weeks=26):
            return (False, "Deadline more than 6 months out")
        return (True, f"Time-bound criteria met (deadline: {deadline_str})")

    def validate_goal(self, goal: Dict) -> Dict:
        """Validate a single goal against all SMART criteria"""
        results = {
            "goal_id": goal.get("id", "unknown"),
            "description": goal.get("description", ""),
            "passed": True,
            "checks": {}
        }
        try:
            checks = [
                ("specific", self._check_specific),
                ("measurable", self._check_measurable),
                ("achievable", self._check_achievable),
                ("relevant", self._check_relevant),
                ("timebound", self._check_timebound)
            ]
            for check_name, check_func in checks:
                passed, msg = check_func(goal)
                results["checks"][check_name] = {"passed": passed, "message": msg}
                if not passed:
                    results["passed"] = False
            self.validation_results.append(results)
            logger.info(f"Validated goal {results['goal_id']}: {'PASS' if results['passed'] else 'FAIL'}")
            return results
        except Exception as e:
            logger.error(f"Failed to validate goal {results['goal_id']}: {str(e)}")
            raise SMARTValidatorError(f"Validation error: {str(e)}") from e

    def validate_batch(self, goals: List[Dict]) -> List[Dict]:
        """Validate a batch of goals, continue on error"""
        results = []
        for goal in goals:
            try:
                res = self.validate_goal(goal)
                results.append(res)
            except SMARTValidatorError as e:
                logger.warning(f"Skipping invalid goal: {str(e)}")
                continue
        return results

if __name__ == "__main__":
    # Example usage with sample goals
    sample_goals = [
        {
            "id": "goal-001",
            "description": "Reduce API p99 latency for user auth service from 2.4s to 120ms",
            "metrics": [
                {"name": "p99_latency", "target": 120, "unit": "ms"},
                {"name": "request_volume", "target": 10000, "unit": "req/min"}
            ],
            "allocated_resources": {"headcount": 2, "budget": 5000, "tool_access": ["datadog", "prometheus"]},
            "team_okrs": ["okr-2024-q3-eng-001"],
            "okr_id": "okr-2024-q3-eng-001",
            "deadline": "2024-09-30T23:59:59",
            "type": "team"
        },
        {
            "id": "goal-002",
            "description": "Improve database performance",
            "metrics": [{"name": "latency", "target": "fast", "unit": "ms"}],
            "allocated_resources": {"headcount": 0, "budget": 0, "tool_access": []},
            "team_okrs": ["okr-2024-q3-eng-001"],
            "okr_id": "okr-2024-q3-eng-002",
            "deadline": "2025-01-01T23:59:59",
            "type": "team"
        }
    ]

    validator = SMARTGoalValidator(min_measurable_threshold=2)
    try:
        validation_results = validator.validate_batch(sample_goals)
        print(json.dumps(validation_results, indent=2))
    except Exception as e:
        logger.critical(f"Batch validation failed: {str(e)}")
        exit(1)

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "sync"
    "time"
)

// Version of the OKR tracker
const version = "2.4.1"

// OKR represents a quarterly objective key result
type OKR struct {
    ID          string    `json:"id"`
    Name        string    `json:"name"`
    Quarter     string    `json:"quarter"`
    Owner       string    `json:"owner"`
    Progress    float64   `json:"progress"` // 0.0 to 1.0
    KeyResults  []KeyResult `json:"key_results"`
    CreatedAt   time.Time `json:"created_at"`
    UpdatedAt   time.Time `json:"updated_at"`
}

// KeyResult represents a measurable key result under an OKR
type KeyResult struct {
    ID          string  `json:"id"`
    Description string  `json:"description"`
    Target      float64 `json:"target"`
    Current     float64 `json:"current"`
    Unit        string  `json:"unit"`
    Weight      float64 `json:"weight"` // 0.0 to 1.0, sum of all KR weights should be 1.0
}

// OKRTracker manages a collection of OKRs with thread-safe operations
type OKRTracker struct {
    okrs map[string]OKR
    mu   sync.RWMutex
}

// NewOKRTracker initializes a new tracker with empty storage
func NewOKRTracker() *OKRTracker {
    return &OKRTracker{
        okrs: make(map[string]OKR),
    }
}

// AddOKR adds a new OKR to the tracker, returns error if ID already exists
func (t *OKRTracker) AddOKR(o OKR) error {
    t.mu.Lock()
    defer t.mu.Unlock()

    if _, exists := t.okrs[o.ID]; exists {
        return fmt.Errorf("OKR with ID %s already exists", o.ID)
    }

    // Validate KR weights sum to 1.0
    var totalWeight float64
    for _, kr := range o.KeyResults {
        totalWeight += kr.Weight
    }
    if totalWeight < 0.99 || totalWeight > 1.01 {
        return fmt.Errorf("key result weights sum to %f, must be 1.0", totalWeight)
    }

    o.CreatedAt = time.Now()
    o.UpdatedAt = time.Now()
    t.okrs[o.ID] = o
    log.Printf("Added OKR %s: %s", o.ID, o.Name)
    return nil
}

// UpdateKRProgress updates the current value of a key result, recalculates OKR progress
func (t *OKRTracker) UpdateKRProgress(okrID, krID string, newValue float64) error {
    t.mu.Lock()
    defer t.mu.Unlock()

    okr, exists := t.okrs[okrID]
    if !exists {
        return fmt.Errorf("OKR %s not found", okrID)
    }

    krFound := false
    for i := range okr.KeyResults {
        if okr.KeyResults[i].ID == krID {
            okr.KeyResults[i].Current = newValue
            krFound = true
            break
        }
    }
    if !krFound {
        return fmt.Errorf("key result %s not found in OKR %s", krID, okrID)
    }

    // Recalculate overall OKR progress as weighted average of KR progress
    var totalProgress float64
    for _, kr := range okr.KeyResults {
        krProgress := kr.Current / kr.Target
        if krProgress > 1.0 {
            krProgress = 1.0 // Cap at 100%
        }
        totalProgress += krProgress * kr.Weight
    }
    okr.Progress = totalProgress
    okr.UpdatedAt = time.Now()
    t.okrs[okrID] = okr
    log.Printf("Updated OKR %s progress to %.2f%%", okrID, okr.Progress*100)
    return nil
}

// GetOKRProgress returns a summary of all OKRs with progress above a threshold
func (t *OKRTracker) GetOKRProgress(minProgress float64) []map[string]interface{} {
    t.mu.RLock()
    defer t.mu.RUnlock()

    var summaries []map[string]interface{}
    for _, okr := range t.okrs {
        if okr.Progress >= minProgress {
            summaries = append(summaries, map[string]interface{}{
                "id":       okr.ID,
                "name":     okr.Name,
                "quarter":  okr.Quarter,
                "progress": fmt.Sprintf("%.2f%%", okr.Progress*100),
                "owner":    okr.Owner,
            })
        }
    }
    return summaries
}

// ExportToJSON exports all OKRs to a JSON file
func (t *OKRTracker) ExportToJSON(filepath string) error {
    t.mu.RLock()
    defer t.mu.RUnlock()

    data, err := json.MarshalIndent(t.okrs, "", "  ")
    if err != nil {
        return fmt.Errorf("failed to marshal OKRs: %w", err)
    }

    err = os.WriteFile(filepath, data, 0644)
    if err != nil {
        return fmt.Errorf("failed to write file: %w", err)
    }
    log.Printf("Exported %d OKRs to %s", len(t.okrs), filepath)
    return nil
}

func main() {
    tracker := NewOKRTracker()

    // Add sample OKR
    sampleOKR := OKR{
        ID:      "okr-2024-q3-eng-001",
        Name:    "Reduce auth service latency to improve user retention",
        Quarter: "2024-Q3",
        Owner:   "jane.doe@example.com",
        KeyResults: []KeyResult{
            {
                ID:          "kr-001",
                Description: "Reduce p99 auth latency from 2.4s to 120ms",
                Target:      120,
                Current:     2100,
                Unit:        "ms",
                Weight:      0.6,
            },
            {
                ID:          "kr-002",
                Description: "Increase auth success rate from 98.2% to 99.9%",
                Target:      99.9,
                Current:     98.2,
                Unit:        "%",
                Weight:      0.4,
            },
        },
    }

    if err := tracker.AddOKR(sampleOKR); err != nil {
        log.Fatalf("Failed to add sample OKR: %v", err)
    }

    // Update KR progress
    if err := tracker.UpdateKRProgress("okr-2024-q3-eng-001", "kr-001", 150); err != nil {
        log.Fatalf("Failed to update KR progress: %v", err)
    }

    // Get progress summary
    summaries := tracker.GetOKRProgress(0.0)
    for _, s := range summaries {
        fmt.Printf("OKR %s: %s (Progress: %s)\n", s["id"], s["name"], s["progress"])
    }

    // Export to JSON
    if err := tracker.ExportToJSON("okr_export.json"); err != nil {
        log.Fatalf("Failed to export OKRs: %v", err)
    }
}

/**
 * GoalBenchmarker v0.9.0
 * Compares performance of in-memory vs Redis-backed goal tracking for high-throughput engineering teams
 * Includes statistical analysis of latency, throughput, and error rates
 */

import { createClient, RedisClientType } from 'redis';
import { randomUUID } from 'crypto';
import { promisify } from 'util';

// Configuration
const BENCHMARK_DURATION_MS = 30_000; // 30 second benchmark
const CONCURRENT_WORKERS = 10;
const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';

// In-memory goal store (for comparison)
class InMemoryGoalStore {
  private goals: Map = new Map();

  async set(goal: Goal): Promise {
    this.goals.set(goal.id, goal);
  }

  async get(id: string): Promise {
    return this.goals.get(id);
  }

  async delete(id: string): Promise {
    return this.goals.delete(id);
  }

  async size(): Promise {
    return this.goals.size;
  }
}

// Redis-backed goal store
class RedisGoalStore {
  private client: RedisClientType;

  constructor(client: RedisClientType) {
    this.client = client;
  }

  async set(goal: Goal): Promise {
    await this.client.hSet(`goal:${goal.id}`, {
      id: goal.id,
      description: goal.description,
      progress: goal.progress.toString(),
      owner: goal.owner,
      createdAt: goal.createdAt.toISOString(),
    });
  }

  async get(id: string): Promise {
    const data = await this.client.hGetAll(`goal:${id}`);
    if (Object.keys(data).length === 0) return undefined;
    return {
      id: data.id,
      description: data.description,
      progress: parseFloat(data.progress),
      owner: data.owner,
      createdAt: new Date(data.createdAt),
    };
  }

  async delete(id: string): Promise {
    const result = await this.client.del(`goal:${id}`);
    return result === 1;
  }

  async size(): Promise {
    const keys = await this.client.keys('goal:*');
    return keys.length;
  }
}

// Goal type definition
interface Goal {
  id: string;
  description: string;
  progress: number;
  owner: string;
  createdAt: Date;
}

// Benchmark metrics
interface BenchmarkMetrics {
  totalOperations: number;
  successfulOperations: number;
  failedOperations: number;
  avgLatencyMs: number;
  p99LatencyMs: number;
  throughputOpsPerSec: number;
}

// Helper to generate random goals
function generateRandomGoal(): Goal {
  return {
    id: randomUUID(),
    description: `Reduce latency for service ${randomUUID().slice(0, 8)}`,
    progress: Math.random(),
    owner: `user-${Math.floor(Math.random() * 1000)}@example.com`,
    createdAt: new Date(),
  };
}

// Run benchmark for a given store
async function runBenchmark(
  store: InMemoryGoalStore | RedisGoalStore,
  storeName: string
): Promise {
  const latencies: number[] = [];
  let successful = 0;
  let failed = 0;
  const startTime = Date.now();

  // Run concurrent workers
  const workers = Array.from({ length: CONCURRENT_WORKERS }, async () => {
    while (Date.now() - startTime < BENCHMARK_DURATION_MS) {
      const goal = generateRandomGoal();
      const opStart = Date.now();
      try {
        await store.set(goal);
        const retrieved = await store.get(goal.id);
        if (!retrieved) throw new Error('Failed to retrieve goal');
        await store.delete(goal.id);
        successful++;
        latencies.push(Date.now() - opStart);
      } catch (err) {
        failed++;
        console.error(`Benchmark error for ${storeName}:`, err);
      }
    }
  });

  await Promise.all(workers);

  const totalTimeSec = (Date.now() - startTime) / 1000;
  const sortedLatencies = latencies.sort((a, b) => a - b);
  const p99Index = Math.floor(sortedLatencies.length * 0.99);

  return {
    totalOperations: successful + failed,
    successfulOperations: successful,
    failedOperations: failed,
    avgLatencyMs: latencies.reduce((a, b) => a + b, 0) / latencies.length,
    p99LatencyMs: sortedLatencies[p99Index] || 0,
    throughputOpsPerSec: successful / totalTimeSec,
  };
}

// Main benchmark execution
async function main() {
  // Initialize stores
  const inMemoryStore = new InMemoryGoalStore();
  let redisClient: RedisClientType | undefined;
  let redisStore: RedisGoalStore | undefined;

  try {
    // Run in-memory benchmark
    console.log('Running in-memory benchmark...');
    const inMemoryMetrics = await runBenchmark(inMemoryStore, 'In-Memory');
    console.log('In-Memory Results:', inMemoryMetrics);

    // Initialize Redis
    redisClient = createClient({ url: REDIS_URL });
    await redisClient.connect();
    redisStore = new RedisGoalStore(redisClient);
    console.log('Running Redis benchmark...');
    const redisMetrics = await runBenchmark(redisStore, 'Redis');
    console.log('Redis Results:', redisMetrics);

    // Print comparison table
    console.log('\n=== Benchmark Comparison ===');
    console.log('Metric\t\tIn-Memory\tRedis');
    console.log(`Throughput (ops/s)\t${inMemoryMetrics.throughputOpsPerSec.toFixed(2)}\t\t${redisMetrics.throughputOpsPerSec.toFixed(2)}`);
    console.log(`Avg Latency (ms)\t${inMemoryMetrics.avgLatencyMs.toFixed(2)}\t\t${redisMetrics.avgLatencyMs.toFixed(2)}`);
    console.log(`P99 Latency (ms)\t${inMemoryMetrics.p99LatencyMs.toFixed(2)}\t\t${redisMetrics.p99LatencyMs.toFixed(2)}`);
    console.log(`Error Rate\t\t${(inMemoryMetrics.failedOperations / inMemoryMetrics.totalOperations * 100).toFixed(2)}%\t\t${(redisMetrics.failedOperations / redisMetrics.totalOperations * 100).toFixed(2)}%`);
  } catch (err) {
    console.error('Benchmark failed:', err);
    process.exit(1);
  } finally {
    if (redisClient) await redisClient.quit();
  }
}

// Execute if run directly
if (require.main === module) {
  main();
}

# Weekly audit script snippet
import json
from smart_validator import SMARTGoalValidator

validator = SMARTGoalValidator(min_measurable_threshold=2)
with open("sprint-goals.json") as f:
    goals = json.load(f)
results = validator.validate_batch(goals)
failed = [r for r in results if not r["passed"]]
if failed:
    print(f"FAIL: {len(failed)} goals failed SMART validation")
    exit(1)
else:
    print("All goals passed SMART validation")
    exit(0)

# OKR traceability snippet from okr-master config
okrs:
  - id: okr-2024-q3-eng-001
    name: Improve auth service reliability
    company_objective: Increase user retention by 5%
goals:
  - id: goal-001
    description: Reduce auth p99 latency to 120ms
    okr_id: okr-2024-q3-eng-001
    owner: jane.doe
  - id: goal-002
    description: Increase auth success rate to 99.9%
    okr_id: okr-2024-q3-eng-001
    owner: jane.doe

# GitHub Actions workflow snippet for goal CI checks
name: Goal CI
on:
  push:
    paths:
      - 'goals/**'
  pull_request:
    paths:
      - 'goals/**'

jobs:
  validate-goals:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - run: pip install smart-goal-validator
      - run: |
          for file in goals/*.json; do
            smart-validator "$file" || exit 1
          done
      - run: python scripts/check-progress.py
        env:
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}