codeninja 3.2.0 → 4.0.1

package/ide/antigravity/.agents/workflows/codeninja-db-modify.md

@@ -1,106 +1,164 @@
+This workflow runs when user invokes /codeninja:db:modify
+
 ---
-slash_command: /codeninja:db:modify
-personas: [global-orchestrator, database-architect]
-skills: [mcp-and-context, database]
-description: Modify an existing table via a numbered ALTER migration file.
+type: workflow
+name: db-modify-table
+command: "@db:modify-table"
+description: >
+  Modify an existing table via a numbered ALTER migration file. Supports
+  adding columns, renaming columns, dropping columns, changing types,
+  and adding check constraints. Always generates a migration file and
+  updates context.
 ---
 
-# /codeninja:db:modify
+# Workflow: @db:modify-table
 
-## Before Running
-1. Call `context_read` — load `context.db.schema` fully
-2. Call `context_check_stale`
-3. Call `migration_next_number` to get next sequential number
+## Goal
+Generate a properly numbered ALTER TABLE migration file that modifies an
+existing table. Record the change in context.db.schema.change_log so all
+agents have the updated schema.
 
-## Execution — Full Step-by-Step
+## Rules
+- ALWAYS generate an ALTER file — never edit the original table setup file
+- ALTER files are numbered sequentially after the last existing file
+- Every change is recorded in context.db.schema.change_log
+- create-schema.sql is updated after every ALTER file generated
 
-### Phase 1 — Target
+---
 
-**Step 1.** Ask: "Which table?" (list from `context.db.schema.tables`)
-- Store: `context.current_db.table_name`
+## Step-by-Step Execution
 
-**Step 2.** Ask: "What operation?"
-1. Add a new column
-2. Rename a column
-3. Drop a column
-4. Change a column type
-5. Add a CHECK constraint to an existing column
-6. Add a new index → route to /codeninja:db:index instead
-- Store: `context.current_db.modify_operation`
+### Phase 1 — Target
+1. Run task: `ask-table-name`
+   - List tables from `context.db.schema.tables`
+   - Stores: `context.current_db.table_name`
+
+2. Run task: `ask-modify-operation`
+   - Ask: "What do you want to do?"
+   - Options:
+     1. Add a new column
+     2. Rename a column
+     3. Drop a column
+     4. Change a column type
+     5. Add a CHECK constraint to an existing column
+     6. Add a new index
+   - Stores: `context.current_db.modify_operation`
+
+   2b. If `context.current_db.modify_operation == "add_index"`:
+      → Immediately route to `@db:add-index` workflow.
+      → End this workflow (no further steps needed).
 
 ---
 
-### Phase 2 — Operation Details
+### Phase 2 — Operation-Specific Collection
 
 #### If "Add a new column":
-- Ask: "New column name?" (snake_case, lowercase)
-- Ask: "Column type?" (show type suggestions from naming patterns — same as db:create)
-- Ask: "Is this an enum column?" — if yes, collect allowed values
-- Ask: "Add column after which existing column?" (list current columns from context)
-- SQL generated: `ALTER TABLE public.<table> ADD COLUMN <col> <type> NOT NULL DEFAULT <default>;`
+3. Run task: `ask-column-name`
+4. Run task: `ask-column-type`
+5. Run task: `ask-column-is-enum`
+6. Run task: `ask-column-position`
+   - Ask: "Add column after which existing column?"
+   - List current columns from context
+   - Stores: `context.current_db.after_column`
+
+Generated SQL pattern:
+```sql
+ALTER TABLE public.<table_name>
+  ADD COLUMN <col_name> <type> NOT NULL DEFAULT <default>;
+```
 
 #### If "Rename a column":
-- Ask: "Which column to rename?" (list current columns from context)
-- Ask: "New column name?" (snake_case)
-- SQL generated: `ALTER TABLE public.<table> RENAME COLUMN <old> TO <new>;`
+3. Run task: `ask-old-column-name`
+   - List current columns from context
+4. Run task: `ask-new-column-name`
+   - Enforce: snake_case, lowercase
+
+Generated SQL pattern:
+```sql
+ALTER TABLE public.<table_name>
+  RENAME COLUMN <old_name> TO <new_name>;
+```
 
 #### If "Drop a column":
-- Ask: "Which column to drop?" (list current columns)
-- WARN: "This will generate a DROP COLUMN migration. This is irreversible in production.
-  Make sure you have removed all code references first."
-- Ask: "Confirm dropping column '<col>'? (yes/no)"
-- SQL generated: `ALTER TABLE public.<table> DROP COLUMN IF EXISTS <col>;`
+3. Run task: `ask-old-column-name`
+   - List current columns from context
+   - WARN: "This will generate a DROP COLUMN migration. This is irreversible
+     in production. Make sure you have removed all code references first."
+   - Ask: "Confirm dropping column '<col>'? (yes/no)"
+
+Generated SQL pattern:
+```sql
+ALTER TABLE public.<table_name>
+  DROP COLUMN IF EXISTS <col_name>;
+```
 
 #### If "Change a column type":
-- Ask: "Which column?" (list current columns)
-- Ask: "New type?" (warn about potential data loss for narrower types)
-- SQL generated: `ALTER TABLE public.<table> ALTER COLUMN <col> TYPE <new_type> USING <col>::<new_type>;`
+3. Run task: `ask-old-column-name`
+4. Run task: `ask-column-type` (new type)
+   - WARN agent about potential data loss if changing to narrower type
+
+Generated SQL pattern:
+```sql
+ALTER TABLE public.<table_name>
+  ALTER COLUMN <col_name> TYPE <new_type> USING <col_name>::<new_type>;
+```
+
+#### If "Add a CHECK constraint":
+3. Run task: `ask-old-column-name`
+4. Run task: `ask-column-enum-values`
+
+Generated SQL pattern:
+```sql
+ALTER TABLE public.<table_name>
+  ADD CONSTRAINT chk_<table>_<col> CHECK (<col_name> IN (<values>));
+COMMENT ON COLUMN public.<table_name>.<col_name> IS '<enum explanation>';
+```
 
-#### If "Add CHECK constraint":
-- Ask: "Which column?" (list current columns)
-- Ask: "Allowed values?" (comma-separated)
-- SQL generated: `ALTER TABLE public.<table> ADD CONSTRAINT chk_<table>_<col> CHECK (<col> IN (<values>));`
-  Plus: `COMMENT ON COLUMN public.<table>.<col> IS '<enum explanation>';`
+#### If "Add a new index":
+→ Route to `@db:add-index` workflow instead.
 
 ---
 
 ### Phase 3 — File Numbering
-
-**Step 7.** Ask: "Migration file number?" (agent suggests next available)
-- Store: `context.current_db.file_number`
+7. Run task: `ask-table-file-number`
+   - Suggest: next available number after all existing files
+   - Stores: `context.current_db.file_number`
 
 ---
 
 ### Phase 4 — Confirm and Generate
+8. Show summary of the ALTER operation
+   - Display the exact SQL that will be generated
+   - Ask: "Generate this migration? (yes / no)"
 
-**Step 8.** Show the exact SQL that will be generated. Ask: "Generate? (yes / no)"
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/` before generating each migration file.
 
-**Step 9.** Delegate to database-agent:
-Generate: `<repo_root>/database/<db_type>/migrations/<number>-alter-tbl-<n>-<description>.sql`
+9. Delegate to `database-agent`:
+   - Generate: `<repo_root>/database/<db_type>/migrations/<number>-alter-tbl-<n>-<description>.sql`
 
-Full file structure:
-```sql
--- Alter tbl_<table>: <description>
--- Migration: <number>-alter-tbl-<n>-<description>.sql
--- Generated: <ISO date>
+   Full file structure:
+   ```sql
+   -- Alter tbl_<table>: <description>
+   -- Migration: <number>-alter-tbl-<n>-<description>.sql
+   -- Generated: <ISO date>
 
-BEGIN;
+   BEGIN;
 
-ALTER TABLE public.<table_name>
-  <operation>;
+   ALTER TABLE public.<table_name>
+     <operation>;
 
--- COMMENT ON COLUMN if enum/flag column
--- CREATE INDEX if new column needs one
+   -- Optional: COMMENT ON COLUMN if enum/flag column
+   -- Optional: CREATE INDEX if new column needs one
 
-COMMIT;
-```
-Update: `database/<db_type>/create-schema.sql`
+   COMMIT;
+   ```
 
-**Step 10.** Call `context_write`:
-- Update `context.db.schema.tables[<table>].columns`
-- Append to `context.db.schema.change_log`
-- Clear `context.current_db`
+   - Update: `database/<db_type>/create-schema.sql`
 
-**Step 11.** Call `context_clear_scratchpad` with keys: ["current_db"]
+10. Run task: `write-context`
+    - Update `context.db.schema.tables[<table>].columns`
+    - Append to `context.db.schema.change_log`
+    - Clear `context.current_db`
 
-**Step 12.** Show final summary.
+11. Run task: `show-final-summary`

package/ide/antigravity/.agents/workflows/codeninja-db-seed.md

@@ -1,76 +1,104 @@
+This workflow runs when user invokes /codeninja:db:seed
+
 ---
-slash_command: /codeninja:db:seed
-personas: [global-orchestrator, database-architect]
-skills: [mcp-and-context, database]
-description: Add seed/initial data to a table.
+type: workflow
+name: db-seed
+command: "@db:seed"
+description: >
+  Add or update seed data for a table. For reference/master data tables,
+  seed goes inside the table setup file. For all others, a standalone seed
+  file is generated in the seeds/ folder.
 ---
 
-# /codeninja:db:seed
+# Workflow: @db:seed
+
+## Goal
+Generate properly formatted INSERT seed data for a table. Determine whether
+seed belongs in the table file or a standalone seed file.
 
-## Before Running
-1. Call `context_read` — load `context.db.schema`
-2. Call `context_check_stale`
+## Rules
+- Passwords in seed data must be pre-encrypted — agent must ask for encrypted value
+- Never generate plaintext passwords in any file
+- Multi-row INSERT format always (single INSERT with multiple value tuples)
+- Seed file naming: `<repo_root>/database/<db_type>/seeds/<table_name>_seed.sql`
 
-## Execution — Full Step-by-Step
+---
+
+## Step-by-Step Execution
 
 ### Phase 1 — Target
+1. Run task: `ask-table-name`
+   - List tables from `context.db.schema.tables`
+   - Stores: `context.current_db.table_name`
 
-**Step 1.** Ask: "Which table?" (list from `context.db.schema.tables`)
-- Store: `context.current_db.table_name`
+---
 
 ### Phase 2 — Seed File Type
+2. Agent checks if table is a reference/master table:
+   - Reference tables (seed goes IN setup file): tbl_country, tbl_app_content,
+     tbl_strategy_modules, tbl_admin, any lookup table
+   - All others: standalone seed file in seeds/
 
-**Step 2.** Determine seed target:
-- Reference tables (seed goes IN setup file): lookup tables, master/config tables
-- All other tables: standalone seed file in seeds/
+   Ask: "Where should this seed data go?"
+   Options:
+   1. Append to the table's setup file (for reference/master data)
+   2. Create a standalone seed file in seeds/ (for dev/test data)
 
-Ask: "Where should this seed data go?"
-1. Append to the table's setup file (for reference/master data)
-2. Create standalone seed file in seeds/ (for dev/test data)
-- Store: `context.current_db.seed_target`
+   Stores: `context.current_db.seed_target`
 
-### Phase 3 — Data Collection
-
-**Step 3.** Show column list from context (excluding `id` and `created_at` — auto-generated).
+---
 
-**Step 4.** Ask: "How many rows do you want to seed?"
-- Store: `context.current_db.seed_count`
+### Phase 3 — Data Collection
+3. Show column list for the table from context.
+   
+4. Run task: `ask-seed-rows-count`
+   - Ask: "How many rows do you want to seed?"
+   - Stores: `context.current_db.seed_count`
+
+5. For each row (repeat seed_count times):
+   Run task: `ask-seed-row-values`
+   - For each column (excluding `id` and `created_at` — auto-generated):
+     - Ask the value one column at a time
+     - If column is `password` → warn: "Enter the encrypted/hashed value only. Never store plaintext."
+     - If column has CHECK constraint → show allowed values
+     - If column has DEFAULT → offer to use default (user can press enter to skip)
+   - Stores: appends to `context.current_db.seed_rows[]`
 
-**Step 5.** For each row (repeat seed_count times):
-- Ask value for each column one at a time
-- If column is `password` → warn: "Enter the encrypted/hashed value only. Never store plaintext."
-- If column has CHECK constraint → show allowed values
-- If column has DEFAULT → offer to use default (press Enter to skip)
-- Append to: `context.current_db.seed_rows[]`
+---
 
 ### Phase 4 — Generate
-
-**Step 6.** Show full INSERT preview. Ask: "Generate this seed data? (yes / no)"
-
-**Step 7.** Delegate to database-agent:
-
-If appending to setup file → append after the GRANT line:
-```sql
-INSERT INTO public.<table_name> (<col1>, <col2>, ...) VALUES
-(<val1a>, <val2a>, ...),
-(<val1b>, <val2b>, ...);
-```
-
-If standalone seed file → generate `database/<db_type>/seeds/<table_name>_seed.sql`:
-```sql
--- Seed data for <table_name>
--- Environment: development
--- Generated: <ISO date>
-
-INSERT INTO public.<table_name> (<col1>, <col2>, ...) VALUES
-(<val1a>, <val2a>, ...),
-(<val1b>, <val2b>, ...);
-```
-
-**Step 8.** Call `context_write`:
-- Append to `context.db.schema.change_log`: `{ type: "seed_added", table: "<n>", rows: <count> }`
-- Clear `context.current_db`
-
-**Step 9.** Call `context_clear_scratchpad` with keys: ["current_db"]
-
-**Step 10.** Show final summary.
+6. Show full INSERT preview to user
+   - Ask: "Generate this seed data? (yes / no)"
+
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/collect-seed-data.task.md` before generating seed data.
+
+7. Delegate to `database-agent`:
+
+   If appending to setup file:
+   - Read existing setup file
+   - Append after the GRANT line:
+   ```sql
+   INSERT INTO public.<table_name> (<col1>, <col2>, ...) VALUES
+   (<val1a>, <val2a>, ...),
+   (<val1b>, <val2b>, ...);
+   ```
+
+   If standalone seed file:
+   - Generate: `database/<db_type>/seeds/<table_name>_seed.sql`
+   ```sql
+   -- Seed data for <table_name>
+   -- Environment: development
+   -- Generated: <ISO date>
+
+   INSERT INTO public.<table_name> (<col1>, <col2>, ...) VALUES
+   (<val1a>, <val2a>, ...),
+   (<val1b>, <val2b>, ...);
+   ```
+
+8. Run task: `write-context`
+   - Append to `context.db.schema.change_log`:
+     `{ "type": "seed_added", "table": "<n>", "rows": <count> }`
+   - Clear `context.current_db`
+
+9. Run task: `show-final-summary`

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

@@ -1,70 +1,106 @@
+This workflow runs when user invokes /codeninja:db:sync
+
 ---
-slash_command: /codeninja:db:sync
-personas: [global-orchestrator, database-architect]
-skills: [mcp-and-context, database]
-description: Scan all migration files and rebuild context.db.schema from actual file contents.
+type: workflow
+name: db-sync
+command: "@db:sync"
+description: >
+  Scan all migration files in the database folder and rebuild context.db.schema
+  from actual file contents. Safe to run at any time. Never destructive —
+  only adds or updates, never removes existing context entries.
 ---
 
-# /codeninja:db:sync
+# Workflow: @db:sync
+
+## Goal
+Make context.db.schema an accurate reflection of what is actually on disk.
+Parse every migration file in order and reconstruct the full schema state.
 
-## Before Running
-1. Call `context_read`
-2. Call `context_check_stale`
+---
 
-## Execution — Full Step-by-Step
+## Step-by-Step Execution
 
 ### Phase 1 — Locate Files
+1. Read `context.db.type` to find the correct folder:
+   `<repo_root>/database/<db_type>/migrations/`
+   The database folder is always at repository root, never inside
+   a service folder.
+2. List all `.sql` files in that folder
+3. Sort them in numeric order by filename prefix (1, 2, 3... 111)
+4. Separate into categories:
+   - setup files: `*-setup-tbl-*.sql`
+   - alter files: `*-alter-tbl-*.sql`
+   - drop files: `*-drop-tbl-*.sql`
+   - index file: `111-setup-database-indexes.sql`
 
-**Step 1.** Read `context.db.type` → find `<repo_root>/database/<db_type>/migrations/`
-**Step 2.** List all `.sql` files, sort by numeric prefix (1, 2, 3… 111)
-**Step 3.** Categorize:
-- setup files: `*-setup-tbl-*.sql`
-- alter files: `*-alter-tbl-*.sql`
-- drop files: `*-drop-tbl-*.sql`
-- index file: `111-setup-database-indexes.sql`
+---
 
 ### Phase 2 — Parse Each File
-
 For each setup file (in order):
-- Extract table name from CREATE TABLE
+- Extract table name from CREATE TABLE statement
 - Extract all column names and types
-- Extract CHECK constraints and COMMENT ON COLUMN lines (enum descriptions)
+- Extract CHECK constraints (enum values)
+- Extract COMMENT ON COLUMN lines (enum descriptions)
 - Extract per-file CREATE INDEX lines
 - Note if table has `status`, `is_deleted`, `created_at`
 
 For each alter file (in order after its setup file):
-- ADD COLUMN → add to that table's columns
-- RENAME COLUMN → update name, record in change_log
-- DROP COLUMN → remove from columns
-- ADD CONSTRAINT → update column constraint info
+- Parse ADD COLUMN → add to that table's columns
+- Parse RENAME COLUMN → update column name, record in change_log
+- Parse DROP COLUMN → remove from columns
+- Parse ADD CONSTRAINT → update column's constraint info
 
-For each drop file: mark table as dropped.
+For each drop file:
+- Mark that table as dropped in the scan result
 
-For the index file: parse all CREATE INDEX, associate each with its table.
+For the index file:
+- Parse all CREATE INDEX statements
+- Associate each index with its table
 
-### Phase 3 — Rebuild Context
+---
 
+### Phase 3 — Rebuild Context
 For each discovered table (not dropped):
 - Compare with existing `context.db.schema.tables[<table>]`
-- Add tables not already in context
-- Add columns not already tracked
-- Add indexes not already tracked
-- For renames in ALTER files → append to change_log if not already there
+- Add any tables not already in context
+- Add any columns not already tracked
+- Add any indexes not already tracked
+- For renames found in ALTER files → append to change_log if not already there
 
 For dropped tables:
-- If still in `context.db.schema.tables` → move to change_log snapshot, remove from active tables
+- If still in `context.db.schema.tables` → move to change_log snapshot
+- Remove from active tables list
 
-### Phase 4 — Rebuild create-schema.sql
+---
 
-- Re-read all filenames in correct numeric order
+### Phase 4 — Rebuild create-schema.sql
+- Re-read all file names in correct numeric order
 - Rewrite `create-schema.sql` to match actual files on disk
-- Report: any `\i` entries in create-schema.sql missing from disk (stale)
-- Report: any files on disk not in create-schema.sql (missing)
+- Report any \i entries that are in create-schema.sql but missing from disk (stale)
+- Report any files on disk not in create-schema.sql (missing)
 
-### Phase 5 — Finalize
-
-**Step 5.** Show sync report: tables synced, columns added, indexes added, stale entries, missing files.
-
-**Step 6.** Call `context_write` with rebuilt `context.db.schema`.
+---
 
-**Step 7.** Show final summary.
+### Phase 5 — Write and Report
+
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/` before generating any schema updates.
+
+1. Run task: `write-context` with all schema deltas
+2. Display sync report:
+```
+@db:sync complete
+─────────────────────────────────────────
+Migration files scanned : [n]
+Tables discovered       : [n] ([x] new)
+Columns synced          : [n] ([x] new)
+Indexes synced          : [n] ([x] new)
+Renames detected        : [n]
+Dropped tables          : [n]
+create-schema.sql       : updated
+Context gaps filled     : [n]
+─────────────────────────────────────────
+```
+3. If any conflicts found (e.g. column exists in context with different type than file):
+   - List each conflict
+   - Ask user which to keep (file or context) — one at a time

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

@@ -1,44 +1,60 @@
+This workflow runs when user invokes /codeninja:debug
+
 ---
-slash_command: /codeninja:debug
-personas: [global-orchestrator, nodejs-backend]
-skills: [mcp-and-context, api-builder, code-intelligence]
-description: Diagnose and fix bugs using full project context and code path tracing.
+type: workflow
+name: debug
+description: >
+  Diagnose and fix bugs using full project context — DB schema, middleware
+  chain, service config, and established patterns. Traces the exact failure
+  path and produces a concrete fix.
 ---
 
-# /codeninja:debug
+# Workflow: @debug / /codeninja:debug
 
-## Before Running
-1. Call `context_read` — load services, DB schema, project config
-2. Call `context_check_stale`
+## Goal
+Find the root cause of a bug and produce a concrete fix using actual project
+context. Never guess — trace the real code path.
+
+## Rules
+- Trace the full request path before concluding anything
+- Cross-reference context.db.schema before assuming a DB mismatch
+- Check middleware chain order before assuming an auth issue
+- One question at a time when gathering information
+
+---
 
-## Execution — Full Step-by-Step
+## Step-by-Step Execution
 
-### Step 1 — Gather Error Information (ask one at a time if not provided)
+### Step 1 — Gather Error Information
+Ask (one at a time if not already provided):
 1. "Paste the full error message and stack trace."
 2. "Which endpoint or operation triggered it? (e.g., POST /v1/scores/submit)"
-3. "What did you expect vs what actually happened?"
+3. "What did you expect to happen vs what actually happened?"
 4. "What changed recently before this error appeared?"
 
 ### Step 2 — Load Context
-1. Call `fs_read` on the relevant `route.js`
-2. Call `fs_read` on the relevant `_model.js`
-3. Call `fs_exists` on the migration file for any table mentioned in the error
+1. Call `context_read` — load services, DB schema, project config
+2. Call `fs_read` on the relevant route.js
+3. Call `fs_read` on the relevant _model.js
+4. Call `fs_exists` on the migration file for any table mentioned in the error
 
 ### Step 3 — Trace the Failure Path
 
-Walk the request lifecycle in order — mark the exact step where failure occurs:
+Walk the request lifecycle in order:
 ```
 Request received
   → Language middleware (extracts Accept-Language)
   → API key middleware (validates api-key header)
-  → Auth middleware (validates JWT if protected)
+  → Auth middleware (validates JWT, if protected)
   → Validation (validatorjs schema)
   → Route handler (calls model)
   → Model function (executes query)
-  → Database (pg pool / mysql2 / mongoose)
+  → Database (pg pool)
   → Response formatter
 ```
 
+Mark the exact step where the error occurs.
+
 ### Step 4 — Check Common Root Causes
 
 | Symptom | Check |
@@ -48,7 +64,7 @@ Request received
 | `Cannot read property of undefined` | missing null check after DB query returns 0 rows |
 | `401 Unauthorized` | middleware order — apiKey middleware applied? header name correct? |
 | `500 Internal Server Error` | missing try/catch around async DB call |
-| `Wrong number of rows` | missing dedup, RANK vs DENSE_RANK, missing WHERE clause |
+| `Wrong number of rows` | missing dedup query, RANK vs DENSE_RANK, missing WHERE clause |
 | `Migration not applied` | table exists in code but not in DB — run migration |
 | Stale context data | context.db.schema out of date — suggest /codeninja:db:sync |
 
@@ -69,14 +85,12 @@ After:
 Why this fixes it: [one sentence]
 ```
 
-If multiple files need changes, show each in order.
+If multiple files need changes, show each one in order.
 
 ### Step 6 — Verify Plan
-
 "Before I apply this fix, confirm: does this match what you're seeing?
 Once confirmed, I'll make the changes."
 
 ### Step 7 — Prevent Recurrence
-
 After fixing: suggest one guard that prevents this class of bug in the future.
 (e.g., a missing index, an added null check helper, a context convention)