checkmyvibe 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,67 @@
+# checkmyvibe
+
+A structured, zero-dependency, local security-audit workflow packaged as an Agent Skill for AI coding assistants (such as Claude Code, Cursor, Codex, and Gemini CLI).
+
+AI-generated ("vibe-coded") applications built on modern AI tools frequently ship with serious, well-documented security flaws—such as exposed API keys, fake authentication stubs, permissive default database rules, and client-side pricing logic. **checkmyvibe** solves this by packaging security checks directly into an Agent Skill. When you ask your coding agent to "run a security audit," the agent uses checkmyvibe's local helper scripts and its own reasoning capabilities to analyze your codebase, producing a prioritized report detailing what's wrong, why it matters, and how to fix it.
+
+---
+
+## What This Checks For
+
+*   **Exposed Secrets & API Keys:** Identifies hardcoded API keys, JWT secrets, database credentials, and high-entropy strings across your files (using standard prefixes like `sk_live`, `AIza`, `AKIA`, and `ghp_`).
+*   **Version Control Leakage:** Verifies if sensitive files (like `.env`) exist in the project but are not properly excluded in your `.gitignore` file.
+*   **Fake & Stubbed Authentication:** Greps for common mock authentication markers (such as functions named `mockAuth`, `fakeLogin`, `tempAuth`, or logic that returns `true` unconditionally to bypass authentication checks).
+*   **Database Misconfigurations:** Identifies permissive default rules (such as `allow read, write: if true;` in Firebase/Firestore configs) and checks if Row-Level Security (RLS) is enabled on Supabase database schemas.
+*   **Broken Object-Level Authorization (BOLA/IDOR):** Analyzes API routes to check if endpoints fetch resources by ID without validating that the authenticated user owns or has permission to access that resource.
+*   **Client-Side Payment & Pricing Logic:** Scans checkout routes and payment integrations to check if prices or transaction values are calculated or accepted directly from client-side parameters rather than securely fetched on the server.
+
+---
+
+## What This Does NOT Check For (Disclaimer)
+
+> [!WARNING]
+> **checkmyvibe is not a substitute for a full professional security audit.**
+> This tool is a first-pass heuristic scanner meant to highlight common mistakes made by AI coding models during rapid scaffolding. It does not perform dynamic runtime analysis, penetration testing, deep static analysis, dependency vulnerability checks, or comprehensive logic auditing. Do not rely solely on checkmyvibe to declare your application secure for production.
+
+---
+
+## Installation
+
+### Method 1: Using npx (Recommended)
+You can install and copy the skill automatically to your project or global environment by running:
+
+```bash
+npx checkmyvibe
+```
+
+The installer will detect if you have a `.claude` configuration directory in your project root and offer to install it either locally (project-level) or globally for your user.
+
+### Method 2: Manual Installation
+If you prefer not to use `npx`, copy the files manually:
+
+1. Create a `checkmyvibe` directory inside your agent's skills path:
+   * **Project-level (Claude Code):** `.claude/skills/checkmyvibe/`
+   * **Global/Personal (Claude Code):** `~/.claude/skills/checkmyvibe/`
+2. Copy `SKILL.md`, the `scripts/` folder, and the `references/` folder into that directory.
+
+---
+
+## Usage
+
+Once installed, your AI coding agent will automatically recognize the `checkmyvibe` skill when relevant. You can trigger the workflow explicitly:
+
+### Claude Code
+Open your terminal in the workspace and type:
+```bash
+/bug run a security audit
+```
+*Or simply ask Claude in the chat:*
+> "Run a security audit on this project using checkmyvibe"
+
+The agent will walk through the checks, execute the local python validation scripts, and print a prioritized markdown report (Critical / Should Fix / Worth Reviewing) with instructions on how to correct the issues.
+
+---
+
+## License
+
+This project is open-source and licensed under the [Apache 2.0 License](LICENSE).

package/SKILL.md

@@ -0,0 +1,326 @@
+---
+name: checkmyvibe
+description: >
+  Use this skill when the user asks for a security review, security audit, penetration test, or "is this safe to ship / safe to launch" check. Also trigger proactively when the agent is about to help deploy, publish, or push an application live, or when the codebase shows signs of AI-scaffolded patterns (Supabase/Firebase config, recently generated boilerplate, auth stubs, no existing security review) and the user has not had one done yet. Covers the specific, documented vulnerability patterns common in AI-generated and vibe-coded applications: exposed secrets, missing or fake authentication, permissive database rules, broken object-level authorization, unvalidated inputs, and client-side payment or pricing logic.
+---
+
+# checkmyvibe — Security Audit for Vibe-Coded Apps
+
+## Why this skill exists
+
+AI coding tools optimize for "it works," not "it's safe." A feature can pass every
+manual test a non-technical founder runs — sign up, log in, place an order — and
+still leak every other user's data to a stranger who changes one number in a URL.
+This happens because AI-generated code frequently ships with scaffolding shortcuts
+that were meant to be temporary (a stub auth check, a permissive default database
+rule) and never get hardened before launch, precisely because the person building
+the app doesn't know those shortcuts exist or what to look for.
+
+Your job when this skill is active: think like a security engineer doing a
+pre-launch review for a client who has never heard the words "IDOR" or "row-level
+security." Find the real, exploitable issues. Explain them in plain language. Give
+exact fixes. Do not pad the report with theoretical concerns that don't apply to
+this specific codebase, and do not skip a check because the codebase "looks
+simple" — simple codebases are exactly where stubbed auth and hardcoded secrets
+hide, because nobody expected them to hold real user data yet.
+
+## Scope and honesty (read this before writing any report)
+
+This is a first-pass audit for known, documented failure patterns. It is not a
+full penetration test, it does not cover infrastructure security, dependency
+vulnerabilities, or novel/business-logic-specific flaws outside the six categories
+below. Never tell the user their app is "secure" or "safe" in an unqualified way.
+The correct language is "no issues found in this pass" or "ready to ship as far as
+these checks go" — always paired with the scope reminder in the Final Summary
+section. If the app appears to handle payments, health data, or other regulated
+data, say explicitly that a professional audit is strongly recommended regardless
+of what this pass finds.
+
+## Before you start
+
+1. **Analyze and understand the whole project first:** Walk the directory tree and analyze the repository configuration files before running any checks, generating findings, or providing instructions. Establish a solid high-level understanding of the architecture, components, and data flow.
+2. Identify the stack: what backend/framework, what database or BaaS provider
+   (Supabase, Firebase, custom Postgres, etc.), what auth approach is in use.
+   This changes which checks apply and how to phrase findings.
+3. Identify what data the app handles: user accounts, payments, health data,
+   messages between users, files. This changes severity judgments — the same
+   missing check is more severe on an app handling payment data than on a toy
+   to-do list.
+4. Run the checks below in order. Use the bundled scripts where noted. For
+   everything else, read the actual code — don't rely on file names alone.
+
+---
+
+
+## Supported stacks to recognize
+
+Common stacks this skill should expect include: Next.js, Express, FastAPI, Supabase, Firebase, Prisma, Postgres, MongoDB, Clerk, NextAuth, Stripe, and common app patterns built around them.
+
+## Evidence and confidence rules
+
+- Only flag something when there is evidence in the code.
+- Do not guess from filenames, comments, or variable names alone.
+- If something looks suspicious but is not fully proven, mark it with a confidence tag such as `High confidence`, `Medium confidence`, or `Needs manual review`.
+- Do not overflag. Prefer one precise finding over several weak or duplicate ones.
+
+## Fix priority
+
+When multiple issues are found, sort them in this order:
+Critical user exposure > auth bypass > IDOR > payment logic > config issues > hygiene.
+
+## What success looks like
+
+The report should help the coding agent make the repo safer in the next commit, not just describe problems.
+
+## Check 1: Exposed secrets and credentials
+
+**Run the script** `scripts/scan_secrets.py` (located relative to this `SKILL.md` file) against the project root. It flags known key
+prefixes (`sk_live`, `sk_test`, `AIza`, `AKIA`, `ghp_`, `xox[bp]`), high-entropy
+strings, and variable assignments where a name like `key`, `secret`, `token`, or
+`password` is set to a literal string instead of `process.env.X` or equivalent.
+
+**What counts as a finding:**
+- A real credential committed directly in source, e.g.:
+  `const stripeKey = "sk_live_51H8x..."` — Critical
+- A secret present only in `.env` but `.env` is not gitignored (see Check 2) —
+  Critical, because it WILL leak on the next commit even if it hasn't yet
+- A secret exposed to the client bundle — e.g. a server-only key referenced in
+  frontend code, or a Next.js env var missing the required server-only scoping
+  (using a secret key where only `NEXT_PUBLIC_`-prefixed vars should appear) —
+  Critical, this is directly shippable to every visitor's browser
+
+**What is NOT a finding (avoid false positives):**
+- Public/anon/publishable keys that are designed to be exposed client-side
+  (Stripe publishable keys starting `pk_`, Supabase anon keys) — these are safe
+  by design as long as server-side authorization (RLS, API checks) is correctly
+  configured. Note this distinction explicitly in the report so the user isn't
+  confused about why one key is fine and another isn't.
+- Example/placeholder values clearly meant as documentation, e.g. `"your-api-key-here"`
+
+## Check 2: .gitignore hygiene
+
+**Run the script** `scripts/check_gitignore.py` (located relative to this `SKILL.md` file) against the project root. It checks whether `.env`, `.env.local`, and
+similar files exist in the project and whether `.gitignore` actually excludes
+them (not just whether a `.gitignore` file exists — many AI-generated `.gitignore`
+files exist but miss the actual secret file).
+
+**What counts as a finding:**
+- `.env` present in the working directory and not listed in `.gitignore` —
+  Critical, regardless of current contents
+- `.env` already committed to git history (check with a quick `git log --all
+  --full-history -- .env` if git is available) — Critical, and note in the
+  fix that removing it from `.gitignore` going forward is not enough; the
+  secrets in git history must be rotated, since they're recoverable even after
+  deletion
+
+## Check 3: Missing or fake authentication
+
+**Run the script** `scripts/check_auth_patterns.py` (located relative to this `SKILL.md` file) against the project root as a first pass. Then search auth-related code (login handlers, middleware, route guards, session
+checks) for these patterns:
+
+**What counts as a finding:**
+- A function that always returns true/success regardless of input, e.g.:
+  ```js
+  function isAuthenticated(req) {
+    return true; // TODO: implement real auth
+  }
+  ```
+  Critical — this is a placeholder someone forgot to replace.
+- Naming that signals a stub: `mockAuth`, `fakeLogin`, `tempAuth`, `bypassAuth`,
+  `skipAuth`, `devAuth` still present in a codebase with no clear dev-only guard
+  around it. If it IS properly guarded (e.g. `if (process.env.NODE_ENV ===
+  'development')`), verify the guard is airtight and note it as Should Fix
+  rather than Critical, since misconfigured environment variables in production
+  are a common way these leak through anyway.
+- A protected route or API endpoint with no auth check at all — compare route
+  definitions against which ones return or modify user-specific data.
+- Client-side-only auth checks — e.g. hiding a button in the UI if not logged in,
+  but the underlying API endpoint doesn't independently verify the session.
+  This is Critical: anyone can call the API directly, bypassing the UI entirely.
+- Auth checks present but commented out, with a bypass left active nearby.
+
+**Judgment note:** this check benefits most from your own reasoning rather than
+pure pattern matching, since real projects name things inconsistently. If
+something looks like it might be a stub but you're not certain, read the
+function body fully before deciding — don't flag based on the name alone, and
+don't clear something based on the name alone either.
+
+## Check 4: Database and backend-as-a-service misconfiguration
+
+**Run the script** `scripts/check_db_config.py` (located relative to this `SKILL.md` file) against the project root as a first pass.
+
+If the project uses **Supabase**: check for row-level security (RLS) policies on
+every table that holds user-specific data. A table with RLS disabled, or enabled
+with a policy like `USING (true)` for `SELECT`/`UPDATE`/`DELETE`, means any
+authenticated (or even anonymous) user can read or modify every row.
+```sql
+-- Finding example: this policy applies to ALL rows for ALL users
+CREATE POLICY "allow all" ON orders FOR SELECT USING (true);
+
+-- Correct pattern to recommend as the fix:
+CREATE POLICY "users see own orders" ON orders
+  FOR SELECT USING (auth.uid() = user_id);
+```
+
+If the project uses **Firebase**: check `firestore.rules` or `storage.rules` for
+default-allow states, e.g. `allow read, write: if true;` on collections holding
+user data, or rules left at the Firebase default test-mode state (which expires
+but is often copy-pasted into production-like configs).
+
+**Storage buckets**: check whether file storage (Supabase Storage, Firebase
+Storage, S3) is set to public when it holds user-uploaded content that should be
+private (profile documents, private images, receipts).
+
+## Check 5: Broken object-level authorization (IDOR)
+
+This is the single most common serious flaw in vibe-coded apps and the one most
+worth spending real time on. The pattern: an endpoint takes an ID from the
+request and fetches/modifies a resource using that ID, without checking the
+resource actually belongs to the requesting user.
+
+```js
+// Finding example — Critical
+app.get('/api/orders/:id', requireAuth, async (req, res) => {
+  const order = await db.query('SELECT * FROM orders WHERE id = $1', [req.params.id]);
+  res.json(order); // any logged-in user can read ANY order by guessing/incrementing the id
+});
+
+// Correct pattern to recommend as the fix
+app.get('/api/orders/:id', requireAuth, async (req, res) => {
+  const order = await db.query(
+    'SELECT * FROM orders WHERE id = $1 AND user_id = $2',
+    [req.params.id, req.user.id]
+  );
+  if (!order) return res.status(404).json({ error: 'Not found' });
+  res.json(order);
+});
+```
+
+Check every route that takes an ID as a URL param, query string, or body field
+and touches a database record. This applies to GET (data exposure), PUT/PATCH
+(unauthorized modification), and DELETE (unauthorized deletion) — all three are
+common and DELETE is often the most damaging.
+
+## Check 6: Unvalidated inputs
+
+Spot-check forms and API endpoints for:
+- No type or length validation on inputs before they're stored or used
+- User input passed into a database query via string concatenation rather than
+  parameterized queries/an ORM (SQL injection risk)
+- User input rendered into HTML without escaping (XSS risk), especially in
+  frameworks that don't auto-escape by default
+- File uploads with no restriction on file type or size
+
+This check doesn't need to be exhaustive — flag the clearest, highest-impact
+examples rather than every single form field, and note in the summary that a
+full input-validation review is a good idea if the codebase is large.
+
+## Check 7: Client-side payment or pricing logic
+
+Search checkout/payment flows for the price, discount, or total being read from
+data the client controls (a hidden form field, a request body value, a query
+param) rather than looked up server-side from a trusted source.
+
+```js
+// Finding example — Critical
+app.post('/api/checkout', async (req, res) => {
+  const { productId, price } = req.body; // price is trusted from the client!
+  await chargeCard(req.user.paymentMethod, price);
+});
+
+// Correct pattern to recommend as the fix
+app.post('/api/checkout', async (req, res) => {
+  const { productId } = req.body;
+  const product = await db.query('SELECT price FROM products WHERE id = $1', [productId]);
+  await chargeCard(req.user.paymentMethod, product.price); // price comes from the server
+});
+```
+
+---
+
+## Severity rubric
+
+- **Critical** — exploitable right now by any user or visitor, exposes real user
+  data, or allows bypassing authentication or payment. Ship-blocking.
+- **Should Fix** — a genuine weakness that requires more specific conditions to
+  exploit (e.g. requires knowing another user's exact ID, or only affects an
+  admin-only route with a smaller blast radius), or a control that exists but is
+  incomplete/inconsistent.
+- **Worth Reviewing** — best-practice gap with low immediate exploitability
+  given the current app, but worth fixing before the app scales or handles more
+  sensitive data.
+
+When in doubt between two levels, consider: could a stranger with no special
+access do real harm to a real user right now? If yes, Critical.
+
+## Report format
+
+For every finding, use exactly this structure:
+
+- Include a short `Confidence:` line when the evidence is not fully conclusive.
+- Include a `Generated fix:` line when a direct code snippet or precise implementation step would help the agent patch the issue immediately.
+
+**[SEVERITY] Short title**
+- **What's wrong:** plain-English description, no jargon. If a technical term is
+  unavoidable (e.g. "IDOR"), define it in one clause the first time it's used.
+- **Why it matters:** a concrete, real-world consequence a non-technical person
+  would understand — not "this violates the principle of least privilege" but
+  "a stranger could see another user's home address and order history just by
+  changing a number in the browser's address bar."
+- **The fix:** a specific code snippet or precise instruction, not a vague
+  suggestion like "add proper validation."
+- **File(s):** exact path and line number(s).
+
+
+## After the checks
+
+Once the checks are complete, create a security audit/report. **The report must be written in clear, plain English, completely free of dense security jargon, so that it is easily understandable by non-technical stakeholders (such as founders, clients, or project managers).** The report must include:
+- what was found
+- what is fixed already
+- how each fix was applied
+- what still needs attention
+- the final readiness verdict
+
+If no issues are found, still produce a short report that says no blocking issues were found in this pass, which categories were checked, and what the remaining scope limits are.
+
+
+## Example report style
+
+Use clear, direct wording like:
+
+**[Critical] Missing object-level authorization**
+- **What's wrong:** Any logged-in user can read another user's order by changing the order ID.
+- **Why it matters:** A stranger could see someone else's orders and personal details.
+- **The fix:** Add a user ownership check in the query and return 404 when the record does not belong to the current user.
+- **File(s):** `src/routes/orders.ts:42-58`
+
+## Final summary
+
+End every audit with, in this order:
+1. Stack and data-sensitivity context noted at the start (one line)
+2. Total findings by severity, e.g. "2 Critical, 3 Should Fix, 1 Worth Reviewing"
+3. A one-line verdict: "Not ready to ship — fix the Critical items first" or "No
+   blocking issues found in this pass — review the Should Fix items when you can"
+4. The scope reminder: "This covers common patterns seen in AI-generated code —
+   exposed secrets, auth stubs, database misconfiguration, IDOR, input validation,
+   and client-side payment logic. It is not a full penetration test. If this app
+   handles payment, health, or other regulated data, get a professional security
+   review before launch regardless of these results."
+
+## Notes for the agent
+
+- Always produce an audit/report after the scan; do not stop at raw findings.
+- Write the entire report in clear, accessible language. Frame findings around concrete, real-world user consequences rather than abstract technical concepts. A non-technical stakeholder must be able to read the report and immediately understand the real-world danger.
+- The audit should clearly separate what was found, what was fixed, how it was fixed, and what remains.
+- Always run the available scripts (located in the `scripts/` directory relative to this `SKILL.md` file) before relying on reasoning alone for Checks 1-4 — they exist so those specific checks are reliable and repeatable rather than dependent on re-deriving the logic every time.
+- If a script is missing, fails to run, or the language/stack isn't supported by
+  it, say so explicitly in the report ("automated secret scan could not run;
+  manually reviewed instead") rather than silently skipping the check.
+- Do not invent findings to seem thorough. If a check finds nothing, report "No
+  issues found" for that category explicitly — silence looks like the check
+  wasn't performed at all.
+- Do not flag the same underlying issue multiple times under different check
+  categories — pick the most relevant category and reference it once.
+- If the codebase is large, prioritize routes and files that touch
+  authentication, payments, and any endpoint returning data tied to a specific
+  user ID — these are where real damage concentrates.

package/install.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Source paths in the npm package
+const srcSkill = path.join(__dirname, 'SKILL.md');
+const srcScripts = path.join(__dirname, 'scripts');
+const srcReferences = path.join(__dirname, 'references');
+
+// Destination selection
+const cwd = process.cwd();
+const hasLocalClaude = fs.existsSync(path.join(cwd, '.claude'));
+
+const localDest = path.join(cwd, '.claude', 'skills', 'checkmyvibe');
+const globalDest = path.join(os.homedir(), '.claude', 'skills', 'checkmyvibe');
+
+function copyRecursiveSync(src, dest) {
+  if (fs.statSync(src).isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    fs.readdirSync(src).forEach((child) => {
+      copyRecursiveSync(path.join(src, child), path.join(dest, child));
+    });
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function performInstall(destPath) {
+  try {
+    console.log(`\nInstalling checkmyvibe to: ${destPath}...`);
+    
+    // Clear destination if it already exists (overwrite mode)
+    if (fs.existsSync(destPath)) {
+      if (fs.rmSync) {
+        fs.rmSync(destPath, { recursive: true, force: true });
+      } else {
+        fs.rmdirSync(destPath, { recursive: true });
+      }
+    }
+    fs.mkdirSync(destPath, { recursive: true });
+
+    // Copy SKILL.md
+    fs.copyFileSync(srcSkill, path.join(destPath, 'SKILL.md'));
+    
+    // Copy folders
+    copyRecursiveSync(srcScripts, path.join(destPath, 'scripts'));
+    copyRecursiveSync(srcReferences, path.join(destPath, 'references'));
+
+    console.log('\n=========================================');
+    console.log('🎉 checkmyvibe Agent Skill installed!');
+    console.log('=========================================');
+    console.log('\nHow to run a security audit:');
+    console.log('1. Open your terminal in the target repository.');
+    console.log('2. Ask your coding agent: "run a security audit"');
+    console.log('3. The agent will execute checkmyvibe\'s checks and output a prioritized report!');
+    console.log('=========================================\n');
+  } catch (err) {
+    console.error('Error installing skill:', err.message);
+    process.exit(1);
+  }
+}
+
+if (hasLocalClaude) {
+  // If .claude folder exists in the project root, install at project level directly
+  performInstall(localDest);
+} else {
+  // Prompt user for local vs global/personal installation
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log('No local .claude/ directory detected in the current working directory.');
+  console.log(`1. Install locally to current directory: ${path.join('.claude', 'skills', 'checkmyvibe')}`);
+  console.log(`2. Install globally/personally: ${globalDest.replace(os.homedir(), '~')}`);
+  
+  rl.question('\nSelect installation destination (1 or 2, default 2): ', (answer) => {
+    rl.close();
+    const selection = answer.trim();
+    if (selection === '1') {
+      performInstall(localDest);
+    } else {
+      performInstall(globalDest);
+    }
+  });
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "checkmyvibe",
+  "version": "1.0.0",
+  "description": "A structured security-audit workflow Agent Skill for AI coding assistants to catch common vibe-coded vulnerabilities.",
+  "main": "install.js",
+  "bin": {
+    "checkmyvibe": "install.js"
+  },
+  "files": [
+    "SKILL.md",
+    "scripts/",
+    "references/",
+    "install.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "ai-agent",
+    "security-audit",
+    "claude-code",
+    "cursor",
+    "vibe-coding",
+    "agent-skill"
+  ],
+  "author": "Sarthak",
+  "license": "Apache-2.0"
+}

package/references/vibe_vulnerability_patterns.md

@@ -0,0 +1,81 @@
+# Vibe Vulnerability Patterns
+
+This document serves as a reference for common vulnerability patterns identified in AI-generated ("vibe-coded") applications. AI coding assistants frequently introduce these security flaws because they prioritize speed, feature completion, and standalone component demonstration over robust security configurations.
+
+---
+
+## 1. Exposed Secrets
+
+### Overview
+AI assistants often scaffold code with hardcoded API keys, JWT secrets, database connection strings, or third-party client keys directly inside configuration files or source code. Additionally, local environment files (`.env`) are frequently created without updating the project's `.gitignore` to prevent them from being committed to version control.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+
+---
+
+## 2. Missing/Fake Authentication (Fake/Stubbed Auth)
+
+### Overview
+When generating authentication flows, AI tools often implement mock authentication functions, fake login buttons, or bypass logic (e.g. returning `true` or dummy user objects unconditionally) to make testing quick. Developers may unknowingly deploy this placeholder logic directly to production, leaving endpoints unprotected.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+
+---
+
+## 3. Database Misconfiguration (Permissive Database Rules / RLS)
+
+### Overview
+Services like Supabase or Firebase Firestore rely on Row-Level Security (RLS) or security rules files to protect data access. AI assistants frequently scaffold projects with default allow-all rules (e.g. `allow read, write: if true;` or `CREATE POLICY ... TO public USING (true);`) or create tables in Supabase without enabling RLS, enabling any client with an anonymous key to query or modify all records.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+
+---
+
+## 4. Broken Object-Level Authorization (BOLA / IDOR)
+
+### Overview
+Broken Object-Level Authorization occurs when an application exposes a resource endpoint (e.g. `/api/orders/:id` or fetching data by a user-supplied ID parameter) and retrieves or updates the resource without verifying that the authenticated user owns or has permission to access that specific resource.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+
+---
+
+## 5. Unvalidated Inputs
+
+### Overview
+AI code often lacks backend input validation, trusting that client-side forms are sufficient. This opens the door to SQL injection, Cross-Site Scripting (XSS), server-side crashes due to unexpected data formats, or logic bypasses.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]
+
+---
+
+## 6. Client-Side Payment Logic
+
+### Overview
+AI tools often write payment flows where pricing calculations, transaction amounts, subscription statuses, or checkout processes are determined or validated entirely on the client side. Attackers can easily intercept and modify request bodies (e.g. setting a premium product price to `$0.00`) before sending it to a payment gateway API.
+
+### Why it happens in AI-generated code
+[Placeholder: The user will fill in real-world examples and analysis of why this happens in AI-generated code.]
+
+### The Correct Fix
+[Placeholder: The user will fill in the correct fix and mitigation strategies.]

package/scripts/check_auth_patterns.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+import os
+import sys
+import re
+
+SKIP_DIRS = {
+    'node_modules', '.git', 'build', 'dist', '.next', '.svelte-kit', 
+    '__pycache__', 'venv', '.venv', 'env', 'coverage', 'out'
+}
+
+SKIP_EXTS = {
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', 
+    '.gz', '.mp3', '.mp4', '.mov', '.db', '.sqlite', '.exe', '.dll',
+    '.so', '.dylib', '.woff', '.woff2', '.ttf', '.eot', '.lock',
+    '.package-lock.json', '.pnpm-lock.yaml', '.yarn.lock', '.map',
+    '.svg', '.css', '.scss', '.less', '.html', '.xml'
+}
+
+# 1. Naming patterns for fake/mock/bypass authentication
+AUTH_KEYWORDS = [
+    r'mockAuth', r'fakeLogin', r'tempAuth', r'bypassAuth', 
+    r'mockLogin', r'fakeAuth', r'bypassLogin', r'dummyAuth',
+    r'bypassUser', r'mockUser', r'fakeUser'
+]
+KEYWORD_REGEX = re.compile(r'(?i)\b(' + '|'.join(AUTH_KEYWORDS) + r')\b')
+
+# 2. Stubbed functions or parameters returning true (always passing)
+STUB_PATTERNS = [
+    # JS arrow function returning true: e.g. checkAuth = () => true
+    (re.compile(r'(?i)\b\w*(?:auth|login|signin|signup|admin|role|permission|credential)\w*\b\s*=\s*(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>\s*true\b(?!\s*==)'), 
+     "Arrow function returning true directly"),
+    
+    # JS standard function returning true: function checkAuth(...) { return true; }
+    (re.compile(r'(?i)\bfunction\s+\w*(?:auth|login|signin|signup|admin|role|permission|credential)\w*\b\s*\([^)]*\)\s*\{\s*return\s+true;?\s*\}'),
+     "Function returning true directly"),
+     
+    # Python function returning True: def is_auth(...): return True
+    (re.compile(r'(?i)\bdef\s+\w*(?:auth|login|signin|signup|admin|role|permission|credential)\w*\b\s*\([^)]*\)\s*:\s*return\s+True\b'),
+     "Python function returning True directly"),
+     
+    # Generic bypass function or property: e.g. "authBypass: true", "skipAuth: true"
+    (re.compile(r'(?i)\b(?:authBypass|skipAuth|disableAuth|bypassAuthentication|devAuth)\b\s*:\s*true\b'),
+     "Authentication bypass flag set to true")
+]
+
+def is_binary(file_path):
+    try:
+        with open(file_path, 'rb') as f:
+            chunk = f.read(1024)
+            return b'\x00' in chunk
+    except Exception:
+        return True
+
+def scan_file(file_path):
+    findings = []
+    if is_binary(file_path):
+        return findings
+
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+            
+        lines = content.splitlines()
+        
+        # 1. Search for keyword matches line by line
+        for line_num, line in enumerate(lines, 1):
+            match = KEYWORD_REGEX.search(line)
+            if match:
+                findings.append((line_num, f"Mock/Bypass auth keyword '{match.group(1)}' found", line.strip()))
+                
+        # 2. Search for stub patterns in the file content
+        for pattern, desc in STUB_PATTERNS:
+            for match in pattern.finditer(content):
+                start_pos = match.start()
+                # Find line number of this match
+                line_num = content.count('\n', 0, start_pos) + 1
+                matched_text = match.group(0).replace('\n', ' ').strip()
+                # Avoid adding multiple duplicate findings for the same line
+                if not any(f[0] == line_num for f in findings):
+                    findings.append((line_num, f"Stubbed Auth: {desc}", matched_text))
+                    
+    except Exception:
+        pass
+        
+    findings.sort(key=lambda x: x[0])
+    return findings
+
+def main():
+    target_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
+    target_dir = os.path.abspath(target_dir)
+    
+    if not os.path.exists(target_dir):
+        print(f"Error: Path '{target_dir}' does not exist.")
+        sys.exit(1)
+        
+    for root, dirs, files in os.walk(target_dir):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
+        
+        for file in files:
+            ext = os.path.splitext(file)[1].lower()
+            if ext in SKIP_EXTS or file.startswith('.'):
+                continue
+                
+            file_path = os.path.join(root, file)
+            rel_path = os.path.relpath(file_path, target_dir)
+            
+            findings = scan_file(file_path)
+            for line_num, desc, context in findings:
+                print(f"{rel_path}:{line_num}: {desc} -> `{context}`")
+
+if __name__ == '__main__':
+    main()

package/scripts/check_db_config.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+import os
+import sys
+import re
+
+SKIP_DIRS = {'node_modules', '.git', 'dist', 'build'}
+
+# Permissive rules patterns for Firestore and Firebase Storage
+FIREBASE_PERMISSIVE = re.compile(r'allow\s+[\w\s,]+:\s*if\s+true\s*;')
+
+# Permissive Realtime Database rules
+RTDB_PERMISSIVE = re.compile(r'"\.(read|write)"\s*:\s*"true"')
+
+# Permissive policies in Supabase / SQL schema definition
+SUPABASE_PERMISSIVE_POLICY = re.compile(r'(?i)create\s+policy\s+\w+\s+on\s+\w+\s+(?:for\s+\w+\s+)?to\s+(?:public|anon)\s+using\s*\(\s*true\s*\)')
+SUPABASE_PERMISSIVE_POLICY_SIMPLE = re.compile(r'(?i)using\s*\(\s*true\s*\)|with\s+check\s*\(\s*true\s*\)')
+
+def scan_firebase_rules(file_path):
+    """Scan Firestore/Storage rules for allow-all statements."""
+    findings = []
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line_num, line in enumerate(f, 1):
+                clean_line = line.strip()
+                if FIREBASE_PERMISSIVE.search(clean_line):
+                    findings.append((line_num, f"Permissive allow-all rule found: `{clean_line}`"))
+    except Exception:
+        pass
+    return findings
+
+def scan_rtdb_rules(file_path):
+    """Scan Firebase Realtime Database rules for true reads/writes."""
+    findings = []
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line_num, line in enumerate(f, 1):
+                clean_line = line.strip()
+                if RTDB_PERMISSIVE.search(clean_line):
+                    findings.append((line_num, f"Permissive RTDB allow-all rule found: `{clean_line}`"))
+    except Exception:
+        pass
+    return findings
+
+def scan_sql_rls(file_path):
+    """Scan SQL files to check if RLS is enabled on all tables and check for permissive policies."""
+    findings = []
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+            
+        # 1. Strip comments to avoid false matches (e.g. commented-out commands or code annotations)
+        # Strip single-line -- comments
+        content_no_comments = re.sub(r'--.*$', '', content, flags=re.M)
+        # Strip multiline /* */ comments
+        content_no_comments = re.sub(r'/\*.*?\*/', '', content_no_comments, flags=re.S)
+
+        # 2. Find all CREATE TABLE statements (support schemas, quotes, etc.)
+        created_tables = re.findall(r'(?i)create\s+table\s+(?:if\s+not\s+exists\s+)?([\w\.]+)', content_no_comments)
+        # Find all ENABLE ROW LEVEL SECURITY statements
+        enabled_rls = re.findall(r'(?i)alter\s+table\s+(?:if\s+exists\s+)?([\w\.]+)\s+enable\s+row\s+level\s+security', content_no_comments)
+        
+        # Clean table names (strip quotes, normalize schemas)
+        def clean_table_name(t):
+            t = t.replace('"', '').replace("'", "")
+            if '.' in t:
+                t = t.split('.')[-1]
+            return t.lower()
+            
+        created_clean = [clean_table_name(t) for t in created_tables]
+        enabled_clean = [clean_table_name(t) for t in enabled_rls]
+        
+        for idx, table in enumerate(created_tables):
+            clean_t = clean_table_name(table)
+            if clean_t not in enabled_clean:
+                # Find line number in original file
+                escaped_t = re.escape(table)
+                match = re.search(r'(?i)create\s+table\s+(?:if\s+not\s+exists\s+)?' + escaped_t, content)
+                line_num = content.count('\n', 0, match.start()) + 1 if match else 1
+                findings.append((line_num, f"Table '{table}' is created but Row Level Security (RLS) is not enabled"))
+                
+        # 3. Find permissive policies:
+        # Search for CREATE POLICY ... USING (true) or WITH CHECK (true)
+        # Handles multiline policy definitions and quoted policy names
+        policy_pattern = re.compile(
+            r'(?i)create\s+policy\s+("[^"]+"|[a-zA-Z_]\w*)\s+on\s+([\w\.]+)\s+[^;]+?(?:using|with\s+check)\s*\(\s*true\s*\)',
+            re.DOTALL
+        )
+        
+        for match in policy_pattern.finditer(content_no_comments):
+            policy_name = match.group(1)
+            table_name = match.group(2)
+            # Find the character position of this policy match in the original content
+            orig_match = re.search(r'(?i)create\s+policy\s+' + re.escape(policy_name), content)
+            line_num = content.count('\n', 0, orig_match.start()) + 1 if orig_match else 1
+            findings.append((line_num, f"Permissive policy {policy_name} on table {table_name} allows public read/write via USING(true) / CHECK(true)"))
+            
+    except Exception:
+        pass
+    return findings
+
+def main():
+    target_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
+    target_dir = os.path.abspath(target_dir)
+    
+    findings_by_file = {}
+    
+    for root, dirs, files in os.walk(target_dir):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
+        
+        for file in files:
+            file_path = os.path.join(root, file)
+            rel_path = os.path.relpath(file_path, target_dir)
+            
+            # Check for Firebase Firestore/Storage rules
+            if file in ['firestore.rules', 'storage.rules']:
+                file_findings = scan_firebase_rules(file_path)
+                if file_findings:
+                    findings_by_file[rel_path] = file_findings
+                    
+            # Check for Firebase Realtime Database rules
+            elif file == 'database.rules.json':
+                file_findings = scan_rtdb_rules(file_path)
+                if file_findings:
+                    findings_by_file[rel_path] = file_findings
+                    
+            # Check for SQL migrations/schema files
+            elif file.endswith('.sql'):
+                file_findings = scan_sql_rls(file_path)
+                if file_findings:
+                    findings_by_file[rel_path] = file_findings
+                    
+    # Output findings
+    if not findings_by_file:
+        print("PASS: No database security misconfigurations detected in configuration files.")
+        sys.exit(0)
+        
+    print("FAIL: The following database security issues were found:")
+    for rel_path, file_findings in findings_by_file.items():
+        for line_num, desc in file_findings:
+            print(f"{rel_path}:{line_num}: {desc}")
+    sys.exit(1)
+
+if __name__ == '__main__':
+    main()

package/scripts/check_gitignore.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+import os
+import sys
+import fnmatch
+
+# Potential local secret file patterns (glob format)
+SECRET_PATTERNS = [
+    '.env',
+    '.env.*',
+    '*service-account*.json',
+    '*serviceAccount*.json',
+    '*credentials*.json',
+    '*.pem',
+    '*.key',
+    '*.p12',
+    'secrets.json',
+    'jwt_key*',
+]
+
+# Patterns that are allowed to be public (not secrets)
+PUBLIC_EXCEPTIONS = [
+    '*.example',
+    '*.template',
+    '*.sample',
+    '*.dist',
+    '*.config.json',
+    'firebase.json',
+]
+
+def is_secret_file(filename):
+    """Check if filename matches secret patterns and doesn't match public exceptions."""
+    is_secret = False
+    for pat in SECRET_PATTERNS:
+        if fnmatch.fnmatch(filename, pat):
+            is_secret = True
+            break
+            
+    if not is_secret:
+        return False
+        
+    for pat in PUBLIC_EXCEPTIONS:
+        if fnmatch.fnmatch(filename, pat):
+            return False
+            
+    return True
+
+def parse_gitignore(gitignore_path):
+    """Read and parse the .gitignore patterns, skipping comments and empty lines."""
+    patterns = []
+    if not os.path.exists(gitignore_path):
+        return patterns
+        
+    with open(gitignore_path, 'r', encoding='utf-8', errors='ignore') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            # Strip inline comments
+            if ' #' in line:
+                line = line.split(' #')[0].strip()
+            patterns.append(line)
+    return patterns
+
+def is_ignored(file_rel_path, gitignore_patterns):
+    """Verify if a relative file path matches any .gitignore pattern."""
+    ignored = False
+    parts = file_rel_path.split(os.sep)
+    
+    # Hardcoded check for system folders that are assumed ignored
+    if 'node_modules' in parts or '.git' in parts or 'dist' in parts or 'build' in parts:
+        return True
+
+    for pattern in gitignore_patterns:
+        negate = False
+        if pattern.startswith('!'):
+            negate = True
+            pattern = pattern[1:]
+            
+        match = False
+        if pattern.startswith('/'):
+            clean_pattern = pattern[1:]
+            match = fnmatch.fnmatch(file_rel_path, clean_pattern) or fnmatch.fnmatch(file_rel_path, clean_pattern + '/*')
+        else:
+            match = fnmatch.fnmatch(os.path.basename(file_rel_path), pattern) or \
+                    fnmatch.fnmatch(file_rel_path, pattern) or \
+                    fnmatch.fnmatch(file_rel_path, '*/' + pattern) or \
+                    any(fnmatch.fnmatch(part, pattern) for part in parts)
+                    
+        if match:
+            ignored = not negate
+            
+    return ignored
+
+def main():
+    target_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
+    target_dir = os.path.abspath(target_dir)
+    
+    gitignore_path = os.path.join(target_dir, '.gitignore')
+    has_gitignore = os.path.exists(gitignore_path)
+    
+    gitignore_patterns = parse_gitignore(gitignore_path) if has_gitignore else []
+    
+    secret_files_found = []
+    unignored_secrets = []
+    
+    for root, dirs, files in os.walk(target_dir):
+        # Exclude directories
+        dirs[:] = [d for d in dirs if d not in {'node_modules', '.git', 'dist', 'build', '.next', '.svelte-kit'}]
+        
+        for file in files:
+            if is_secret_file(file):
+                file_path = os.path.join(root, file)
+                rel_path = os.path.relpath(file_path, target_dir)
+                
+                if is_ignored(rel_path, gitignore_patterns):
+                    secret_files_found.append((rel_path, True))
+                else:
+                    secret_files_found.append((rel_path, False))
+                    unignored_secrets.append(rel_path)
+                    
+    if not secret_files_found:
+        print("PASS: No local secret files (like .env) were detected in the project.")
+        sys.exit(0)
+        
+    if unignored_secrets:
+        print("FAIL: The following local secret files are NOT excluded by .gitignore:")
+        for sf in unignored_secrets:
+            print(f"  - {sf}")
+        if not has_gitignore:
+            print("  (Note: No .gitignore file was found in the project root)")
+        sys.exit(1)
+    else:
+        print("PASS: All detected local secret files are correctly listed in .gitignore:")
+        for sf, ignored in secret_files_found:
+            print(f"  - {sf} (ignored)")
+        sys.exit(0)
+
+if __name__ == '__main__':
+    main()

package/scripts/scan_secrets.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+import os
+import sys
+import re
+import math
+
+# Directories to skip during scanning
+SKIP_DIRS = {
+    'node_modules', '.git', 'build', 'dist', '.next', '.svelte-kit', 
+    '__pycache__', 'venv', '.venv', 'env', 'coverage', 'out', '.expo',
+    '.output', '.nuxt'
+}
+
+# File extensions to skip (binary/media/lockfiles/assets)
+SKIP_EXTS = {
+    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip', '.tar', 
+    '.gz', '.mp3', '.mp4', '.mov', '.db', '.sqlite', '.exe', '.dll',
+    '.so', '.dylib', '.woff', '.woff2', '.ttf', '.eot', '.lock',
+    '.package-lock.json', '.pnpm-lock.yaml', '.yarn.lock', '.map',
+    '.svg', '.css', '.scss', '.less', '.html', '.xml'
+}
+
+# Regexes for known API key formats
+API_KEY_PATTERNS = [
+    (re.compile(r'AIza[0-9A-Za-z-_]{35}'), 'Google API Key'),
+    (re.compile(r'AKIA[0-9A-Z]{16}'), 'AWS Access Key ID'),
+    (re.compile(r'ghp_[a-zA-Z0-9]{36,40}'), 'GitHub Personal Access Token'),
+    (re.compile(r'sk_(live|test)_[0-9a-zA-Z]{24,96}'), 'Stripe Secret Key'),
+    (re.compile(r'xox[bapr]-[0-9]{12}-[0-9]{12}-[0-9]{12}-[a-z0-9]{32}'), 'Slack Token'),
+]
+
+# Regex for variable assignments with potential hardcoded secrets
+# Matches: name = "string" or "name": "string", where name contains key, secret, token, password, credential, auth
+ASSIGNMENT_PATTERN = re.compile(
+    r'(?i)(?:[\'"`]?)\b(\w*(?:key|secret|token|password|credential|auth)\w*)\b(?:[\'"`]?)\s*(?:=|:)\s*([\'"`])([^\'"`\n\r]{8,256})\2'
+)
+
+# Regex for standalone high-entropy candidate words (length 32 to 128)
+HIGH_ENTROPY_WORD_PATTERN = re.compile(r'\b([a-zA-Z0-9+/=_-]{32,128})\b')
+
+def calculate_entropy(s):
+    """Calculate the Shannon entropy of a string."""
+    if not s:
+        return 0
+    entropy = 0
+    for x in set(s):
+        p_x = s.count(x) / len(s)
+        entropy -= p_x * math.log2(p_x)
+    return entropy
+
+def is_binary(file_path):
+    """Check if a file is binary by looking for null bytes."""
+    try:
+        with open(file_path, 'rb') as f:
+            chunk = f.read(1024)
+            return b'\x00' in chunk
+    except Exception:
+        return True
+
+def scan_file(file_path):
+    findings = []
+    if is_binary(file_path):
+        return findings
+
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line_num, line in enumerate(f, 1):
+                # 1. Check known API key patterns
+                for pattern, name in API_KEY_PATTERNS:
+                    if pattern.search(line):
+                        findings.append((line_num, f"Exposed {name}"))
+                        
+                # 2. Check variable assignments
+                for match in ASSIGNMENT_PATTERN.finditer(line):
+                    var_name, quote, val = match.groups()
+                    
+                    # Ignore environment variable references, string interpolation, or placeholders
+                    if any(x in val for x in ['process.env', 'os.environ', 'os.getenv', 'ENV[', '${', '{{', '}}']):
+                        continue
+                    
+                    # Ignore common placeholder value patterns
+                    val_lower = val.lower()
+                    placeholders = {
+                        'true', 'false', 'null', 'undefined', 'placeholder', 'dummy', 
+                        'your_key_here', 'your-key-here', 'your_secret_here', 'your-secret-here',
+                        'test', 'mock', 'none', 'value', 'secret', 'password', 'key', 'token'
+                    }
+                    if val_lower in placeholders or all(c in '-_*' for c in val):
+                        continue
+                    
+                    entropy = calculate_entropy(val)
+                    if len(val) >= 12 and entropy > 3.0:
+                        findings.append((line_num, f"Potential secret assigned to '{var_name}' (entropy: {entropy:.2f})"))
+                    elif len(val) >= 16:
+                        findings.append((line_num, f"Suspicious long literal assigned to '{var_name}'"))
+
+                # 3. Check for standalone high-entropy words (only if not already matched above)
+                # Keep threshold high to reduce noise from base64 assets/hashes
+                for match in HIGH_ENTROPY_WORD_PATTERN.finditer(line):
+                    word = match.group(1)
+                    # Skip if it is part of a URL, or has common non-secret structures
+                    if any(x in line for x in ['http://', 'https://', 'src=', 'href=', 'url(']):
+                        continue
+                    
+                    # Skip common long words/hashes that are not secrets (e.g. standard CSS classes, hex colors)
+                    if re.match(r'^[0-9a-fA-F]+$', word) and len(word) < 40:
+                        # Small hex hashes are common (commit IDs, etc.) - require higher length or entropy
+                        continue
+                        
+                    entropy = calculate_entropy(word)
+                    # True high entropy strings (like keys) typically have entropy > 4.2 for 32+ char length
+                    if len(word) >= 32 and entropy > 4.3:
+                        # Make sure it's not already reported in assignments
+                        if not any(word in f[1] for f in findings):
+                            findings.append((line_num, f"Standalone high-entropy string found (entropy: {entropy:.2f})"))
+                            
+    except Exception:
+        pass
+        
+    return findings
+
+def main():
+    target_dir = sys.argv[1] if len(sys.argv) > 1 else '.'
+    target_dir = os.path.abspath(target_dir)
+    
+    if not os.path.exists(target_dir):
+        print(f"Error: Path '{target_dir}' does not exist.")
+        sys.exit(1)
+        
+    for root, dirs, files in os.walk(target_dir):
+        # Exclude directories in-place
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith('.')]
+        
+        for file in files:
+            ext = os.path.splitext(file)[1].lower()
+            # Skip hidden files unless they are .env configuration files
+            if ext in SKIP_EXTS or (file.startswith('.') and not file.startswith('.env')):
+                continue
+                
+            file_path = os.path.join(root, file)
+            rel_path = os.path.relpath(file_path, target_dir)
+            
+            findings = scan_file(file_path)
+            for line_num, desc in findings:
+                print(f"{rel_path}:{line_num}: {desc}")
+
+if __name__ == '__main__':
+    main()