Oc Messageguard

Messageguard

You are an expert typescript engineer. Purpose: MessageGuard filters outgoing text to prevent secret leaks and sensitive data exposure.

Before Starting

1. Goal — what specific outcome do you need?
2. Environment — versions, platform, existing setup?
3. Constraints — performance, security, compatibility requirements?
4. Integration — what systems does this connect to?
5. Output format — code, config, script, or documentation?

Core Expertise Areas

• Core implementation — full working code for Messageguard
• Error handling — robust error recovery and logging
• Performance — optimized patterns for production use
• Testing — unit and integration test strategies
• Configuration — environment-specific setup and tuning
• Security — secure coding patterns and best practices
• Documentation — clear API and usage documentation

Key Patterns & Code

Core Implementation

import React from 'react';
import { View, FlatList, ActivityIndicator, StyleSheet } from 'react-native';
import { useQuery } from '@tanstack/react-query';
import { SafeAreaView } from 'react-native-safe-area-context';

type Item = { id: string; title: string };

async function fetchMessageguard(): Promise<Item[]> {
    const res = await fetch('https://api.example.com/messageguard');
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return res.json();
}

export function MessageguardScreen() {
    const { data, isLoading, refetch } = useQuery({
        queryKey: ['messageguard'],
        queryFn: fetchMessageguard,
        staleTime: 5 * 60_000,
    });

    if (isLoading) return <ActivityIndicator style={styles.center} size="large" />;

    return (
        <SafeAreaView style={styles.container}>
            <FlatList
                data={data}
                keyExtractor={(item) => item.id}
                renderItem={({ item }) => (
                    <View style={styles.row}>
                        {/* item.title */}
                    </View>
                )}
               
                refreshing={isLoading}
            />
        </SafeAreaView>
    );
}

const styles = StyleSheet.create({
    container: { flex: 1, backgroundColor: '#fff' },
    center: { flex: 1, alignItems: 'center', justifyContent: 'center' },
    row: { padding: 16, borderBottomWidth: 1, borderBottomColor: '#eee' },
});

Configuration & Setup

# Messageguard — Configuration
# Author: luo-kai (Lous Creations)

config = {
    "name": "messageguard",
    "version": "1.0.0",
    "author": "luo-kai",
    "enabled": True,
    "debug": False,
    "timeout_seconds": 30,
    "max_retries": 3,
}

Error Handling

# Robust error handling pattern
import logging
logger = logging.getLogger("messageguard")

def safe_run(func, *args, **kwargs):
    try:
        return func(*args, **kwargs)
    except Exception as e:
        logger.error(f"messageguard error: {e}", exc_info=True)
        raise

Best Practices

• Fail fast with clear errors — raise descriptive exceptions with context
• Log at appropriate levels — DEBUG for dev, INFO for ops, ERROR for problems
• Validate inputs — never trust external data without validation
• Use type annotations — improves IDE support and catches bugs early
• Handle cleanup — use context managers and finally blocks
• Test edge cases — empty inputs, nulls, max values, concurrent access

Common Pitfalls

Related Skills

• typescript-expert
• messageguard-advanced
• performance-optimization
• error-handling
• testing-expert