@aicgen/aicgen 1.0.0-beta.1

package/data/language/rust/basics.md

@@ -0,0 +1,175 @@
+# Rust Fundamentals
+
+## Project Structure
+
+```
+myproject/
+├── src/
+│   ├── main.rs           # Binary entry point
+│   ├── lib.rs            # Library root
+│   ├── models/
+│   │   └── mod.rs
+│   └── services/
+│       └── mod.rs
+├── tests/                # Integration tests
+├── Cargo.toml
+└── Cargo.lock
+```
+
+## Ownership & Borrowing
+
+```rust
+// Ownership: each value has one owner
+let s1 = String::from("hello");
+let s2 = s1;  // s1 is moved, no longer valid
+
+// Borrowing: references without ownership
+fn print_len(s: &String) {
+    println!("{}", s.len());
+}
+
+// Mutable borrowing (only one at a time)
+fn append(s: &mut String) {
+    s.push_str(" world");
+}
+
+// Lifetimes: ensure references are valid
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+    if x.len() > y.len() { x } else { y }
+}
+```
+
+## Error Handling
+
+```rust
+// Result for recoverable errors
+fn read_file(path: &str) -> Result<String, io::Error> {
+    fs::read_to_string(path)
+}
+
+// ? operator for propagation
+fn process_file(path: &str) -> Result<Data, Error> {
+    let content = fs::read_to_string(path)?;
+    let data = parse(&content)?;
+    Ok(data)
+}
+
+// Custom error types
+#[derive(Debug)]
+enum AppError {
+    NotFound(String),
+    InvalidInput(String),
+    Database(sqlx::Error),
+}
+
+impl From<sqlx::Error> for AppError {
+    fn from(err: sqlx::Error) -> Self {
+        AppError::Database(err)
+    }
+}
+```
+
+## Option & Pattern Matching
+
+```rust
+// Option for nullable values
+fn find_user(id: u64) -> Option<User> {
+    users.get(&id).cloned()
+}
+
+// Pattern matching
+match find_user(42) {
+    Some(user) => println!("Found: {}", user.name),
+    None => println!("Not found"),
+}
+
+// if let for single patterns
+if let Some(user) = find_user(42) {
+    process(user);
+}
+
+// Combinators
+find_user(42)
+    .map(|u| u.email)
+    .unwrap_or_default()
+```
+
+## Traits
+
+```rust
+// Define behavior
+trait Repository {
+    fn find(&self, id: u64) -> Option<Entity>;
+    fn save(&mut self, entity: Entity) -> Result<(), Error>;
+}
+
+// Implement for types
+impl Repository for PostgresRepo {
+    fn find(&self, id: u64) -> Option<Entity> {
+        // Implementation
+    }
+}
+
+// Trait bounds
+fn process<T: Repository + Clone>(repo: T) {
+    // Can use Repository and Clone methods
+}
+
+// Default implementations
+trait Greet {
+    fn greet(&self) -> String {
+        String::from("Hello!")
+    }
+}
+```
+
+## Testing
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_user() {
+        let user = User::new("test@example.com");
+        assert_eq!(user.email, "test@example.com");
+    }
+
+    #[test]
+    #[should_panic(expected = "invalid email")]
+    fn test_invalid_email_panics() {
+        User::new("invalid");
+    }
+
+    #[test]
+    fn test_find_user() -> Result<(), Error> {
+        let repo = TestRepo::new();
+        let user = repo.find(1)?;
+        assert!(user.is_some());
+        Ok(())
+    }
+}
+```
+
+## Async/Await
+
+```rust
+// Async functions
+async fn fetch_data(url: &str) -> Result<Data, Error> {
+    let response = reqwest::get(url).await?;
+    let data = response.json().await?;
+    Ok(data)
+}
+
+// Spawning tasks
+let handle = tokio::spawn(async {
+    fetch_data("https://api.example.com").await
+});
+
+// Concurrent execution
+let (result1, result2) = tokio::join!(
+    fetch_data("url1"),
+    fetch_data("url2")
+);
+```

package/data/language/rust/testing.md

@@ -0,0 +1,219 @@
+# Rust Testing
+
+## Test Module Structure
+
+```rust
+// In src/lib.rs or src/user.rs
+pub fn create_user(email: &str) -> Result<User, Error> {
+    // implementation
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_user() {
+        let user = create_user("test@example.com").unwrap();
+        assert_eq!(user.email, "test@example.com");
+    }
+}
+```
+
+## Assertions
+
+```rust
+#[test]
+fn test_assertions() {
+    // Equality
+    assert_eq!(actual, expected);
+    assert_ne!(value1, value2);
+
+    // Boolean
+    assert!(condition);
+    assert!(!condition);
+
+    // With custom message
+    assert_eq!(result, expected, "failed for input: {}", input);
+}
+```
+
+## Testing Results and Options
+
+```rust
+#[test]
+fn test_result() -> Result<(), Error> {
+    let user = create_user("test@example.com")?;
+    assert_eq!(user.email, "test@example.com");
+    Ok(())
+}
+
+#[test]
+fn test_option() {
+    let result = find_user("123");
+    assert!(result.is_some());
+    assert_eq!(result.unwrap().id, "123");
+}
+```
+
+## Testing Panics
+
+```rust
+#[test]
+#[should_panic]
+fn test_panics() {
+    divide(1, 0);
+}
+
+#[test]
+#[should_panic(expected = "division by zero")]
+fn test_panic_message() {
+    divide(1, 0);
+}
+```
+
+## Test Organization
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    mod create {
+        use super::*;
+
+        #[test]
+        fn with_valid_email() {
+            // test
+        }
+
+        #[test]
+        fn with_invalid_email() {
+            // test
+        }
+    }
+
+    mod update {
+        use super::*;
+
+        #[test]
+        fn existing_user() {
+            // test
+        }
+    }
+}
+```
+
+## Test Fixtures
+
+```rust
+struct TestContext {
+    db: MockDatabase,
+    service: UserService,
+}
+
+impl TestContext {
+    fn new() -> Self {
+        let db = MockDatabase::new();
+        let service = UserService::new(db.clone());
+        Self { db, service }
+    }
+}
+
+#[test]
+fn test_with_context() {
+    let ctx = TestContext::new();
+    let user = ctx.service.create("test@example.com").unwrap();
+    assert!(ctx.db.contains(&user.id));
+}
+```
+
+## Mocking with Traits
+
+```rust
+// Define trait
+trait UserRepository {
+    fn save(&self, user: &User) -> Result<(), Error>;
+    fn find_by_id(&self, id: &str) -> Option<User>;
+}
+
+// Mock implementation
+struct MockRepository {
+    users: RefCell<HashMap<String, User>>,
+}
+
+impl UserRepository for MockRepository {
+    fn save(&self, user: &User) -> Result<(), Error> {
+        self.users.borrow_mut().insert(user.id.clone(), user.clone());
+        Ok(())
+    }
+
+    fn find_by_id(&self, id: &str) -> Option<User> {
+        self.users.borrow().get(id).cloned()
+    }
+}
+
+#[test]
+fn test_service_create() {
+    let repo = MockRepository { users: RefCell::new(HashMap::new()) };
+    let service = UserService::new(Box::new(repo));
+
+    let user = service.create("test@example.com").unwrap();
+    assert_eq!(user.email, "test@example.com");
+}
+```
+
+## Integration Tests
+
+```
+tests/
+├── integration_test.rs
+└── common/
+    └── mod.rs
+```
+
+```rust
+// tests/common/mod.rs
+pub fn setup() -> TestDatabase {
+    TestDatabase::new()
+}
+
+// tests/integration_test.rs
+mod common;
+
+#[test]
+fn test_database_integration() {
+    let db = common::setup();
+    // integration test...
+}
+```
+
+## Async Tests
+
+```rust
+#[tokio::test]
+async fn test_async_create() {
+    let service = UserService::new();
+    let user = service.create_async("test@example.com").await.unwrap();
+    assert_eq!(user.email, "test@example.com");
+}
+```
+
+## Running Tests
+
+```bash
+# Run all tests
+cargo test
+
+# Run specific test
+cargo test test_create_user
+
+# Run tests with output
+cargo test -- --nocapture
+
+# Run ignored tests
+cargo test -- --ignored
+
+# Run benchmarks (nightly)
+cargo bench
+```

package/data/language/typescript/async.md

@@ -0,0 +1,103 @@
+# Async/Await Patterns
+
+## Prefer async/await
+
+Always use async/await over promise chains:
+
+```typescript
+// ✅ Good
+async function fetchUser(id: string): Promise<User> {
+  const response = await fetch(`/api/users/${id}`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  return await response.json();
+}
+
+// ❌ Avoid
+function fetchUser(id: string): Promise<User> {
+  return fetch(`/api/users/${id}`)
+    .then(res => res.json());
+}
+```
+
+## Error Handling
+
+Always wrap async operations in try/catch:
+
+```typescript
+async function safeOperation(): Promise<Result> {
+  try {
+    const data = await riskyOperation();
+    return { success: true, data };
+  } catch (error) {
+    logger.error('Operation failed', error);
+    return { success: false, error: error.message };
+  }
+}
+```
+
+## Parallel Execution
+
+Use `Promise.all()` for independent operations:
+
+```typescript
+// ✅ Good - parallel (fast)
+const [users, posts, comments] = await Promise.all([
+  fetchUsers(),
+  fetchPosts(),
+  fetchComments()
+]);
+
+// ❌ Bad - sequential (slow)
+const users = await fetchUsers();
+const posts = await fetchPosts();
+const comments = await fetchComments();
+```
+
+## Handling Failures
+
+Use `Promise.allSettled()` when some failures are acceptable:
+
+```typescript
+const results = await Promise.allSettled([
+  fetchData1(),
+  fetchData2(),
+  fetchData3()
+]);
+
+results.forEach((result, index) => {
+  if (result.status === 'fulfilled') {
+    console.log(`Success ${index}:`, result.value);
+  } else {
+    console.error(`Failed ${index}:`, result.reason);
+  }
+});
+```
+
+## Retry Pattern
+
+Implement retry with exponential backoff:
+
+```typescript
+async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  maxRetries: number = 3
+): Promise<T> {
+  let lastError: Error;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error as Error;
+      if (attempt < maxRetries - 1) {
+        const delay = 1000 * Math.pow(2, attempt);
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError!;
+}
+```

package/data/language/typescript/basics.md

@@ -0,0 +1,87 @@
+# TypeScript Fundamentals
+
+## Strict Mode (Required)
+
+Always use strict mode in `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true
+  }
+}
+```
+
+## Type Annotations
+
+Use explicit types for clarity:
+
+```typescript
+// Function signatures
+function calculateTotal(items: CartItem[], taxRate: number): number {
+  const subtotal = items.reduce((sum, item) => sum + item.price, 0);
+  return subtotal * (1 + taxRate);
+}
+
+// Variable declarations
+const userName: string = "Alice";
+const age: number = 30;
+const isActive: boolean = true;
+```
+
+## Avoid `any`
+
+Never use `any` - use `unknown` with type guards:
+
+```typescript
+// ❌ Bad
+function processData(data: any) {
+  return data.value;
+}
+
+// ✅ Good
+function processData(data: unknown): string {
+  if (typeof data === 'object' && data !== null && 'value' in data) {
+    return String(data.value);
+  }
+  throw new Error('Invalid data structure');
+}
+```
+
+## Type Guards
+
+Implement custom type guards:
+
+```typescript
+interface User {
+  id: string;
+  email: string;
+}
+
+function isUser(value: unknown): value is User {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'id' in value &&
+    'email' in value &&
+    typeof value.id === 'string' &&
+    typeof value.email === 'string'
+  );
+}
+
+// Usage
+if (isUser(data)) {
+  console.log(data.email); // Type: User
+}
+```
+
+## Naming Conventions
+
+- Classes/Interfaces: `PascalCase`
+- Functions/Variables: `camelCase`
+- Constants: `UPPER_SNAKE_CASE`
+- Files: `kebab-case.ts`
+- No `I` prefix for interfaces

package/data/language/typescript/config.md

@@ -0,0 +1,95 @@
+# TypeScript Configuration
+
+## tsconfig.json Best Practices
+
+```json
+{
+  "compilerOptions": {
+    // Strict type checking
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+
+    // Additional checks
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Module resolution
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+
+    // Output
+    "target": "ES2022",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+
+    // Path aliases
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"],
+      "@services/*": ["src/services/*"],
+      "@models/*": ["src/models/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}
+```
+
+## Path Aliases Setup
+
+```typescript
+// With path aliases configured:
+import { UserService } from '@services/user';
+import { User } from '@models/user';
+
+// Instead of relative paths:
+import { UserService } from '../../../services/user';
+```
+
+## Project References (Monorepo)
+
+```json
+// packages/shared/tsconfig.json
+{
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "./dist"
+  }
+}
+
+// packages/api/tsconfig.json
+{
+  "extends": "../../tsconfig.base.json",
+  "references": [
+    { "path": "../shared" }
+  ]
+}
+```
+
+## Environment-Specific Configs
+
+```json
+// tsconfig.build.json - for production builds
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "sourceMap": false,
+    "removeComments": true
+  },
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}
+```