@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/templates/prompts/legacy.txt

@@ -0,0 +1,280 @@
+You are assisting with C legacy code maintenance and modernization.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Maintaining and upgrading legacy C codebases
+
+## Key Rules for Legacy Maintenance
+
+### 1. Backward Compatibility
+- Maintain API compatibility when possible
+- Use feature test macros for conditional compilation
+- Document breaking changes clearly
+- Provide migration guides
+- Support multiple C standards (C89, C99, C11)
+
+### 2. Incremental Modernization
+- Modernize in small, testable increments
+- Add tests before refactoring
+- Use compatibility layers for new features
+- Keep old and new code paths temporarily
+- Document modernization strategy
+
+### 3. C89 to C11 Migration Patterns
+- Replace implicit int with explicit types
+- Add function prototypes
+- Use stdint.h types instead of platform-specific
+- Replace K&R function definitions with ANSI
+- Add const correctness incrementally
+
+### 4. Compatibility Layers
+- Provide fallbacks for missing C99/C11 features
+- Use preprocessor for conditional compilation
+- Implement polyfills for standard functions
+- Document platform-specific code
+- Test on all target platforms
+
+### 5. Documentation and Testing
+- Document legacy behavior and quirks
+- Add regression tests for existing functionality
+- Document platform dependencies
+- Create migration test suite
+- Maintain changelog of modernization
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: C89 to C11 Migration
+
+```c
+/* BEFORE: C89 style */
+#include <stdio.h>
+
+/* K&R function definition */
+int calculate(x, y)
+    int x;
+    int y;
+{
+    int result;  /* Declaration at start of block */
+    result = x + y;
+    return result;
+}
+
+void process_data(buffer, size)
+    char *buffer;
+    int size;
+{
+    int i;
+    for (i = 0; i < size; i++) {
+        buffer[i] = process_byte(buffer[i]);
+    }
+}
+
+/* AFTER: C11 style */
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+/* ANSI function prototype with explicit types */
+int32_t calculate(int32_t x, int32_t y) {
+    /* Declaration at point of use (C99+) */
+    int32_t result = x + y;
+    return result;
+}
+
+void process_data(uint8_t *buffer, size_t size) {
+    /* Loop variable declared in for statement (C99+) */
+    for (size_t i = 0; i < size; i++) {
+        buffer[i] = process_byte(buffer[i]);
+    }
+}
+```
+
+## Example Pattern: Compatibility Layer
+
+```c
+/* compatibility.h - Provide C99/C11 features for older compilers */
+
+#ifndef COMPATIBILITY_H
+#define COMPATIBILITY_H
+
+/* Feature test macros */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define HAVE_C99 1
+#endif
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define HAVE_C11 1
+#endif
+
+/* stdint.h types for pre-C99 */
+#ifndef HAVE_C99
+    typedef signed char        int8_t;
+    typedef unsigned char      uint8_t;
+    typedef signed short       int16_t;
+    typedef unsigned short     uint16_t;
+    typedef signed int         int32_t;
+    typedef unsigned int       uint32_t;
+    typedef signed long long   int64_t;
+    typedef unsigned long long uint64_t;
+    typedef unsigned long      size_t;
+#else
+    #include <stdint.h>
+#endif
+
+/* stdbool.h for pre-C99 */
+#ifndef HAVE_C99
+    typedef enum { false = 0, true = 1 } bool;
+#else
+    #include <stdbool.h>
+#endif
+
+/* inline keyword */
+#ifndef HAVE_C99
+    #if defined(__GNUC__)
+        #define inline __inline__
+    #elif defined(_MSC_VER)
+        #define inline __inline
+    #else
+        #define inline
+    #endif
+#endif
+
+/* restrict keyword */
+#ifndef HAVE_C99
+    #if defined(__GNUC__)
+        #define restrict __restrict__
+    #elif defined(_MSC_VER)
+        #define restrict __restrict
+    #else
+        #define restrict
+    #endif
+#endif
+
+/* Static assertions */
+#ifdef HAVE_C11
+    #include <assert.h>
+    #define STATIC_ASSERT(cond, msg) _Static_assert(cond, msg)
+#else
+    #define STATIC_ASSERT(cond, msg) \
+        typedef char static_assertion_##msg[(cond) ? 1 : -1]
+#endif
+
+#endif /* COMPATIBILITY_H */
+```
+
+## Example Pattern: Gradual Refactoring
+
+```c
+/* Step 1: Add new API alongside old API */
+
+/* Legacy API - deprecated but still supported */
+int old_process_data(char *buffer, int size) {
+    /* Old implementation */
+    return legacy_implementation(buffer, size);
+}
+
+/* New API - recommended */
+int process_data_v2(uint8_t *buffer, size_t size) {
+    /* New, improved implementation */
+    if (!buffer || size == 0) {
+        return -1;
+    }
+    
+    for (size_t i = 0; i < size; i++) {
+        buffer[i] = process_byte(buffer[i]);
+    }
+    
+    return 0;
+}
+
+/* Compatibility wrapper */
+#ifndef DISABLE_LEGACY_API
+int process_data(char *buffer, int size) {
+    /* Emit deprecation warning */
+    #ifdef __GNUC__
+        #warning "process_data is deprecated, use process_data_v2"
+    #endif
+    
+    /* Forward to new implementation */
+    if (size < 0) {
+        return -1;
+    }
+    return process_data_v2((uint8_t*)buffer, (size_t)size);
+}
+#endif
+```
+
+## Example Pattern: Platform Abstraction
+
+```c
+/* platform.h - Abstract platform differences */
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+#include "compatibility.h"
+
+/* Platform detection */
+#if defined(_WIN32) || defined(_WIN64)
+    #define PLATFORM_WINDOWS 1
+#elif defined(__linux__)
+    #define PLATFORM_LINUX 1
+#elif defined(__APPLE__)
+    #define PLATFORM_MACOS 1
+#else
+    #define PLATFORM_UNKNOWN 1
+#endif
+
+/* Platform-specific includes */
+#ifdef PLATFORM_WINDOWS
+    #include <windows.h>
+    typedef HANDLE thread_t;
+#else
+    #include <pthread.h>
+    typedef pthread_t thread_t;
+#endif
+
+/* Platform-specific functions */
+static inline int platform_sleep_ms(uint32_t milliseconds) {
+#ifdef PLATFORM_WINDOWS
+    Sleep(milliseconds);
+    return 0;
+#else
+    struct timespec ts;
+    ts.tv_sec = milliseconds / 1000;
+    ts.tv_nsec = (milliseconds % 1000) * 1000000;
+    return nanosleep(&ts, NULL);
+#endif
+}
+
+#endif /* PLATFORM_H */
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Breaking API compatibility without notice
+- Modernizing too much code at once
+- Not testing on all target platforms
+- Removing legacy code paths prematurely
+- Not documenting migration strategy
+- Ignoring platform-specific behavior
+- Assuming C99/C11 features available
+
+Generate legacy C code maintenance following these careful migration standards.
+

package/augment-extensions/coding-standards/c/templates/prompts/networking.txt

@@ -0,0 +1,259 @@
+You are assisting with C network programming.
+
+## Context
+- Category: {category}
+- C Standard: {c_standard}
+- Target: Network applications using sockets API
+
+## Key Rules for Network Programming
+
+### 1. Socket Programming Best Practices
+- Always check socket() return value for -1
+- Use getaddrinfo() for address resolution (IPv4/IPv6 compatible)
+- Set socket options appropriately (SO_REUSEADDR, etc.)
+- Close sockets in all code paths
+- Handle partial send/recv in loops
+
+### 2. Endianness Handling
+**CRITICAL**: Network byte order is big-endian
+- Use htons() for host-to-network short (16-bit)
+- Use htonl() for host-to-network long (32-bit)
+- Use ntohs() for network-to-host short
+- Use ntohl() for network-to-host long
+- Never assume host byte order
+
+### 3. Protocol Implementation
+- Follow RFC specifications exactly
+- Validate all input from network
+- Implement proper state machines
+- Handle protocol errors gracefully
+- Document protocol version and extensions
+
+### 4. Buffer Management
+- Use fixed-size buffers with bounds checking
+- Handle partial reads/writes
+- Implement timeout mechanisms
+- Prevent buffer overflows
+- Use MSG_PEEK for protocol parsing
+
+### 5. Non-Blocking I/O
+- Use select(), poll(), or epoll() for multiplexing
+- Handle EAGAIN/EWOULDBLOCK properly
+- Set O_NONBLOCK flag correctly
+- Implement proper timeout handling
+- Use edge-triggered or level-triggered appropriately
+
+{#if rules}
+## Active Rules
+{#each rules}
+- {id}: {description}
+{/each}
+{/if}
+
+## Example Pattern: TCP Server with Error Handling
+
+```c
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+#define PORT 8080
+#define BACKLOG 10
+#define BUFFER_SIZE 1024
+
+int create_tcp_server(void) {
+    int server_fd, opt = 1;
+    struct sockaddr_in address;
+    
+    // Create socket
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd < 0) {
+        perror("socket");
+        return -1;
+    }
+    
+    // Set socket options
+    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR,
+                   &opt, sizeof(opt)) < 0) {
+        perror("setsockopt");
+        close(server_fd);
+        return -1;
+    }
+    
+    // Bind to address
+    memset(&address, 0, sizeof(address));
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
+    address.sin_port = htons(PORT);  // Host to network byte order
+    
+    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
+        perror("bind");
+        close(server_fd);
+        return -1;
+    }
+    
+    // Listen for connections
+    if (listen(server_fd, BACKLOG) < 0) {
+        perror("listen");
+        close(server_fd);
+        return -1;
+    }
+    
+    return server_fd;
+}
+
+ssize_t send_all(int sockfd, const void *buf, size_t len) {
+    size_t total_sent = 0;
+    ssize_t sent;
+    
+    while (total_sent < len) {
+        sent = send(sockfd, (char*)buf + total_sent,
+                   len - total_sent, 0);
+        
+        if (sent < 0) {
+            if (errno == EINTR) {
+                continue;  // Interrupted, retry
+            }
+            perror("send");
+            return -1;
+        }
+        
+        total_sent += sent;
+    }
+    
+    return total_sent;
+}
+```
+
+## Example Pattern: UDP Multicast
+
+```c
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+#define MULTICAST_GROUP "239.0.0.1"
+#define MULTICAST_PORT  5000
+
+int join_multicast_group(void) {
+    int sockfd;
+    struct sockaddr_in addr;
+    struct ip_mreq mreq;
+    
+    // Create UDP socket
+    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) {
+        perror("socket");
+        return -1;
+    }
+    
+    // Allow multiple sockets to use the same port
+    int reuse = 1;
+    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,
+                   &reuse, sizeof(reuse)) < 0) {
+        perror("setsockopt SO_REUSEADDR");
+        close(sockfd);
+        return -1;
+    }
+    
+    // Bind to multicast port
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
+    addr.sin_port = htons(MULTICAST_PORT);
+    
+    if (bind(sockfd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+        perror("bind");
+        close(sockfd);
+        return -1;
+    }
+    
+    // Join multicast group
+    mreq.imr_multiaddr.s_addr = inet_addr(MULTICAST_GROUP);
+    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+    
+    if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+                   &mreq, sizeof(mreq)) < 0) {
+        perror("setsockopt IP_ADD_MEMBERSHIP");
+        close(sockfd);
+        return -1;
+    }
+    
+    return sockfd;
+}
+```
+
+## Example Pattern: Protocol Parser with Endianness
+
+```c
+#include <stdint.h>
+#include <arpa/inet.h>
+#include <stdbool.h>
+
+// Network protocol header (big-endian)
+typedef struct __attribute__((packed)) {
+    uint16_t version;
+    uint16_t message_type;
+    uint32_t payload_length;
+    uint32_t sequence_number;
+} protocol_header_t;
+
+bool parse_protocol_header(const uint8_t *buffer, protocol_header_t *header) {
+    if (!buffer || !header) {
+        return false;
+    }
+    
+    // Convert from network byte order to host byte order
+    header->version = ntohs(*(uint16_t*)(buffer + 0));
+    header->message_type = ntohs(*(uint16_t*)(buffer + 2));
+    header->payload_length = ntohl(*(uint32_t*)(buffer + 4));
+    header->sequence_number = ntohl(*(uint32_t*)(buffer + 8));
+    
+    // Validate header
+    if (header->version != 1) {
+        return false;
+    }
+    
+    if (header->payload_length > MAX_PAYLOAD_SIZE) {
+        return false;
+    }
+    
+    return true;
+}
+
+void build_protocol_header(uint8_t *buffer, const protocol_header_t *header) {
+    // Convert from host byte order to network byte order
+    *(uint16_t*)(buffer + 0) = htons(header->version);
+    *(uint16_t*)(buffer + 2) = htons(header->message_type);
+    *(uint32_t*)(buffer + 4) = htonl(header->payload_length);
+    *(uint32_t*)(buffer + 8) = htonl(header->sequence_number);
+}
+```
+
+{#if examples}
+## Additional Examples
+{#each examples}
+
+### {title}
+```c
+{code}
+```
+{/each}
+{/if}
+
+## Common Pitfalls to Avoid
+- Forgetting endianness conversion (htons/ntohs)
+- Not handling partial send/recv
+- Ignoring socket errors
+- Not closing sockets on error paths
+- Buffer overflows from network input
+- Not validating protocol data
+- Blocking indefinitely without timeouts
+
+Generate network C code following these standards.
+