anchi-kit 1.2.3 → 1.2.6

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

@@ -0,0 +1,293 @@
+# 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/.antigravity/skills/test-driven-development/references/tdd-patterns.md

@@ -0,0 +1,124 @@
+# 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/.antigravity/skills/test-driven-development/references/testing-strategies.md

@@ -0,0 +1,131 @@
+# 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/.antigravity/skills/threejs/references/01-getting-started.md

@@ -0,0 +1,177 @@
+# 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
+```