@aicgen/aicgen 1.0.0-beta.1

package/data/language/javascript/basics.md

@@ -0,0 +1,217 @@
+# JavaScript Fundamentals
+
+## Project Structure
+
+```
+myproject/
+├── src/
+│   ├── index.js          # Entry point
+│   ├── config/
+│   ├── controllers/
+│   ├── services/
+│   ├── models/
+│   └── utils/
+├── tests/
+├── package.json
+└── .eslintrc.js
+```
+
+## Modern JavaScript (ES6+)
+
+```javascript
+// const/let instead of var
+const immutable = "cannot change";
+let mutable = "can change";
+
+// Arrow functions
+const add = (a, b) => a + b;
+const users = data.map(d => new User(d));
+
+// Destructuring
+const { name, email } = user;
+const [first, ...rest] = items;
+
+// Spread operator
+const merged = { ...defaults, ...options };
+const combined = [...array1, ...array2];
+
+// Template literals
+const message = `Hello, ${name}!`;
+
+// Optional chaining
+const avatar = user?.profile?.avatar ?? defaultAvatar;
+
+// Nullish coalescing
+const value = input ?? defaultValue;
+```
+
+## Async/Await
+
+```javascript
+// Async functions
+async function fetchUser(id) {
+  const response = await fetch(`/api/users/${id}`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch user: ${response.status}`);
+  }
+  return response.json();
+}
+
+// Error handling
+async function processUser(id) {
+  try {
+    const user = await fetchUser(id);
+    return await processData(user);
+  } catch (error) {
+    console.error("Processing failed:", error);
+    throw error;
+  }
+}
+
+// Parallel execution
+const [users, posts] = await Promise.all([
+  fetchUsers(),
+  fetchPosts()
+]);
+
+// Promise.allSettled for partial failures
+const results = await Promise.allSettled([
+  fetchUser(1),
+  fetchUser(2),
+  fetchUser(3)
+]);
+```
+
+## Classes
+
+```javascript
+class UserService {
+  #repository; // Private field
+
+  constructor(repository) {
+    this.#repository = repository;
+  }
+
+  async create(data) {
+    const user = new User(data);
+    await this.#validate(user);
+    return this.#repository.save(user);
+  }
+
+  async #validate(user) {
+    if (!user.email) {
+      throw new ValidationError("Email required");
+    }
+  }
+
+  static fromConfig(config) {
+    return new UserService(new Repository(config));
+  }
+}
+```
+
+## Error Handling
+
+```javascript
+// Custom errors
+class NotFoundError extends Error {
+  constructor(id) {
+    super(`Not found: ${id}`);
+    this.name = "NotFoundError";
+    this.id = id;
+  }
+}
+
+class ValidationError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+}
+
+// Error handling
+async function handleRequest(req) {
+  try {
+    return await processRequest(req);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      return { status: 404, message: error.message };
+    }
+    if (error instanceof ValidationError) {
+      return { status: 400, message: error.message, field: error.field };
+    }
+    throw error; // Re-throw unexpected errors
+  }
+}
+```
+
+## Modules
+
+```javascript
+// Named exports
+export function createUser(data) { }
+export const MAX_USERS = 100;
+
+// Default export
+export default class UserService { }
+
+// Imports
+import UserService from "./user-service.js";
+import { createUser, MAX_USERS } from "./utils.js";
+import * as utils from "./utils.js";
+```
+
+## Array Methods
+
+```javascript
+// Map, filter, reduce
+const emails = users.map(u => u.email);
+const active = users.filter(u => u.isActive);
+const total = orders.reduce((sum, o) => sum + o.total, 0);
+
+// Find
+const user = users.find(u => u.id === targetId);
+const index = users.findIndex(u => u.id === targetId);
+
+// Some/every
+const hasAdmin = users.some(u => u.role === "admin");
+const allActive = users.every(u => u.isActive);
+
+// Chaining
+const result = users
+  .filter(u => u.isActive)
+  .map(u => u.email)
+  .sort();
+```
+
+## Testing (Jest)
+
+```javascript
+describe("UserService", () => {
+  let repository;
+  let service;
+
+  beforeEach(() => {
+    repository = { save: jest.fn(), find: jest.fn() };
+    service = new UserService(repository);
+  });
+
+  describe("create", () => {
+    it("creates user with valid data", async () => {
+      repository.save.mockResolvedValue({ id: "1", email: "test@example.com" });
+
+      const user = await service.create({ email: "test@example.com" });
+
+      expect(user.email).toBe("test@example.com");
+      expect(repository.save).toHaveBeenCalled();
+    });
+
+    it("throws on invalid email", async () => {
+      await expect(service.create({ email: "" }))
+        .rejects
+        .toThrow(ValidationError);
+    });
+  });
+});
+```

package/data/language/javascript/testing.md

@@ -0,0 +1,269 @@
+# JavaScript Testing (Jest)
+
+## Project Structure
+
+```
+myproject/
+├── src/
+│   └── services/
+│       └── userService.js
+└── tests/          # or __tests__/
+    └── services/
+        └── userService.test.js
+```
+
+## Basic Tests
+
+```javascript
+const { UserService } = require("../src/services/userService");
+
+describe("UserService", () => {
+  let service;
+
+  beforeEach(() => {
+    service = new UserService();
+  });
+
+  describe("create", () => {
+    it("creates user with valid email", async () => {
+      const user = await service.create({ email: "test@example.com" });
+
+      expect(user.email).toBe("test@example.com");
+      expect(user.id).toBeDefined();
+    });
+
+    it("throws on invalid email", async () => {
+      await expect(service.create({ email: "invalid" }))
+        .rejects
+        .toThrow(ValidationError);
+    });
+  });
+});
+```
+
+## Matchers
+
+```javascript
+// Equality
+expect(value).toBe(exact);           // ===
+expect(value).toEqual(deepEqual);    // deep equality
+expect(value).toStrictEqual(obj);    // deep + type
+
+// Truthiness
+expect(value).toBeTruthy();
+expect(value).toBeFalsy();
+expect(value).toBeNull();
+expect(value).toBeUndefined();
+expect(value).toBeDefined();
+
+// Numbers
+expect(value).toBeGreaterThan(3);
+expect(value).toBeLessThanOrEqual(5);
+expect(value).toBeCloseTo(0.3, 5);   // floating point
+
+// Strings
+expect(string).toMatch(/pattern/);
+expect(string).toContain("substring");
+
+// Arrays
+expect(array).toContain(item);
+expect(array).toHaveLength(3);
+expect(array).toContainEqual({ id: 1 });
+
+// Objects
+expect(object).toHaveProperty("name");
+expect(object).toHaveProperty("user.email", "test@example.com");
+expect(object).toMatchObject({ name: "John" });
+
+// Exceptions
+expect(() => fn()).toThrow();
+expect(() => fn()).toThrow(ErrorType);
+expect(() => fn()).toThrow("message");
+```
+
+## Async Testing
+
+```javascript
+// Async/await
+it("fetches user", async () => {
+  const user = await service.fetch("123");
+  expect(user.id).toBe("123");
+});
+
+// Promises
+it("fetches user", () => {
+  return service.fetch("123").then(user => {
+    expect(user.id).toBe("123");
+  });
+});
+
+// Rejections
+it("rejects on not found", async () => {
+  await expect(service.fetch("invalid"))
+    .rejects
+    .toThrow(NotFoundError);
+});
+```
+
+## Mocking
+
+```javascript
+// Mock functions
+const mockFn = jest.fn();
+mockFn.mockReturnValue(42);
+mockFn.mockResolvedValue(user);
+mockFn.mockRejectedValue(new Error("failed"));
+
+// Mock implementations
+mockFn.mockImplementation((x) => x * 2);
+
+// Verify calls
+expect(mockFn).toHaveBeenCalled();
+expect(mockFn).toHaveBeenCalledWith("arg1", "arg2");
+expect(mockFn).toHaveBeenCalledTimes(2);
+
+// Mock modules
+jest.mock("../src/services/emailService");
+const { EmailService } = require("../src/services/emailService");
+EmailService.prototype.send = jest.fn().mockResolvedValue(true);
+
+// Spy on existing methods
+const spy = jest.spyOn(console, "log");
+// ... test
+spy.mockRestore();
+```
+
+## Testing with Mocked Dependencies
+
+```javascript
+describe("UserService", () => {
+  let repository;
+  let notifier;
+  let service;
+
+  beforeEach(() => {
+    repository = {
+      save: jest.fn(),
+      find: jest.fn()
+    };
+    notifier = {
+      sendWelcome: jest.fn().mockResolvedValue(true)
+    };
+    service = new UserService(repository, notifier);
+  });
+
+  it("saves user and sends welcome", async () => {
+    const userData = { email: "test@example.com" };
+    repository.save.mockResolvedValue({ id: "1", ...userData });
+
+    const user = await service.create(userData);
+
+    expect(repository.save).toHaveBeenCalledWith(expect.objectContaining({
+      email: "test@example.com"
+    }));
+    expect(notifier.sendWelcome).toHaveBeenCalledWith(user);
+  });
+});
+```
+
+## Setup and Teardown
+
+```javascript
+beforeAll(() => {
+  // Run once before all tests
+});
+
+beforeEach(() => {
+  // Run before each test
+});
+
+afterEach(() => {
+  // Run after each test
+  jest.clearAllMocks();
+});
+
+afterAll(() => {
+  // Run once after all tests
+});
+```
+
+## Snapshot Testing
+
+```javascript
+it("renders correctly", () => {
+  const tree = renderer.create(<Button label="Click me" />).toJSON();
+  expect(tree).toMatchSnapshot();
+});
+
+// Inline snapshot
+it("serializes correctly", () => {
+  expect(user.toJSON()).toMatchInlineSnapshot(`
+    {
+      "email": "test@example.com",
+      "id": "1"
+    }
+  `);
+});
+```
+
+## Test Each (Parameterized)
+
+```javascript
+describe("validateEmail", () => {
+  it.each([
+    ["test@example.com", true],
+    ["invalid", false],
+    ["", false]
+  ])("validates %s as %s", (email, expected) => {
+    expect(validateEmail(email)).toBe(expected);
+  });
+
+  // With named parameters
+  it.each`
+    email                 | expected
+    ${"test@example.com"} | ${true}
+    ${"invalid"}          | ${false}
+  `("validates $email", ({ email, expected }) => {
+    expect(validateEmail(email)).toBe(expected);
+  });
+});
+```
+
+## Timer Mocking
+
+```javascript
+jest.useFakeTimers();
+
+it("calls callback after delay", () => {
+  const callback = jest.fn();
+
+  delayedCall(callback, 1000);
+
+  expect(callback).not.toHaveBeenCalled();
+  jest.advanceTimersByTime(1000);
+  expect(callback).toHaveBeenCalled();
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+```
+
+## Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Watch mode
+npm test -- --watch
+
+# Coverage
+npm test -- --coverage
+
+# Run specific file
+npm test -- userService.test.js
+
+# Run matching tests
+npm test -- -t "creates user"
+```

package/data/language/python/async.md

@@ -0,0 +1,100 @@
+# Python Async/Await
+
+## Basic Async Patterns
+
+```python
+import asyncio
+from typing import List
+
+# ✅ Async function definition
+async def fetch_user(user_id: int) -> User:
+    async with aiohttp.ClientSession() as session:
+        async with session.get(f"/users/{user_id}") as response:
+            data = await response.json()
+            return User(**data)
+
+# ✅ Running async code
+async def main():
+    user = await fetch_user(1)
+    print(user.name)
+
+asyncio.run(main())
+```
+
+## Parallel Execution
+
+```python
+# ❌ Sequential (slow)
+async def get_all_users(ids: List[int]) -> List[User]:
+    users = []
+    for user_id in ids:
+        user = await fetch_user(user_id)  # One at a time
+        users.append(user)
+    return users
+
+# ✅ Parallel with gather (fast)
+async def get_all_users(ids: List[int]) -> List[User]:
+    tasks = [fetch_user(user_id) for user_id in ids]
+    return await asyncio.gather(*tasks)  # All at once
+
+# ✅ Parallel with error handling
+async def get_all_users_safe(ids: List[int]) -> List[User | Exception]:
+    tasks = [fetch_user(user_id) for user_id in ids]
+    return await asyncio.gather(*tasks, return_exceptions=True)
+```
+
+## Async Context Managers
+
+```python
+from contextlib import asynccontextmanager
+
+# ✅ Async context manager
+@asynccontextmanager
+async def get_connection():
+    conn = await database.connect()
+    try:
+        yield conn
+    finally:
+        await conn.close()
+
+# Usage
+async def query_users():
+    async with get_connection() as conn:
+        return await conn.execute("SELECT * FROM users")
+```
+
+## Timeouts and Cancellation
+
+```python
+# ✅ Add timeouts to prevent hanging
+async def fetch_with_timeout(url: str, timeout: float = 10.0):
+    try:
+        async with asyncio.timeout(timeout):
+            return await fetch(url)
+    except asyncio.TimeoutError:
+        raise ServiceError(f"Request to {url} timed out")
+
+# ✅ Handle cancellation gracefully
+async def long_running_task():
+    try:
+        while True:
+            await process_batch()
+            await asyncio.sleep(1)
+    except asyncio.CancelledError:
+        await cleanup()
+        raise
+```
+
+## Semaphore for Rate Limiting
+
+```python
+# ✅ Limit concurrent operations
+async def fetch_all(urls: List[str], max_concurrent: int = 10):
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def fetch_one(url: str):
+        async with semaphore:
+            return await fetch(url)
+
+    return await asyncio.gather(*[fetch_one(url) for url in urls])
+```

package/data/language/python/basics.md

@@ -0,0 +1,100 @@
+# Python Fundamentals
+
+## PEP 8 Style Guide
+
+```python
+# Naming conventions
+variable_name = "snake_case"          # Variables and functions
+CONSTANT_VALUE = 42                   # Constants
+ClassName = "PascalCase"              # Classes
+_private_var = "internal"             # Private by convention
+
+# Imports - group and order
+import os                             # 1. Standard library
+import sys
+
+import requests                       # 2. Third-party
+from flask import Flask
+
+from myapp.models import User         # 3. Local application
+from myapp.utils import helper
+```
+
+## String Formatting
+
+```python
+# ✅ Use f-strings (Python 3.6+)
+name = "Alice"
+age = 30
+message = f"Hello, {name}! You are {age} years old."
+
+# ✅ Multi-line f-strings
+query = f"""
+    SELECT *
+    FROM users
+    WHERE name = '{name}'
+    AND age > {age - 5}
+"""
+
+# ❌ Avoid old-style formatting
+message = "Hello, %s!" % name           # Old style
+message = "Hello, {}!".format(name)     # Verbose
+```
+
+## List Comprehensions
+
+```python
+# ✅ Simple and readable
+squares = [x ** 2 for x in range(10)]
+even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
+
+# ❌ Too complex - use regular loop instead
+result = [
+    transform(item)
+    for sublist in nested_list
+    for item in sublist
+    if condition(item) and another_condition(item)
+]
+
+# ✅ Break into steps when complex
+filtered_items = [item for sublist in nested_list for item in sublist]
+filtered_items = [item for item in filtered_items if condition(item)]
+result = [transform(item) for item in filtered_items]
+```
+
+## Context Managers
+
+```python
+# ✅ Always use context managers for resources
+with open('file.txt', 'r') as f:
+    content = f.read()
+# File automatically closed
+
+# ✅ Database connections
+with db.connection() as conn:
+    cursor = conn.execute(query)
+
+# ✅ Multiple resources
+with open('input.txt') as infile, open('output.txt', 'w') as outfile:
+    outfile.write(infile.read())
+```
+
+## Pythonic Patterns
+
+```python
+# ✅ EAFP (Easier to Ask Forgiveness than Permission)
+try:
+    value = my_dict[key]
+except KeyError:
+    value = default
+
+# Or simply:
+value = my_dict.get(key, default)
+
+# ✅ Truthiness
+if my_list:          # Instead of: if len(my_list) > 0
+    process(my_list)
+
+if name:             # Instead of: if name != ""
+    greet(name)
+```

package/data/language/python/index.md

@@ -0,0 +1,10 @@
+# Python Language Guidelines
+
+This directory contains Python-specific coding guidelines.
+
+## Available Chunks
+
+- **basics.md** - PEP 8, string formatting, comprehensions, context managers
+- **types.md** - Type hints, TypedDict, Protocols, generics
+- **async.md** - async/await, asyncio, parallel execution
+- **testing.md** - pytest fixtures, parametrized tests, mocking