ATOM Documentation

- name: Run frontend tests
  run: npm test -- --run --reporter=verbose

- name: Run backend tests
  run: |
    cd backend-saas
    python3 -m pytest -v --tb=short --cov=. --cov-report=xml

- name: Check backend coverage
  run: |
    coverage_report=$(python3 -c "...")
    if (( $(echo "$coverage_report < 90" | bc -l) )); then
      echo "::error::Backend coverage $coverage_report% is below 90% threshold"
      exit 1
    fi

# Frontend coverage
open coverage/index.html

# Backend coverage
open backend-saas/htmlcov/index.html

# View coverage report
cat backend-saas/coverage.xml

- name: Check frontend duplication
  run: |
    jscpd src --format "typescript,tsx" --threshold 5

- name: Check backend duplication
  run: |
    pylint --disable=all --enable=similarities \
      --similarities-line-count-threshold=50 \
      --min-similarity-lines=50

# Run redundancy detection
cd backend-saas
python3 scripts/detect_redundancy.py \
  --frontend ../src \
  --backend .

# Review report
cat .planning/phases/298-frontend-backend-unification/redundancy-report.md

# Refactor to remove duplicates

- name: Check for `any` types in API layer
  run: |
    any_count=$(grep -r ": any\|<any>" src/lib/api --include="*.ts" | wc -l)
    if [ "$any_count" -gt 0 ]; then
      echo "::error::Found $any_count instances of `any` type in API layer"
      exit 1
    fi

// Before (bad)
async function createAgent(data: any): Promise<any> { ... }

// After (good)
interface CreateAgentRequest {
  name: string;
  maturity: MaturityLevel;
  capabilities: string[];
}

interface AgentResponse {
  id: string;
  name: string;
  maturity: MaturityLevel;
  capabilities: string[];
}

async function createAgent(
  data: CreateAgentRequest
): Promise<AgentResponse> { ... }

try {
  await riskyOperation();
} catch (error: any) {
  // error: any is acceptable here
  console.error(error.message);
}

- name: Run contract tests
  run: npm test -- src/lib/api/__tests__/contract-tests --run

- name: Run property-based tests
  run: npm test -- src/lib/api/__tests__/property-based --run

- name: Run fuzz tests
  run: npm test -- src/lib/api/__tests__/fuzzy --run

- name: Run concurrency tests
  run: npm test -- src/lib/api/__tests__/concurrency --run

- name: Run E2E workflow tests
  run: npm test -- src/lib/api/__tests__/integration --run

- name: Run performance benchmarks
  run: npm test -- src/lib/api/__tests__/performance --run

- name: Run Phase 298 verification
  run: |
    python3 backend-saas/scripts/verify-phase-298.py \
      --output .planning/phases/298-frontend-backend-unification/phase-298-verification-report.md

- name: Post status to PR
  uses: actions/github-script@v7
  with:
    script: |
      const status = /* check all jobs */;
      const body = `## Regression Prevention Results\n\n${emoji} **Overall Status**: ${status ? 'PASSED' : 'FAILED'}`;
      github.rest.issues.createComment({ issue_number: context.issue.number, body });

# .husky/pre-commit
any_count=$(find src/lib/api -name "*.ts" -o -name "*.tsx" | \
  xargs grep -h ": any\|<any>" 2>/dev/null | \
  grep -v "error: any" | \
  grep -v "// " | \
  grep -v "/\*" | \
  wc -l | tr -d ' ')

if [ "$any_count" -gt 0 ]; then
  echo "  ❌ Found $any_count instances of \`any\` type in API layer"
  exit 1
fi

git commit --no-verify -m "feat: add feature"

# .husky/pre-commit
if [ -f "backend-saas/hooks/pre-commit" ]; then
  cd backend-saas && bash hooks/pre-commit
fi

// Get current metrics
import { qualityMetricsAPI } from '@/lib/monitoring/quality-metrics';

const report = await qualityMetricsAPI.getCurrentMetrics();
console.log('Overall score:', report.overallScore);
console.log('Metrics:', report.metrics);
console.log('Recommendations:', report.recommendations);

// Check for regressions
const regressions = await qualityMetricsAPI.checkRegressions();
if (regressions.length > 0) {
  console.error('Regressions detected:', regressions);
}

// Get metric history
const history = await qualityMetricsAPI.getMetricHistory('frontend_coverage', 30);
console.log('30-day history:', history);

// Get metrics trend
const trends = await qualityMetricsAPI.getMetricsTrend(
  ['frontend_coverage', 'backend_coverage', 'code_duplication'],
  7
);
console.log('7-day trends:', trends);

# Run verification script
cd backend-saas
python3 scripts/verify-phase-298.py

# View report
cat .planning/phases/298-frontend-backend-unification/phase-298-verification-report.md

# View recent commits
git log --oneline -20

# View diff for suspicious commit
git show <commit-hash>

# Bisect to find breaking commit
git bisect start
git bisect bad HEAD
git bisect good <last-known-good-commit>
git bisect run python3 scripts/verify-phase-298.py

# Create fix branch
git checkout -b fix/regression-<issue>

# Implement fix
# ...

# Test fix
python3 scripts/verify-phase-298.py

# Commit fix
git add .
git commit -m "fix(<plan>): resolve regression in <feature>"

// Add test to prevent regression
describe('Regression Test for Issue #123', () => {
  it('should not lose precision when serializing ACU values', async () => {
    const acu = 0.1 + 0.2;  // 0.30000000000000004
    const serialized = serializeACU(acu);
    expect(serialized).toBe('0.30');  // Precision preserved
  });
});

# Run all tests
npm test && cd backend-saas && pytest

# Run verification script
python3 scripts/verify-phase-298.py

# Push fix
git push origin fix/regression-<issue>

# ❌ Bad: Skip tests
git commit --no-verify -m "feat: add feature"

# ✅ Good: Fix tests
# Fix broken tests first
git commit -m "feat: add feature"

# ❌ Bad: Ignore regression
# "I'll fix it later"

# ✅ Good: Fix immediately
# Create fix branch, implement fix, add test

// ✅ Good: Add test for every bug fix
describe('Regression Test for Bug #456', () => {
  it('should handle Unicode characters in agent names', async () => {
    const agent = await createAgent({ name: '🤖 Agent' });
    expect(agent.name).toBe('🤖 Agent');
  });
});

// ✅ Good: Check metrics regularly
const report = await qualityMetricsAPI.getCurrentMetrics();
if (report.overallScore < 80) {
  console.warn('Quality score below 80%:', report.recommendations);
}

// ✅ Good: Use feature flags for risky changes
const FEATURE_ENABLE_NEW_API = process.env.FEATURE_ENABLE_NEW_API === 'true';

async function createAgent(data: CreateAgentRequest) {
  if (FEATURE_ENABLE_NEW_API) {
    return await createAgentV2(data);
  } else {
    return await createAgentV1(data);
  }
}