blamcode 0.4.0__py3-none-any.whl

blamcode/layer/skills/docker/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: docker
+description: Docker for desktop users — containers, images, docker-compose — run and isolate apps. Use when user has a PC/server with Docker and wants to package, run, or keep apps isolated.
+---
+
+# Docker Skill (Desktop Users)
+
+## When Docker makes sense
+- The user has a PC or VPS (Termux itself can't run Docker natively — no proot needed, it just won't work)
+- Multiple apps on one server that must not conflict (different Python/Node versions)
+- Reproducible deploys — "works on my machine" disappears
+- For a simple single app on a phone — Docker is overkill; skip it
+
+## Basic workflow
+```dockerfile
+# Dockerfile — small, safe
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+CMD ["python", "main.py"]
+```
+```sh
+docker build -t myapp .      # build the image
+docker run -p 8080:8080 myapp   # run it (host port 8080 → container 8080)
+docker ps                    # list running containers
+docker stop <id>             # stop one
+```
+
+## docker-compose (multiple services — the usual real case)
+```yaml
+# docker-compose.yml
+services:
+  web:
+    build: .
+    ports: ["8080:8080"]
+    environment:
+      DB_URL: postgres://user:pass@db:5432/app
+    depends_on: [db]
+  db:
+    image: postgres:16
+    environment:
+      POSTGRES_PASSWORD: change_me
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+volumes:
+  pgdata:
+```
+```sh
+docker compose up -d     # start everything in the background
+docker compose logs -f   # follow logs
+docker compose down      # stop (add -v to delete data volumes — careful!)
+```
+
+## Rules (strict)
+- **Never put secrets in the Dockerfile** (they end up in image history).
+  Use `.env` + `environment:` / compose `env_file:`
+- **Don't run as root in the container** — add a non-root user:
+  `RUN useradd -m app && USER app`
+- Pin versions (`python:3.12-slim`, `postgres:16`) — `latest` breaks builds later
+- `.dockerignore` — keep node_modules, .git, .env out of the build context (faster + safer)
+- One process per container; data in **volumes**, never inside the container (lost on recreate)
+- `docker exec -it <id> sh` to debug inside
+
+## Common fixes
+- "port already in use" → `docker ps` shows another container → stop it or change `-p` port
+- Container exits instantly → `docker logs <id>` — the app crashed at startup
+- Can't reach the app → check `-p HOST:CONTAINER` mapping and the app binds 0.0.0.0 inside
+- Build too slow → run again; layers are cached. Put `requirements.txt` BEFORE the code copy
+
+## Deliver
+- Dockerfile + compose file + the exact commands to build/run/stop
+- One line on how to update: rebuild + `docker compose up -d` again

blamcode/layer/skills/firebase-supabase/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: firebase-supabase
+description: Backend without your own server — Firebase and Supabase: auth, database, storage, hosting. Use when user wants a backend, login system, realtime data, or "server-less" storage for an app.
+---
+
+# Firebase + Supabase Skill (Backend Without a Server)
+
+## Choose the platform
+- **Supabase** — PostgreSQL, SQL, generous **free tier**, more transparent pricing.
+  Best default for new projects
+- **Firebase** — Google, realtime database + very easy auth, great for quick apps;
+  free tier is small and billing surprises are common. Use when the user prefers Google
+- Both give: database, auth, file storage, hosting — no server to manage
+
+## Supabase quick start
+```sh
+npm i @supabase/supabase-js
+```
+```js
+import { createClient } from '@supabase/supabase-js';
+const supabase = createClient(import.meta.env.VITE_SUPABASE_URL,
+                               import.meta.env.VITE_SUPABASE_ANON_KEY);
+// fetch rows
+const { data, error } = await supabase.from('todos').select('*').order('created_at');
+// insert
+const { error: err2 } = await supabase.from('todos').insert({ title: 'Buy milk' });
+```
+- Keys in `.env` (Vite: `VITE_` prefix) — the **anon key is public by design**;
+  real security comes from **RLS (Row Level Security)** policies — enable them!
+
+## Firebase quick start
+```js
+import { initializeApp } from 'firebase/app';
+import { getFirestore, collection, addDoc, getDocs } from 'firebase/firestore';
+const app = initializeApp({ /* config from Firebase console */ });
+const db = getFirestore(app);
+await addDoc(collection(db, 'todos'), { title: 'Buy milk', done: false });
+```
+- Firestore security rules: use `match /todos/{id}` + `allow read, write: if request.auth != null` — default "open" is dangerous
+
+## Security rules (MUST — both platforms)
+- **Never trust the client.** The anon key / config is public — the database rules
+  are the real lock
+- Default = deny; allow the minimum (`if request.auth != null`, ownership checks:
+  `request.auth.uid == resource.data.user_id`)
+- Test the rules from a second browser/incognito to prove they block
+
+## Auth patterns
+- Email+password easiest; Google sign-in great UX (needs OAuth client config)
+- Store the user id (`auth.uid`) on every row so ownership checks work
+- Never store passwords yourself — let the platform handle auth
+
+## Hosting
+- **Supabase**: static hosting via Netlify/Vercel + the Supabase backend (see deploy-hosting skill)
+- **Firebase Hosting**: `npm i -g firebase-tools` → `firebase deploy` (only from PC
+  realistically — Termux has issues; Netlify/Vercel work fine from the browser)
+
+## Deliver
+- The app + working demo instructions
+- Explain the free-tier limits honestly (Supabase: 500 MB DB, Firestore: 1 GiB / day free)
+- Remind: enable RLS / security rules — say it is not optional

blamcode/layer/skills/git-workflow/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: git-workflow
+description: Clean, safe git — create repos, commit, branch, push, resolve conflicts, upload to GitHub. Use for any git/GitHub task.
+---
+
+# Git Workflow Skill (Full-Power)
+
+## Termux setup (first time)
+```sh
+git config --global user.name "Name"
+git config --global user.email "email@example.com"
+```
+- Pushing needs a GitHub PAT (fine-grained, repo access only) — help the user
+  set it up; never save or log the key in any file
+
+## Safety rules
+- No commit/push unless the user asked for it
+- Before committing: check `git status` + `git diff` — stage only intended files
+- Secret check: `.env`, `*.key`, tokens — if they appear in the diff, stop
+  - Put `.env` in `.gitignore` from the start
+- Never `git push --force` (only if the user explicitly asks, with a warning)
+- Never rewrite history (rebase -i, amending pushed commits) — fix forward
+
+## Daily flows
+```sh
+# new work
+git checkout -b feature/login
+# ... work ...
+git add <files> && git commit -m "login page add"
+
+# pull updates
+git pull --ff-only
+
+# undo last commit (soft — changes stay)
+git reset --soft HEAD~1
+
+# save local mess for later
+git stash        # ...do other work...
+git stash pop
+
+# discard a file's changes (before committing)
+git checkout -- <file>
+```
+
+## Commit message style
+- Short + present tense: `add login page`, `fix navbar overflow on mobile`
+- Why the change happened (2-3 lines in the body for big changes)
+
+## Conflict resolve
+1. `git status` — which files conflict
+2. Read the file — the `<<<<<<<` markers show both sides
+3. Merge based on BOTH sides' intention — never blindly pick one side
+4. Delete the markers, `git add`, commit
+
+## Uploading a new project to GitHub
+```sh
+git init && git add . && git commit -m "first commit"
+git branch -M main
+git remote add origin https://github.com/<user>/<repo>.git
+git push -u origin main
+```
+- Files over 50MB won't go to GitHub — use Git LFS or a media cloud link
+- Confirm with the user whether the repo should be public or private