anchi-kit 1.2.0 → 1.2.2

package/.cursor/skills/software-architecture/references/solid-principles.md

@@ -1,293 +0,0 @@
-# SOLID Principles
-
-## S - Single Responsibility Principle (SRP)
-
-**A class should have only one reason to change.**
-
-### ❌ Violation
-
-```javascript
-class User {
-  constructor(name, email) {
-    this.name = name;
-    this.email = email;
-  }
-
-  // Database logic - reason #1 to change
-  save() {
-    database.insert("users", this);
-  }
-
-  // Email logic - reason #2 to change
-  sendWelcomeEmail() {
-    emailService.send(this.email, "Welcome!");
-  }
-
-  // Validation - reason #3 to change
-  validate() {
-    return this.email.includes("@");
-  }
-}
-```
-
-### ✅ Solution
-
-```javascript
-class User {
-  constructor(name, email) {
-    this.name = name;
-    this.email = email;
-  }
-}
-
-class UserRepository {
-  save(user) {
-    database.insert("users", user);
-  }
-}
-
-class UserNotification {
-  sendWelcome(user) {
-    emailService.send(user.email, "Welcome!");
-  }
-}
-
-class UserValidator {
-  validate(user) {
-    return user.email.includes("@");
-  }
-}
-```
-
-## O - Open/Closed Principle (OCP)
-
-**Open for extension, closed for modification.**
-
-### ❌ Violation
-
-```javascript
-class PaymentProcessor {
-  process(payment) {
-    if (payment.type === "credit-card") {
-      // Process credit card
-    } else if (payment.type === "paypal") {
-      // Process PayPal
-    }
-    // Adding new payment type requires modifying this class
-  }
-}
-```
-
-### ✅ Solution
-
-```javascript
-class PaymentProcessor {
-  constructor(strategy) {
-    this.strategy = strategy;
-  }
-
-  process(payment) {
-    return this.strategy.process(payment);
-  }
-}
-
-class CreditCardStrategy {
-  process(payment) {
-    // Process credit card
-  }
-}
-
-class PayPalStrategy {
-  process(payment) {
-    // Process PayPal
-  }
-}
-
-// Usage - extend without modification
-const processor = new PaymentProcessor(new CreditCardStrategy());
-```
-
-## L - Liskov Substitution Principle (LSP)
-
-**Subclasses should be substitutable for their base classes.**
-
-### ❌ Violation
-
-```javascript
-class Rectangle {
-  setWidth(width) {
-    this.width = width;
-  }
-  setHeight(height) {
-    this.height = height;
-  }
-  getArea() {
-    return this.width * this.height;
-  }
-}
-
-class Square extends Rectangle {
-  setWidth(width) {
-    this.width = width;
-    this.height = width; // Breaks expectation
-  }
-  setHeight(height) {
-    this.width = height;
-    this.height = height;
-  }
-}
-```
-
-### ✅ Solution
-
-```javascript
-class Shape {
-  getArea() {
-    throw new Error("Must implement getArea");
-  }
-}
-
-class Rectangle extends Shape {
-  constructor(width, height) {
-    super();
-    this.width = width;
-    this.height = height;
-  }
-  getArea() {
-    return this.width * this.height;
-  }
-}
-
-class Square extends Shape {
-  constructor(side) {
-    super();
-    this.side = side;
-  }
-  getArea() {
-    return this.side * this.side;
-  }
-}
-```
-
-## I - Interface Segregation Principle (ISP)
-
-**Many specific interfaces are better than one general interface.**
-
-### ❌ Violation
-
-```javascript
-class Worker {
-  work() {}
-  eat() {}
-  sleep() {}
-}
-
-class Robot extends Worker {
-  work() {
-    /* OK */
-  }
-  eat() {
-    throw new Error("Robots don't eat");
-  }
-  sleep() {
-    throw new Error("Robots don't sleep");
-  }
-}
-```
-
-### ✅ Solution
-
-```javascript
-class Workable {
-  work() {}
-}
-
-class Eatable {
-  eat() {}
-}
-
-class Sleepable {
-  sleep() {}
-}
-
-class Human extends Workable {
-  work() {
-    /* ... */
-  }
-  eat() {
-    /* via Eatable */
-  }
-  sleep() {
-    /* via Sleepable */
-  }
-}
-
-class Robot extends Workable {
-  work() {
-    /* ... */
-  }
-  // Doesn't implement eat/sleep
-}
-```
-
-## D - Dependency Inversion Principle (DIP)
-
-**Depend on abstractions, not concretions.**
-
-### ❌ Violation
-
-```javascript
-class EmailService {
-  send(to, message) {
-    /* Send email */
-  }
-}
-
-class UserService {
-  constructor() {
-    this.emailService = new EmailService(); // Tight coupling
-  }
-
-  register(user) {
-    this.emailService.send(user.email, "Welcome");
-  }
-}
-```
-
-### ✅ Solution
-
-```javascript
-// Abstraction
-class NotificationService {
-  send(to, message) {
-    throw new Error("Must implement");
-  }
-}
-
-// Implementations
-class EmailService extends NotificationService {
-  send(to, message) {
-    /* Send email */
-  }
-}
-
-class SMSService extends NotificationService {
-  send(to, message) {
-    /* Send SMS */
-  }
-}
-
-// Depend on abstraction
-class UserService {
-  constructor(notificationService) {
-    this.notificationService = notificationService;
-  }
-
-  register(user) {
-    this.notificationService.send(user.email, "Welcome");
-  }
-}
-
-// Usage - easily swap implementations
-const userService = new UserService(new EmailService());
-```

package/.cursor/skills/test-driven-development/references/tdd-patterns.md

@@ -1,124 +0,0 @@
-# TDD Patterns
-
-## Unit Testing Patterns
-
-### Test Data Builders
-
-Create reusable test data factories:
-
-```javascript
-class UserBuilder {
-  constructor() {
-    this.user = {
-      email: "test@example.com",
-      name: "Test User",
-      role: "user",
-    };
-  }
-
-  withEmail(email) {
-    this.user.email = email;
-    return this;
-  }
-
-  withRole(role) {
-    this.user.role = role;
-    return this;
-  }
-
-  build() {
-    return this.user;
-  }
-}
-
-// Usage
-const admin = new UserBuilder().withRole("admin").build();
-```
-
-### Mock Objects
-
-Replace external dependencies:
-
-```javascript
-const mockDatabase = {
-  findUser: jest.fn().mockResolvedValue({ id: 1, name: "John" }),
-  createUser: jest.fn().mockResolvedValue({ id: 2 }),
-};
-
-test("should fetch user from database", async () => {
-  const user = await getUserById(1, mockDatabase);
-  expect(mockDatabase.findUser).toHaveBeenCalledWith(1);
-  expect(user.name).toBe("John");
-});
-```
-
-### Spy Pattern
-
-Verify function calls without replacing behavior:
-
-```javascript
-const logger = {
-  log: jest.fn(),
-};
-
-performAction(logger);
-expect(logger.log).toHaveBeenCalledWith("Action performed");
-```
-
-## Integration Testing Patterns
-
-### Database Test Pattern
-
-```javascript
-beforeEach(async () => {
-  await database.reset();
-  await database.seed();
-});
-
-afterEach(async () => {
-  await database.cleanup();
-});
-
-test("should persist user to database", async () => {
-  const user = await createUser({ email: "test@example.com" });
-  const found = await database.users.findByEmail("test@example.com");
-  expect(found).toBeDefined();
-});
-```
-
-### API Test Pattern
-
-```javascript
-describe("POST /api/users", () => {
-  it("should create user and return 201", async () => {
-    const response = await request(app)
-      .post("/api/users")
-      .send({ email: "new@example.com", name: "New User" });
-
-    expect(response.status).toBe(201);
-    expect(response.body.email).toBe("new@example.com");
-  });
-});
-```
-
-## Behavior-Driven Development (BDD)
-
-Describe tests in business terms:
-
-```javascript
-describe("User Authentication", () => {
-  describe("when credentials are valid", () => {
-    it("grants access", async () => {
-      const result = await login("user@example.com", "password");
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe("when credentials are invalid", () => {
-    it("denies access", async () => {
-      const result = await login("user@example.com", "wrong");
-      expect(result.success).toBe(false);
-    });
-  });
-});
-```

package/.cursor/skills/test-driven-development/references/testing-strategies.md

@@ -1,131 +0,0 @@
-# Testing Strategies
-
-## Frontend Component Testing
-
-### React Component Test
-
-```javascript
-import { render, screen, fireEvent } from "@testing-library/react";
-import LoginForm from "./LoginForm";
-
-test("should submit form with valid data", () => {
-  const onSubmit = jest.fn();
-  render(<LoginForm onSubmit={onSubmit} />);
-
-  fireEvent.change(screen.getByLabelText("Email"), {
-    target: { value: "test@example.com" },
-  });
-  fireEvent.change(screen.getByLabelText("Password"), {
-    target: { value: "password123" },
-  });
-  fireEvent.click(screen.getByText("Login"));
-
-  expect(onSubmit).toHaveBeenCalledWith({
-    email: "test@example.com",
-    password: "password123",
-  });
-});
-```
-
-### Vue Component Test
-
-```javascript
-import { mount } from "@vue/test-utils";
-import Counter from "./Counter.vue";
-
-test("increments counter on button click", async () => {
-  const wrapper = mount(Counter);
-  await wrapper.find("button").trigger("click");
-  expect(wrapper.text()).toContain("1");
-});
-```
-
-## API Endpoint Testing
-
-### REST API Test
-
-```javascript
-describe("GET /api/users/:id", () => {
-  it("returns user when exists", async () => {
-    const user = await createTestUser({ name: "John" });
-
-    const response = await request(app).get(`/api/users/${user.id}`);
-
-    expect(response.status).toBe(200);
-    expect(response.body.name).toBe("John");
-  });
-
-  it("returns 404 when user not found", async () => {
-    const response = await request(app).get("/api/users/999999");
-    expect(response.status).toBe(404);
-  });
-});
-```
-
-## Database Interaction Testing
-
-### Transaction Test Pattern
-
-```javascript
-test("should rollback on error", async () => {
-  await expect(async () => {
-    await database.transaction(async (trx) => {
-      await trx.users.create({ email: "test@example.com" });
-      throw new Error("Rollback!");
-    });
-  }).rejects.toThrow();
-
-  const user = await database.users.findByEmail("test@example.com");
-  expect(user).toBeNull();
-});
-```
-
-## Error Handling Tests
-
-```javascript
-test("should handle network errors gracefully", async () => {
-  mockApi.get.mockRejectedValue(new Error("Network error"));
-
-  const result = await fetchUserData(1);
-
-  expect(result.error).toBe("Failed to fetch data");
-  expect(result.data).toBeNull();
-});
-```
-
-## Edge Cases
-
-### Boundary Testing
-
-```javascript
-describe("Pagination", () => {
-  it("handles first page", async () => {
-    const result = await getUsers({ page: 1, limit: 10 });
-    expect(result.page).toBe(1);
-  });
-
-  it("handles last page", async () => {
-    const result = await getUsers({ page: 999, limit: 10 });
-    expect(result.data).toHaveLength(0);
-  });
-
-  it("handles negative page", async () => {
-    const result = await getUsers({ page: -1, limit: 10 });
-    expect(result.error).toBe("Invalid page number");
-  });
-});
-```
-
-### Null/Undefined Handling
-
-```javascript
-test("handles null input", () => {
-  expect(() => processUser(null)).toThrow("User cannot be null");
-});
-
-test("handles undefined properties", () => {
-  const user = { name: "John" }; // email is undefined
-  const result = validateUser(user);
-  expect(result.errors).toContain("Email is required");
-});
-```

package/.cursor/skills/threejs/references/01-getting-started.md

@@ -1,177 +0,0 @@
-# Getting Started with Three.js
-
-Core concepts for building your first 3D scene.
-
-## Essential Components
-
-Every Three.js app needs 3 core elements:
-
-### 1. Scene
-Container for all 3D objects, lights, cameras.
-
-```javascript
-const scene = new THREE.Scene();
-scene.background = new THREE.Color(0x000000); // black background
-scene.fog = new THREE.Fog(0xffffff, 1, 5000); // distance fog
-```
-
-### 2. Camera
-Viewpoint into the 3D scene.
-
-**PerspectiveCamera** (realistic, most common):
-```javascript
-const camera = new THREE.PerspectiveCamera(
-  75,  // fov - field of view in degrees
-  window.innerWidth / window.innerHeight,  // aspect ratio
-  0.1,  // near clipping plane
-  1000  // far clipping plane
-);
-camera.position.set(0, 0, 5);
-camera.lookAt(0, 0, 0);
-```
-
-**OrthographicCamera** (no perspective distortion):
-```javascript
-const camera = new THREE.OrthographicCamera(
-  left, right, top, bottom, near, far
-);
-```
-
-### 3. Renderer
-Renders scene using camera perspective.
-
-```javascript
-const renderer = new THREE.WebGLRenderer({ antialias: true });
-renderer.setSize(window.innerWidth, window.innerHeight);
-renderer.setPixelRatio(window.devicePixelRatio);
-document.body.appendChild(renderer.domElement);
-```
-
-## Basic Geometries
-
-Primitive shapes ready to use:
-
-```javascript
-// Box
-new THREE.BoxGeometry(width, height, depth);
-
-// Sphere
-new THREE.SphereGeometry(radius, widthSegments, heightSegments);
-
-// Plane
-new THREE.PlaneGeometry(width, height);
-
-// Cylinder
-new THREE.CylinderGeometry(radiusTop, radiusBottom, height, radialSegments);
-
-// Cone
-new THREE.ConeGeometry(radius, height, radialSegments);
-
-// Torus
-new THREE.TorusGeometry(radius, tube, radialSegments, tubularSegments);
-```
-
-## Basic Materials
-
-Materials define surface appearance:
-
-**MeshBasicMaterial** - unlit, flat color:
-```javascript
-new THREE.MeshBasicMaterial({ color: 0xff0000 });
-```
-
-**MeshStandardMaterial** - PBR, responds to lights:
-```javascript
-new THREE.MeshStandardMaterial({
-  color: 0x00ff00,
-  metalness: 0.5,
-  roughness: 0.5
-});
-```
-
-**MeshPhongMaterial** - specular highlights:
-```javascript
-new THREE.MeshPhongMaterial({
-  color: 0x0000ff,
-  shininess: 100
-});
-```
-
-## Creating Mesh
-
-Combine geometry + material:
-
-```javascript
-const geometry = new THREE.BoxGeometry(1, 1, 1);
-const material = new THREE.MeshStandardMaterial({ color: 0x00ff00 });
-const cube = new THREE.Mesh(geometry, material);
-scene.add(cube);
-```
-
-## Basic Lights
-
-Materials (except Basic) need lights to be visible:
-
-```javascript
-// Ambient - global illumination
-const ambient = new THREE.AmbientLight(0x404040); // soft white
-scene.add(ambient);
-
-// Directional - sun-like, infinite distance
-const directional = new THREE.DirectionalLight(0xffffff, 1);
-directional.position.set(5, 5, 5);
-scene.add(directional);
-
-// Point - lightbulb, radiates in all directions
-const point = new THREE.PointLight(0xff0000, 1, 100);
-point.position.set(0, 10, 0);
-scene.add(point);
-```
-
-## Animation Loop
-
-Continuously render and update scene:
-
-```javascript
-function animate() {
-  requestAnimationFrame(animate);
-
-  // Update objects
-  cube.rotation.x += 0.01;
-  cube.rotation.y += 0.01;
-
-  // Render
-  renderer.render(scene, camera);
-}
-animate();
-```
-
-## Handle Window Resize
-
-Keep aspect ratio correct:
-
-```javascript
-window.addEventListener('resize', () => {
-  camera.aspect = window.innerWidth / window.innerHeight;
-  camera.updateProjectionMatrix();
-  renderer.setSize(window.innerWidth, window.innerHeight);
-});
-```
-
-## Object3D Hierarchy
-
-Transform and group objects:
-
-```javascript
-const group = new THREE.Group();
-group.add(cube1);
-group.add(cube2);
-scene.add(group);
-
-// Transform
-object.position.set(x, y, z);
-object.rotation.set(x, y, z); // Euler angles
-object.scale.set(x, y, z);
-
-// Hierarchy transforms are relative to parent
-```