@thanhthi2895/luna-ai 2.16.2

package/agentic/antigravity/.agents/skills/frontend-development/resources/typescript-standards.md

@@ -0,0 +1,418 @@
+# TypeScript Standards
+
+TypeScript best practices for type safety and maintainability in React frontend code.
+
+---
+
+## Strict Mode
+
+### Configuration
+
+TypeScript strict mode is **enabled** in the project:
+
+```json
+// tsconfig.json
+{
+    "compilerOptions": {
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true
+    }
+}
+```
+
+**This means:**
+- No implicit `any` types
+- Null/undefined must be handled explicitly
+- Type safety enforced
+
+---
+
+## No `any` Type
+
+### The Rule
+
+```typescript
+// ❌ NEVER use any
+function handleData(data: any) {
+    return data.something;
+}
+
+// ✅ Use specific types
+interface MyData {
+    something: string;
+}
+
+function handleData(data: MyData) {
+    return data.something;
+}
+
+// ✅ Or use unknown for truly unknown data
+function handleUnknown(data: unknown) {
+    if (typeof data === 'object' && data !== null && 'something' in data) {
+        return (data as MyData).something;
+    }
+}
+```
+
+**If you truly don't know the type:**
+- Use `unknown` (forces type checking)
+- Use type guards to narrow
+- Document why type is unknown
+
+---
+
+## Explicit Return Types
+
+### Function Return Types
+
+```typescript
+// ✅ CORRECT - Explicit return type
+function getUser(id: number): Promise<User> {
+    return apiClient.get(`/users/${id}`);
+}
+
+function calculateTotal(items: Item[]): number {
+    return items.reduce((sum, item) => sum + item.price, 0);
+}
+
+// ❌ AVOID - Implicit return type (less clear)
+function getUser(id: number) {
+    return apiClient.get(`/users/${id}`);
+}
+```
+
+### Component Return Types
+
+```typescript
+// React.FC already provides return type (ReactElement)
+export const MyComponent: React.FC<Props> = ({ prop }) => {
+    return <div>{prop}</div>;
+};
+
+// For custom hooks
+function useMyData(id: number): { data: Data; isLoading: boolean } {
+    const [data, setData] = useState<Data | null>(null);
+    const [isLoading, setIsLoading] = useState(true);
+
+    return { data: data!, isLoading };
+}
+```
+
+---
+
+## Type Imports
+
+### Use 'type' Keyword
+
+```typescript
+// ✅ CORRECT - Explicitly mark as type import
+import type { User } from '~types/user';
+import type { Post } from '~types/post';
+import type { SxProps, Theme } from '@mui/material';
+
+// ❌ AVOID - Mixed value and type imports
+import { User } from '~types/user';  // Unclear if type or value
+```
+
+**Benefits:**
+- Clearly separates types from values
+- Better tree-shaking
+- Prevents circular dependencies
+- TypeScript compiler optimization
+
+---
+
+## Component Prop Interfaces
+
+### Interface Pattern
+
+```typescript
+/**
+ * Props for MyComponent
+ */
+interface MyComponentProps {
+    /** The user ID to display */
+    userId: number;
+
+    /** Optional callback when action completes */
+    onComplete?: () => void;
+
+    /** Display mode for the component */
+    mode?: 'view' | 'edit';
+
+    /** Additional CSS classes */
+    className?: string;
+}
+
+export const MyComponent: React.FC<MyComponentProps> = ({
+    userId,
+    onComplete,
+    mode = 'view',  // Default value
+    className,
+}) => {
+    return <div>...</div>;
+};
+```
+
+**Key Points:**
+- Separate interface for props
+- JSDoc comments for each prop
+- Optional props use `?`
+- Provide defaults in destructuring
+
+### Props with Children
+
+```typescript
+interface ContainerProps {
+    children: React.ReactNode;
+    title: string;
+}
+
+// React.FC automatically includes children type, but be explicit
+export const Container: React.FC<ContainerProps> = ({ children, title }) => {
+    return (
+        <div>
+            <h2>{title}</h2>
+            {children}
+        </div>
+    );
+};
+```
+
+---
+
+## Utility Types
+
+### Partial<T>
+
+```typescript
+// Make all properties optional
+type UserUpdate = Partial<User>;
+
+function updateUser(id: number, updates: Partial<User>) {
+    // updates can have any subset of User properties
+}
+```
+
+### Pick<T, K>
+
+```typescript
+// Select specific properties
+type UserPreview = Pick<User, 'id' | 'name' | 'email'>;
+
+const preview: UserPreview = {
+    id: 1,
+    name: 'John',
+    email: 'john@example.com',
+    // Other User properties not allowed
+};
+```
+
+### Omit<T, K>
+
+```typescript
+// Exclude specific properties
+type UserWithoutPassword = Omit<User, 'password' | 'passwordHash'>;
+
+const publicUser: UserWithoutPassword = {
+    id: 1,
+    name: 'John',
+    email: 'john@example.com',
+    // password and passwordHash not allowed
+};
+```
+
+### Required<T>
+
+```typescript
+// Make all properties required
+type RequiredConfig = Required<Config>;  // All optional props become required
+```
+
+### Record<K, V>
+
+```typescript
+// Type-safe object/map
+const userMap: Record<string, User> = {
+    'user1': { id: 1, name: 'John' },
+    'user2': { id: 2, name: 'Jane' },
+};
+
+// For styles
+import type { SxProps, Theme } from '@mui/material';
+
+const styles: Record<string, SxProps<Theme>> = {
+    container: { p: 2 },
+    header: { mb: 1 },
+};
+```
+
+---
+
+## Type Guards
+
+### Basic Type Guards
+
+```typescript
+function isUser(data: unknown): data is User {
+    return (
+        typeof data === 'object' &&
+        data !== null &&
+        'id' in data &&
+        'name' in data
+    );
+}
+
+// Usage
+if (isUser(response)) {
+    console.log(response.name);  // TypeScript knows it's User
+}
+```
+
+### Discriminated Unions
+
+```typescript
+type LoadingState =
+    | { status: 'idle' }
+    | { status: 'loading' }
+    | { status: 'success'; data: Data }
+    | { status: 'error'; error: Error };
+
+function Component({ state }: { state: LoadingState }) {
+    // TypeScript narrows type based on status
+    if (state.status === 'success') {
+        return <Display data={state.data} />;  // data available here
+    }
+
+    if (state.status === 'error') {
+        return <Error error={state.error} />;  // error available here
+    }
+
+    return <Loading />;
+}
+```
+
+---
+
+## Generic Types
+
+### Generic Functions
+
+```typescript
+function getById<T>(items: T[], id: number): T | undefined {
+    return items.find(item => (item as any).id === id);
+}
+
+// Usage with type inference
+const users: User[] = [...];
+const user = getById(users, 123);  // Type: User | undefined
+```
+
+### Generic Components
+
+```typescript
+interface ListProps<T> {
+    items: T[];
+    renderItem: (item: T) => React.ReactNode;
+}
+
+export function List<T>({ items, renderItem }: ListProps<T>): React.ReactElement {
+    return (
+        <div>
+            {items.map((item, index) => (
+                <div key={index}>{renderItem(item)}</div>
+            ))}
+        </div>
+    );
+}
+
+// Usage
+<List<User>
+    items={users}
+    renderItem={(user) => <UserCard user={user} />}
+/>
+```
+
+---
+
+## Type Assertions (Use Sparingly)
+
+### When to Use
+
+```typescript
+// ✅ OK - When you know more than TypeScript
+const element = document.getElementById('my-element') as HTMLInputElement;
+const value = element.value;
+
+// ✅ OK - API response that you've validated
+const response = await api.getData();
+const user = response.data as User;  // You know the shape
+```
+
+### When NOT to Use
+
+```typescript
+// ❌ AVOID - Circumventing type safety
+const data = getData() as any;  // WRONG - defeats TypeScript
+
+// ❌ AVOID - Unsafe assertion
+const value = unknownValue as string;  // Might not actually be string
+```
+
+---
+
+## Null/Undefined Handling
+
+### Optional Chaining
+
+```typescript
+// ✅ CORRECT
+const name = user?.profile?.name;
+
+// Equivalent to:
+const name = user && user.profile && user.profile.name;
+```
+
+### Nullish Coalescing
+
+```typescript
+// ✅ CORRECT
+const displayName = user?.name ?? 'Anonymous';
+
+// Only uses default if null or undefined
+// (Different from || which triggers on '', 0, false)
+```
+
+### Non-Null Assertion (Use Carefully)
+
+```typescript
+// ✅ OK - When you're certain value exists
+const data = queryClient.getQueryData<Data>(['data'])!;
+
+// ⚠️ CAREFUL - Only use when you KNOW it's not null
+// Better to check explicitly:
+const data = queryClient.getQueryData<Data>(['data']);
+if (data) {
+    // Use data
+}
+```
+
+---
+
+## Summary
+
+**TypeScript Checklist:**
+- ✅ Strict mode enabled
+- ✅ No `any` type (use `unknown` if needed)
+- ✅ Explicit return types on functions
+- ✅ Use `import type` for type imports
+- ✅ JSDoc comments on prop interfaces
+- ✅ Utility types (Partial, Pick, Omit, Required, Record)
+- ✅ Type guards for narrowing
+- ✅ Optional chaining and nullish coalescing
+- ❌ Avoid type assertions unless necessary
+
+**See Also:**
+- [component-patterns.md](component-patterns.md) - Component typing
+- [data-fetching.md](data-fetching.md) - API typing

package/agentic/antigravity/.agents/skills/git/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: lu:git
+author: luna
+description: "Git operations with conventional commits. Supports GitHub and GitLab (auto-detected from remote URL). Use for staging, committing, pushing, PRs/MRs, merges. Auto-splits commits by type/scope. Security scans for secrets."
+argument-hint: "cm|cp|pr|merge [args]"
+version: 1.0.0
+---
+
+# Git Operations
+
+## Default (No Arguments)
+
+If invoked without arguments, ask in your response which operation the user wants:
+
+| Operation | Description                          |
+| --------- | ------------------------------------ |
+| `cm`      | Stage files & create commits         |
+| `cp`      | Stage files, create commits and push |
+| `pr`      | Create Pull Request                  |
+| `merge`   | Merge branches                       |
+
+**IMPORTANT — Execution order (MANDATORY):**
+
+1. Run **Step 0: Branch Safety Check** using `run_command` tool
+2. Execute ALL remaining steps directly using `run_command` tool — **NEVER use `browser_subagent` for git operations**
+
+> Git operations are terminal-only. Use `run_command` for every shell command.
+
+**IMPORTANT:**
+
+- Sacrifice grammar for the sake of concision.
+- Ensure token efficiency while maintaining high quality.
+- Pass these rules to subagents.
+- **NEVER open a browser** — all `gh` CLI commands must be non-interactive (no `--web`, no `gh browse`, no `gh auth login`). If `gh` is not authenticated, report the error and stop.
+
+## Arguments
+
+- `cm`: Stage files & create commits
+- `cp`: Stage files, create commits and push
+- `pr`: Create Pull Request [to-branch] [from-branch]
+  - `to-branch`: Target branch (default: main)
+  - `from-branch`: Source branch (default: current branch)
+- `merge`: Merge [to-branch] [from-branch]
+  - `to-branch`: Target branch (default: main)
+  - `from-branch`: Source branch (default: current branch)
+
+## Quick Reference
+
+| Task          | Reference                         |
+| ------------- | --------------------------------- |
+| Commit        | `references/workflow-commit.md`   |
+| Push          | `references/workflow-push.md`     |
+| Pull Request  | `references/workflow-pr.md`       |
+| Merge         | `references/workflow-merge.md`    |
+| Standards     | `references/commit-standards.md`  |
+| Safety        | `references/safety-protocols.md`  |
+| Branches      | `references/branch-management.md` |
+| GitHub CLI    | `references/gh-cli-guide.md`      |
+| GitLab CLI    | `references/glab-cli-guide.md`    |
+| Platform Det. | `references/platform-detect.md`   |
+
+## Core Workflow
+
+### Step 0: Branch Safety Check (MANDATORY — runs before everything)
+
+```bash
+git branch --show-current
+```
+
+**Protected branches:** `main`, `master`, `staging`, `dev`, `develop`, `production`, `prod`, `release/*`
+
+| Condition                       | Action                    |
+| ------------------------------- | ------------------------- |
+| Current branch is NOT protected | ✅ Continue to Step 1     |
+| Current branch IS protected     | 🔀 Auto-create new branch |
+
+**When on a protected branch — ALWAYS auto-create a new branch (MANDATORY, no exceptions):**
+
+1. Inspect staged/unstaged changes to infer a branch name prefix: `feat/`, `fix/`, `chore/`
+2. Generate a concise, kebab-case branch name from the change context
+3. Run: `git checkout -b <branch-name>`
+4. Inform the user: "⚠️ Protected branch detected. Auto-created new branch: `<branch-name>`"
+5. Continue to Step 1
+
+### Step 0b: Platform Detection (PR / issue search operations)
+
+For `pr` operation and issue search in Step 3, run detection from `references/platform-detect.md`:
+
+```bash
+# Sets PLATFORM=github|gitlab and PLATFORM_CLI=gh|glab
+# Verifies CLI installed and authenticated
+# Abort with clear error if CLI missing or unauthenticated
+```
+
+→ Skip this step for `cm`, `cp`, `merge` (pure git, platform-agnostic)
+
+### Step 1: Stage + Analyze
+
+First, analyze changes without staging:
+
+```bash
+git status && git diff --stat && git diff --name-only
+```
+
+Then stage **specific files by name** (never use `git add -A` or `git add .`):
+
+```bash
+git add <file1> <file2> ...
+git diff --cached --stat && git diff --cached --name-only
+```
+
+### Step 2: Security Check
+
+Scan for secrets before commit:
+
+```bash
+git diff --cached | grep -iE "(api[_-]?key|token|password|secret|credential)"
+```
+
+**If secrets found:** STOP, warn user, unstage sensitive files, suggest `.gitignore`.
+
+### Step 3: Split Decision
+
+**NOTE:**
+
+- Search related issues (CLI only, no browser). Use PLATFORM from `platform-detect.md`:
+  - GitHub: `gh issue list --json number,title --limit 10`
+  - GitLab: `glab issue list --json --limit 10`
+  - If unauthenticated or CLI not found, skip this step.
+- Only use `feat`, `fix`, or `perf` prefixes for files in `.claude` directory (do not use `docs`).
+
+**Split commits if:**
+
+- Different types mixed (feat + fix, code + docs)
+- Multiple scopes (auth + payments)
+- Config/deps + code mixed
+- FILES > 10 unrelated
+
+**Single commit if:**
+
+- Same type/scope, FILES ≤ 3, LINES ≤ 50
+
+### Step 4: Commit
+
+```bash
+git commit -m "$(cat <<'EOF'
+type(scope): description
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+EOF
+)"
+```
+
+### Step 5: PR/MR Body Formatting (MANDATORY)
+
+When using `gh pr create` or `glab mr create` with multi-line body/description, ALWAYS use HEREDOC wrapped by command substitution.
+
+✅ Correct:
+```bash
+--body "$(cat <<'EOF'
+## Summary
+- ...
+EOF
+)"
+```
+
+❌ Avoid:
+```bash
+--body "line1
+line2"
+```
+
+Reason: prevents shell quoting/newline breakage and keeps command non-interactive/reliable.
+
+## Output Format
+
+```
+✓ staged: N files (+X/-Y lines)
+✓ security: passed
+✓ commit: HASH type(scope): description
+✓ pushed: yes/no
+```
+
+## Error Handling
+
+| Error                     | Action                            |
+| ------------------------- | --------------------------------- |
+| Protected branch detected | Auto-create new branch, no prompt |
+| Secrets detected          | Block commit, show files          |
+| No changes                | Exit cleanly                      |
+| Push rejected             | Suggest `git pull --rebase`       |
+| Merge conflicts           | Suggest manual resolution         |
+
+## References
+
+- `references/workflow-commit.md` - Commit workflow with split logic
+- `references/workflow-push.md` - Push workflow with error handling
+- `references/workflow-pr.md` - PR (GitHub) / MR (GitLab) creation with remote diff analysis
+- `references/workflow-merge.md` - Branch merge workflow
+- `references/commit-standards.md` - Conventional commit format rules
+- `references/safety-protocols.md` - Secret detection, branch protection
+- `references/branch-management.md` - Naming, lifecycle, strategies
+- `references/gh-cli-guide.md` - GitHub CLI commands reference
+- `references/glab-cli-guide.md` - GitLab CLI commands reference
+- `references/platform-detect.md` - Platform auto-detection logic (GitHub vs GitLab)

package/agentic/antigravity/.agents/skills/git/references/branch-management.md

@@ -0,0 +1,88 @@
+# Branch Management
+
+## Naming Convention
+
+**Format:** `<type>/<descriptive-name>`
+
+| Type | Purpose | Example |
+|------|---------|---------|
+| `feature/` | New features | `feature/oauth-login` |
+| `fix/` | Bug fixes | `fix/db-timeout` |
+| `refactor/` | Code restructure | `refactor/api-cleanup` |
+| `docs/` | Documentation | `docs/api-reference` |
+| `test/` | Test improvements | `test/integration-suite` |
+| `chore/` | Maintenance | `chore/deps-update` |
+| `hotfix/` | Production fixes | `hotfix/payment-crash` |
+
+## Branch Lifecycle
+
+### Create
+```bash
+git checkout main
+git pull origin main
+git checkout -b feature/new-feature
+```
+
+### During Development
+```bash
+# Regular commits
+git add <files> && git commit -m "feat(scope): description"
+
+# Stay current with main
+git fetch origin
+git rebase origin/main
+```
+
+### Before Merge
+```bash
+# Push final state
+git push origin feature/new-feature
+
+# Or after rebase (feature branches only)
+git push -f origin feature/new-feature
+```
+
+### After Merge
+```bash
+# Delete local
+git branch -d feature/new-feature
+
+# Delete remote
+git push origin --delete feature/new-feature
+```
+
+## Branch Strategies
+
+### Simple (small teams)
+```
+main (production)
+  └─ feature/* (development)
+```
+
+### Git Flow (releases)
+```
+main (production)
+develop (staging)
+  ├─ feature/*
+  ├─ bugfix/*
+  ├─ hotfix/*
+  └─ release/*
+```
+
+### Trunk-Based (CI/CD)
+```
+main (always deployable)
+  └─ short-lived feature branches
+```
+
+## Quick Commands
+
+| Task | Command |
+|------|---------|
+| List branches | `git branch -a` |
+| Current branch | `git rev-parse --abbrev-ref HEAD` |
+| Switch branch | `git checkout <branch>` |
+| Create + switch | `git checkout -b <branch>` |
+| Delete local | `git branch -d <branch>` |
+| Delete remote | `git push origin --delete <branch>` |
+| Rename | `git branch -m <old> <new>` |