codeninja 2.0.0 → 3.2.0

package/ide/antigravity/.agents/workflows/codeninja-modularize.md

@@ -0,0 +1,216 @@
+---
+slash_command: /codeninja:modularize
+personas: [global-orchestrator, reactjs-frontend]
+skills: [mcp-and-context, reactjs, code-intelligence]
+description: >
+  Scan ReactJS pages, extract repeated layout blocks into reusable components
+  under src/components/, and update each page to import and use them.
+  Layout structure only — never touches business logic, state, or API calls.
+---
+
+# /codeninja:modularize
+
+## Before Running
+1. Call `context_check_stale`
+2. Call `context_read` — load `context.services` to find ReactJS services
+3. Call `service_scan` — verify ReactJS service exists on disk
+
+## Rules
+- Read ALL target pages fully before creating any component
+- NEVER create a component that already exists in `src/components/` — reuse it
+- NEVER modify business logic, state, API calls, or event handlers in any page
+- NEVER break existing imports or prop flows
+- ONE confirmation before any file is written
+- After writing files → call `context_write`
+
+---
+
+## Execution — Full Step-by-Step
+
+### Phase 1 — Target Selection
+
+**Step 1.** Ask: "Which ReactJS service?" (list ReactJS services from `context.services`)
+- Store: `context.current_action.service_name`
+
+**Step 2.** Ask: "What scope?"
+1. All pages — scan every page in `src/pages/` and `src/views/`
+2. Specific page — I'll provide the path
+- Store: `context.current_action.modularize_scope`
+- If specific → also ask: "Page path?" → Store: `context.current_action.page_path`
+
+---
+
+### Phase 2 — Inventory Existing Components
+
+Before scanning any pages, inventory what already exists:
+
+**Step 1.** Scan `src/components/` in the target service.
+For each subdirectory → record component name and file path.
+
+**Step 2.** For each existing component:
+- Read the file
+- Identify structural role: header, footer, sidebar, navbar, modal wrapper, card shell, breadcrumbs, etc.
+- Record: `{ name, path, role, props_accepted }`
+
+Store this as the "existing components registry" — the source of truth for reuse decisions.
+
+---
+
+### Phase 3 — Scan Target Pages
+
+#### If scope == "all":
+Scan `src/pages/` — each subdirectory with `index.jsx` or `index.js` = one page.
+Also scan `src/views/` if it exists.
+
+#### If scope == "specific":
+Pages list = [ context.current_action.page_path ]
+
+For each page:
+
+**Step 1.** Read the full file content.
+
+**Step 2.** Identify all structural blocks (layout HTML — NOT business logic):
+- Look for repeated layout patterns: `<header>`, `<nav>`, `<footer>`, `<aside>`, sidebar wrappers
+- Look for structural patterns repeated across pages: top nav bars, breadcrumb areas, page wrappers
+- Record each structural block as: `{ block_type, jsx_content, props_needed }`
+
+**Step 3.** Cross-check against existing components registry:
+- Does a component already exist that covers this block?
+- If YES → mark as "reuse existing: <ComponentName>"
+- If NO → mark as "new component needed: <ComponentName>"
+
+---
+
+### Phase 4 — Deduplicate Across Pages
+
+After scanning all pages:
+
+**Step 1.** Group blocks by structural similarity across pages.
+- If the same header JSX appears in 3+ pages → one shared Header component
+- If a sidebar appears in 2+ pages → one shared Sidebar component
+- If a block appears in only 1 page → do NOT extract it (no duplication benefit)
+
+**Step 2.** For each component to create, decide:
+- Component name (PascalCase, descriptive: `PageHeader`, `AppSidebar`, `MainFooter`)
+- Props needed (what varies between pages: title, navLinks, userName, etc.)
+- File location: `src/components/<ComponentName>/index.jsx` and `<ComponentName>.module.css`
+
+---
+
+### Phase 5 — Show Extraction Plan
+
+Display the plan before writing anything:
+
+```
+┌─────────────────────────────────────────────────────┐
+│           MODULARIZE PLAN                           │
+├─────────────────────────────────────────────────────┤
+│ Service  : [service_name]                           │
+│ Scope    : [all pages | specific page]              │
+│ Pages    : [n] scanned                              │
+├─────────────────────────────────────────────────────┤
+│ COMPONENTS TO CREATE                                │
+│  ✦ AppHeader — appears in [n] pages                 │
+│    Props: title (string)                            │
+│    File:  src/components/AppHeader/index.jsx        │
+│                                                     │
+│  ✦ MainSidebar — appears in [n] pages               │
+│    Props: activeRoute (string)                      │
+│    File:  src/components/MainSidebar/index.jsx      │
+├─────────────────────────────────────────────────────┤
+│ COMPONENTS REUSED (already exist)                   │
+│  ✓ Footer — src/components/Footer/index.jsx         │
+├─────────────────────────────────────────────────────┤
+│ PAGES TO UPDATE                                     │
+│  → src/pages/Dashboard/index.jsx                   │
+│  → src/pages/Profile/index.jsx                     │
+│  → src/pages/Settings/index.jsx                    │
+└─────────────────────────────────────────────────────┘
+```
+
+Ask: "Apply this plan? (yes / no / adjust)"
+- If yes → proceed to Phase 6
+- If no → abort, nothing written
+- If adjust → ask what to change → re-display plan
+
+---
+
+### Phase 6 — Generate Components
+
+For each new component:
+
+**Step 1.** Generate `src/components/<ComponentName>/index.jsx`:
+```jsx
+/**
+ * <ComponentName> — <one-line description of structural role>.
+ *
+ * @param {Object} props
+ * @param {string} props.<propName> - <description>
+ * @returns {JSX.Element}
+ */
+function <ComponentName>({ <props> }) {
+  return (
+    <extracted JSX block, using props where values varied>
+  );
+}
+
+export default <ComponentName>;
+```
+
+**Step 2.** Generate `src/components/<ComponentName>/<ComponentName>.module.css`:
+- Extract any inline styles or className references that were in the original block
+- Create CSS classes for them
+- If no styles → empty file with a comment: `/* <ComponentName> styles */`
+
+---
+
+### Phase 7 — Update Pages
+
+For each page that used the extracted block:
+
+**Step 1.** Read the current page file.
+
+**Step 2.** Apply changes surgically:
+1. Add import at top of file:
+   ```jsx
+   import <ComponentName> from '../../components/<ComponentName>';
+   ```
+   (adjust relative path based on page depth)
+
+2. Replace the extracted JSX block with the component:
+   ```jsx
+   <ComponentName <prop>={<value>} />
+   ```
+
+3. Remove any now-unused imports that were only used by the extracted block.
+
+4. Remove any CSS classes in the page's `.module.css` that are now handled by the component's own CSS file.
+
+**Step 3.** Write the updated file.
+
+---
+
+### Phase 8 — Finalize
+
+**Step 1.** Call `context_write`:
+- Append to `context.services[<service_name>].components`:
+  `{ name, path, role, props_accepted, used_in: [list of page paths] }`
+- Set `last_command` = "modularize"
+- Append to `change_log`: `{ timestamp, command: "modularize", action: "Created [n] component(s) from [n] pages" }`
+
+**Step 2.** Call `context_clear_scratchpad` with keys: ["current_action"]
+
+**Step 3.** Show completion report:
+```
+/codeninja:modularize Complete
+─────────────────────────────────────────
+Components created : [n]
+Components reused  : [n]
+Pages updated      : [n]
+─────────────────────────────────────────
+[list created files]
+[list modified files]
+─────────────────────────────────────────
+Next: /codeninja:validate-page to add validation
+      /codeninja:integrate-api to wire forms to backend
+```

package/ide/antigravity/.agents/workflows/codeninja-optimize.md

@@ -0,0 +1,84 @@
+---
+slash_command: /codeninja:optimize
+personas: [global-orchestrator, nodejs-backend, database-architect]
+skills: [mcp-and-context, api-builder, database, code-intelligence]
+description: Analyse and improve performance using real project context.
+---
+
+# /codeninja:optimize
+
+## Before Running
+1. Call `context_read` — load `context.db.schema`, `context.services`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+### Step 1 — Identify Target
+If not specified, ask:
+"What would you like to optimise?
+(a) A slow API endpoint — paste the route path
+(b) A heavy SQL query — paste the query or file path
+(c) Overall service startup / memory usage
+(d) Something else — describe it"
+
+### Step 2 — Load Context
+1. Call `fs_read` on the relevant files (route.js, _model.js)
+2. For DB queries: list existing indexes from `context.db.schema.<table>.indexes`
+
+### Step 3A — Database Query Analysis
+
+For each query in the target:
+
+**Check 1 — Missing Indexes**
+Compare WHERE / JOIN / ORDER BY columns against existing indexes.
+Generate `CREATE INDEX CONCURRENTLY` for missing ones.
+
+**Check 2 — SELECT * Anti-Pattern**
+Replace with explicit column list. Show before/after.
+
+**Check 3 — N+1 Query Pattern**
+Flag any loop calling a DB function per iteration. Suggest single query with IN or JOIN.
+
+**Check 4 — Window Function Choice**
+- `RANK()` → gaps after ties (wrong for leaderboards)
+- `DENSE_RANK()` → no gaps (correct for leaderboards)
+- `ROW_NUMBER()` → unique position (correct for pagination)
+
+**Check 5 — Duplicate Row Prevention**
+Flag duplicate rows from missing dedup. Suggest `MIN(id) GROUP BY user_id`.
+
+**Check 6 — Functional Index Trap**
+Flag `DATE(created_at) = '...'` → suggest range form for index usage.
+
+**Check 7 — work_mem for Sort Operations**
+If EXPLAIN shows external merge disk sort → suggest `SET work_mem = '64MB'`.
+
+### Step 3B — API Route Analysis
+
+- Is heavy middleware on lightweight routes?
+- Synchronous blocking in request path?
+- Repeated DB lookups that could be cached in Redis?
+- Pagination missing on list endpoints?
+
+### Step 4 — Output Recommendations
+
+```
+[HIGH | MED | LOW] — Impact label
+
+Target: what's being optimised
+Root cause: why it's slow right now
+Fix:
+  [exact SQL or code change]
+Estimated gain: concrete estimate
+Side effects: anything developer should know
+```
+
+List all, highest impact first.
+
+### Step 5 — Offer to Apply
+"I've found [N] optimisations. Want me to apply them?
+I'll implement each one and show you the change before writing."
+
+For index changes → generate `NNN_add_index_<n>.sql` migration file.
+For code changes → edit the relevant model or route file surgically.
+Always call `context_write` after applying index additions.

package/ide/antigravity/.agents/workflows/codeninja-refactor.md

@@ -0,0 +1,68 @@
+---
+slash_command: /codeninja:refactor
+personas: [global-orchestrator, nodejs-backend, database-architect]
+skills: [mcp-and-context, api-builder, database, code-intelligence]
+description: Rename or restructure code with full context tracking.
+---
+
+# /codeninja:refactor
+
+## Before Running
+1. Call `context_read`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+**Step 1.** Ask: "What type of refactor?"
+1. Rename a DB column
+2. Rename a service
+3. Rename a table
+4. Rename a module
+5. Restructure files
+- Store: `context.current_refactor.type`
+
+**Step 2.** Ask: "Which service?" (if applicable — skip for DB-only refactors)
+
+---
+
+### If "Rename DB column":
+- Ask: "Which table?" (list from context)
+- Ask: "Which column to rename?" (list current columns)
+- Ask: "New column name?" (snake_case)
+- Delegate to database-agent:
+  - Generate ALTER TABLE migration file
+  - Update `context.db.schema.tables[<table>].columns`
+  - Append to `context.db.schema.change_log`
+- Delegate to nodejs-agent:
+  - Find all references to old column name in service files
+  - Update model queries
+  - Update swagger_doc.json
+
+### If "Rename service":
+- Ask: "Current service name?" (list from context)
+- Ask: "New service name?"
+- Update `context.services` key
+- Append to `context.change_log`
+
+### If "Rename table":
+- Ask: "Which table?" (list from context)
+- Ask: "New table name?" (must start with tbl_, snake_case)
+- Delegate to database-agent:
+  - Generate ALTER migration: `RENAME TABLE <old> TO <new>`
+  - Update `context.db.schema.tables` key
+  - Append to `context.db.schema.change_log`: `{ type: "table_renamed", from: "<old>", to: "<new>" }`
+- Delegate to nodejs-agent:
+  - Find all references to old table name in model files
+  - Update queries in all affected services
+- Append to top-level `context.change_log`
+
+### If "Rename module":
+- Ask: "Current module name?"
+- Ask: "New module name?"
+- Delegate to nodejs-agent → rename files and update route_manager
+
+---
+
+**Confirm:** "Apply refactor? (yes/no)"
+If yes → make all changes → call `context_write` → call `context_clear_scratchpad` ["current_refactor"]
+Show final summary.

package/ide/antigravity/.agents/workflows/codeninja-review.md

@@ -0,0 +1,70 @@
+---
+slash_command: /codeninja:review
+personas: [global-orchestrator, nodejs-backend]
+skills: [mcp-and-context, api-builder, code-intelligence]
+description: Deep code review with severity-ranked findings and concrete fixes.
+---
+
+# /codeninja:review
+
+## Before Running
+1. Call `context_read`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+### Step 1 — Identify Target
+If not specified, ask: "Which file or module would you like reviewed?"
+
+### Step 2 — Load Context
+1. Call `fs_read` on the target file
+2. Read 1–2 similar modules from `context.services[<service>].modules` for pattern comparison
+3. Cross-reference `context.db.schema` for table/column accuracy
+
+### Step 3 — Run Review Checklist
+
+#### Security (CRITICAL if failing)
+- [ ] All POST/PUT/PATCH routes have validatorjs input validation
+- [ ] API key middleware applied before any route logic
+- [ ] JWT auth middleware present on protected routes
+- [ ] No hardcoded secrets, keys, or passwords
+- [ ] Parameterized queries only — no string concatenation in SQL
+- [ ] Error responses don't leak stack traces or internal details
+
+#### Architecture (WARNING if failing)
+- [ ] 2-layer rule: no SQL in route.js, no res.json() in model.js
+- [ ] route_manager.js registration matches route file
+- [ ] swagger_doc.json has entry for this endpoint
+- [ ] All user-facing strings in languages/en.js — none hardcoded in route.js
+
+#### Code Quality (SUGGESTION if failing)
+- [ ] JSDoc on every exported function
+- [ ] No unused variables or dead imports
+- [ ] No console.log — project logger used instead
+- [ ] Async functions have try/catch blocks
+- [ ] SELECT * not used — explicit column list
+
+#### Database (WARNING if failing)
+- [ ] Column names match context.db.schema exactly (snake_case)
+- [ ] Foreign key columns indexed
+- [ ] Transactions used where multiple writes occur together
+- [ ] LIMIT clause on any query that could return unbounded rows
+
+### Step 4 — Output Findings
+
+For each issue:
+```
+[CRITICAL|WARNING|SUGGESTION]
+File:   path/to/file.js  (~line N)
+Issue:  clear one-line description
+Before: the current code
+After:  the corrected code
+Why:    one sentence explanation
+```
+
+End with: `Review complete: X critical · Y warnings · Z suggestions`
+
+### Step 5 — Offer Auto-Fix
+"Would you like me to apply any of these fixes?
+- SUGGESTION-level: apply all at once
+- WARNING/CRITICAL: one at a time, confirm each"

package/ide/antigravity/.agents/workflows/codeninja-sync.md

@@ -0,0 +1,183 @@
+---
+slash_command: /codeninja:sync
+personas: [global-orchestrator, nodejs-backend]
+skills: [mcp-and-context, code-intelligence]
+description: Scan the entire repository and rebuild context.json from what actually exists on disk.
+---
+
+# /codeninja:sync
+
+## Before Running
+1. Call `context_read` — load current state (or detect empty)
+2. Call `service_scan` — discover all services on disk
+3. Call `context_check_stale`
+
+## Two Operating Modes (auto-detected — do NOT ask user)
+
+### Mode A — Agent-Initialized Project
+Indicators: context.json exists AND `context_version > 0` AND `context.services` has entries.
+→ Trust context.json as baseline, scan for drift and gaps, merge new findings without overwriting.
+
+### Mode B — Legacy / No-Context Project
+Indicators: context.json missing OR `context_version == 0` OR `context.services` is empty.
+→ Treat every discovery as new. Build context.json entirely from disk. No assumptions about structure.
+
+## Core Rules (both modes)
+- ALWAYS write context.json at the end — no exceptions
+- NEVER delete existing context entries — only add or update
+- NEVER assume a file will be in a specific location — scan first
+- Report all findings in the sync report at the end
+
+---
+
+## Execution — Full Step-by-Step
+
+### Phase 0 — Prepare
+
+**Step 0a.** Check if `.codeninja/context/` exists. If not → create it.
+**Step 0b.** Call `context_read`. If returns empty schema (version == 0) → set mode B, fresh schema.
+**Step 0c.** Call `service_scan` — detect all service directories at repo root.
+**Step 0d.** Init sync report counters: `services_synced`, `routes_discovered`, `routes_new`,
+`db_tables_synced`, `db_tables_new`, `gaps_filled`, `unchanged`, `legacy_inferences`
+
+---
+
+### Phase 1 — Repository Structure Discovery
+
+#### 1a — Find all service-like directories
+Scan every directory at repository root. A directory is a candidate service if it contains ANY of:
+- `package.json`
+- `app.js` or `index.js`
+- `src/` directory
+- `composer.json` (PHP — record but do not deep-scan)
+
+For each candidate service directory:
+- Read `package.json` if present → extract name, version, dependencies
+- Detect type: NodeJS vs ReactJS:
+  - ReactJS: has `react` in dependencies, has `src/App.jsx` or `src/App.js`
+  - NodeJS: has `express` in dependencies, has `app.js` with `require('express')`
+  - Unknown: record type as "unknown"
+- Read `.env` if present (gitignored, may not exist) → extract PORT, DB_*, REDIS_*, KEY, IV, API_KEY
+- Read `.env.example` if present → extract all keys defined
+
+#### 1b — Detect service port
+Priority order:
+1. PORT value from `.env`
+2. PORT value from `.env.example`
+3. `app.listen(PORT, ...)` call in `app.js` — extract default
+4. `context.services[<n>].port` if already recorded
+
+#### 1c — Detect modules (NodeJS services)
+For each NodeJS service:
+- Scan `modules/` directory (may be `v1/`, `v2/`, etc.)
+- Each subdirectory containing `route.js` = one module
+- Read `route.js` — extract: HTTP method, route path, whether auth middleware is applied
+- Record: `{ module_name, version, method, route_path, has_auth }`
+
+#### 1d — Detect React pages (ReactJS services)
+For each ReactJS service:
+- Scan `src/pages/` — each subdirectory with `index.jsx` or `index.js` = one page
+- Scan `src/views/` if it exists — same logic
+- Detect linked backend:
+  - Read `src/api/apiClient.js` → extract `baseURL` → parse port → match against `context.services`
+  - Or read `.env` → `REACT_APP_BASE_URL` → parse port
+
+---
+
+### Phase 2 — Database Discovery
+
+**Step 2a.** Scan for `database/` directory at repo root.
+If found → read sub-directories to determine db type (postgresql, mysql, mongodb).
+
+**Step 2b.** For each db type directory found:
+- List all `.sql` files in `migrations/` sorted by numeric prefix
+- Parse each setup file:
+  - Extract table name from `CREATE TABLE`
+  - Extract column names and types
+  - Extract CHECK constraints and COMMENT ON COLUMN
+  - Extract per-file CREATE INDEX statements
+- Parse ALTER files: ADD COLUMN, RENAME COLUMN, DROP COLUMN, ADD CONSTRAINT
+- Parse DROP files: mark table as dropped
+- Parse `111-setup-database-indexes.sql`: extract CREATE INDEX, associate with tables
+- Build the full schema state from all files in order
+
+---
+
+### Phase 3 — Context Assembly
+
+#### Mode A — Merge with existing context
+
+For each discovered service:
+- If service already in `context.services` → check for drift:
+  - Port changed? → flag and ask user which to keep
+  - New modules found not in context → add them
+  - Modules in context not found on disk → flag as "missing on disk"
+- If service NOT in context → add it as new entry
+
+For DB schema:
+- Add any tables not in context
+- Add any columns not tracked
+- Add any indexes not tracked
+- For renames found in ALTER files → append to change_log if not already there
+
+#### Mode B — Build from scratch
+
+For each discovered service, build full entry:
+```json
+{
+  "service_name": "<n>",
+  "type": "nodejs|reactjs",
+  "port": <n>,
+  "description": "<inferred from package.json description or service name>",
+  "modules": [...],
+  "linked_service": "<inferred from apiClient.js>",
+  "detected_by": "sync"
+}
+```
+
+For legacy projects that don't follow agent conventions:
+- Record what IS found without imposing expected structure
+- Set `legacy: true` flag on the service entry
+- Note what is missing and suggest /codeninja:init to scaffold missing pieces
+
+---
+
+### Phase 4 — Drift Report and Confirmation
+
+Before writing anything, present a drift report:
+
+```
+SYNC REPORT
+════════════════════════════════════════════
+Mode: A (agent-initialized) | B (legacy/fresh)
+────────────────────────────────────────────
+Services discovered on disk:    [n]
+Services already in context:    [n]
+New services to add:            [n]
+Services with drift:            [n]
+────────────────────────────────────────────
+DB tables on disk:              [n]
+DB tables already in context:   [n]
+New tables to add:              [n]
+────────────────────────────────────────────
+DRIFT ITEMS (require confirmation):
+  ⚠ service [n]: port in context = 1001, found on disk = 1002
+  ⚠ module [n] in context but route.js not found on disk
+────────────────────────────────────────────
+```
+
+For each DRIFT ITEM: ask user to confirm which value to keep — one at a time.
+
+---
+
+### Phase 5 — Write Context
+
+**Step 5.** Call `context_write` with the fully assembled context object.
+Set `last_command` = "sync"
+
+**Step 6.** Show final sync summary with counts of what was added/updated.
+
+**Step 7.** Suggest next steps based on findings:
+- If new services found → "Run /codeninja:api to add API routes"
+- If schema gaps found → "Run /codeninja:db:sync to rebuild DB schema"
+- If legacy project → "Run /codeninja:init to scaffold missing baseline files"

package/ide/antigravity/.agents/workflows/codeninja-test.md

@@ -0,0 +1,61 @@
+---
+slash_command: /codeninja:test
+personas: [global-orchestrator, nodejs-backend]
+skills: [mcp-and-context, api-builder, code-intelligence]
+description: Generate or run Jest + Supertest tests for a NodeJS module.
+---
+
+# /codeninja:test
+
+## Before Running
+1. Call `context_read`
+2. Call `context_check_stale`
+
+## Execution — Full Step-by-Step
+
+**Step 1.** Ask: "Which service?" (list from `context.services`)
+- Store: `context.current_test.service_name`
+
+**Step 2.** Ask: "Which module?" (list from `context.services[<n>].modules`)
+- Store: `context.current_test.module_name`
+
+**Step 3.** Ask: "Generate new tests or run existing tests?"
+- Option 1: Generate new tests
+- Option 2: Run existing tests
+- Store: `context.current_test.type`
+
+**Step 4.** If `generate`:
+- Read `modules/<version>/<Module>/route.js` from disk
+- Read `modules/<version>/<Module>/<module>_model.js` from disk
+- Read `context.api_routes` for this module
+- Delegate to nodejs-agent → generate `tests/<version>/<Module>.test.js`
+
+Generated test file covers:
+- 200 happy path for each endpoint
+- 400 validation failures (missing required fields, wrong types)
+- 401 missing or invalid API key header
+- 401 missing or invalid auth token (for protected routes)
+- 404 not found (where applicable)
+- 500 simulated service error (mock DB failure)
+
+Test structure:
+```javascript
+const request = require('supertest');
+const app = require('../../app');
+
+describe('<Module> — POST /<path>', () => {
+  it('200 — happy path', async () => { ... });
+  it('400 — missing required field', async () => { ... });
+  it('401 — invalid api-key', async () => { ... });
+  it('401 — invalid auth token', async () => { ... });
+  it('404 — record not found', async () => { ... });
+});
+```
+
+**Step 5.** If `run`:
+- Execute: `npm test` inside service directory
+- Parse results and display pass/fail summary
+
+**Step 6.** Call `context_write` → update `context.services[<n>].tests`
+
+**Step 7.** Show final summary.