codeninja 3.1.0 → 4.0.0

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

@@ -1,11 +1,109 @@
+This workflow runs when user invokes /codeninja:db:drop
+
 ---
-slash_command: /codeninja:db:drop
-personas: [global-orchestrator, database-architect]
-skills: [mcp-and-context, database]
-description: Drop a table with a DROP migration file
+type: workflow
+name: db-drop-table
+command: "@db:drop-table"
+description: >
+  Generate a DROP TABLE migration file for an existing table. Removes the
+  table from context, updates create-schema.sql, and records the drop in
+  change_log. Never deletes the original setup file — history is preserved.
 ---
-# /codeninja:db:drop
-Delegates to: `.codeninja/commands/db-drop-table.workflow.md`
-Before: `context_read`, `migration_next_number`.
-WARN user: "This is destructive. Confirm you want to DROP [table]?"
-After: `context_write` — remove table from context.db.schema.
+
+# Workflow: @db:drop-table
+
+## Goal
+Safely generate a DROP TABLE migration. The original setup file is preserved
+for history. The schema runner will execute the drop when run.
+
+## Rules
+- NEVER delete the original <number>-setup-tbl-<n>.sql file
+- ALWAYS generate a new numbered drop migration file
+- ALWAYS warn the user about irreversibility
+- Records in change_log with full before-state for rollback reference
+
+---
+
+## 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`
+
+---
+
+### Phase 2 — Impact Analysis
+2. Agent scans `context`:
+   - Check `context.api_routes` for any routes that reference this table as `primary_table`
+   - Check `context.services` for any modules using this table
+   - Check `context.db.schema.tables` for any other tables with FK columns pointing here
+
+3. If references found:
+   - Display warning:
+     ```
+     ⚠ WARNING: This table is referenced by:
+       - [service]/modules/[Module] (primary_table)
+       - tbl_<other_table>.user_id → tbl_users (FK dependency)
+     
+     Dropping this table will break these references.
+     Make sure to update or remove dependent code first.
+     ```
+   - Ask: "Do you still want to proceed? (yes / no)"
+   - If no → abort
+
+4. Final confirmation:
+   - Ask exactly: "Type the table name to confirm the drop."
+   - Must match exactly — if wrong → abort
+   - Stores: confirmation
+
+---
+
+### Phase 3 — File Numbering
+5. Run task: `ask-table-file-number`
+   - Suggest: next available number
+   - Stores: `context.current_db.file_number`
+
+---
+
+### Phase 4 — Generate
+
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/` before generating the drop migration file.
+
+6. Delegate to `database-agent`:
+   - Generate: `<repo_root>/database/<db_type>/migrations/<number>-drop-tbl-<n>.sql`
+
+   File contents:
+   ```sql
+   -- Drop tbl_<table_name>
+   -- Migration: <number>-drop-tbl-<n>.sql
+   -- Generated: <ISO date>
+   -- WARNING: This migration is irreversible in production.
+   -- Original table definition: <original_setup_file>
+
+   BEGIN;
+
+   DROP TABLE IF EXISTS public.<table_name> CASCADE;
+
+   COMMIT;
+   ```
+
+   - Update: `database/<db_type>/create-schema.sql`
+     - Keep the original `\i <setup_file>` entry
+     - Add the drop file entry AFTER it
+
+7. Run task: `write-context`
+   - Move table from `context.db.schema.tables` → save columns snapshot
+   - Append to `context.db.schema.change_log`:
+     ```json
+     {
+       "type": "table_dropped",
+       "table": "<table_name>",
+       "snapshot": { "<full column list saved here>" },
+       "file": "<drop_file_path>"
+     }
+     ```
+   - Clear `context.current_db`
+
+8. Run task: `show-final-summary`

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

@@ -1,11 +1,102 @@
+This workflow runs when user invokes /codeninja:db:index
+
 ---
-slash_command: /codeninja:db:index
-personas: [global-orchestrator, database-architect]
-skills: [mcp-and-context, database]
-description: Add a new index to an existing table with migration file
+type: workflow
+name: db-add-index
+command: "@db:add-index"
+description: >
+  Add a new index to an existing table. Determines whether the index belongs
+  in the table's own file (new tables) or in 111-setup-database-indexes.sql
+  (shared/cross-service indexes). Updates context and create-schema.sql.
 ---
-# /codeninja:db:index
-Delegates to: `.codeninja/commands/db-add-index.workflow.md`
-Before: `context_read`, `migration_next_number`.
-Show existing indexes from context.db.schema before suggesting new ones.
-After: `context_write` with updated index list.
+
+# Workflow: @db:add-index
+
+## Goal
+Generate a properly named CREATE INDEX statement and place it in the correct
+file. Follow all index naming conventions from database-agent.md.
+
+---
+
+## Step-by-Step Execution
+
+### Phase 1 — Target Table
+1. Run task: `ask-table-name`
+   - List tables from `context.db.schema.tables`
+   - Stores: `context.current_db.table_name`
+
+---
+
+### Phase 2 — Index Columns
+2. Run task: `ask-index-columns`
+   - Ask: "Which column(s) should this index cover?"
+   - List available columns from `context.db.schema.tables[<table>].columns`
+   - Allow selecting one or multiple columns (compound index)
+   - Stores: `context.current_db.index_columns[]`
+
+3. Run task: `ask-index-sort-order`
+   - Ask: "Should any column in this index be sorted descending?"
+   - Common case: `created_at DESC`, `time DESC`
+   - If yes → ask which column(s) should be DESC
+   - Stores: `context.current_db.index_desc_columns[]`
+
+4. Run task: `ask-index-type`
+   - Ask: "Is this a standard index or a partial index?"
+   - Options:
+     1. Standard index (covers all rows)
+     2. Partial index (only indexes rows matching a condition)
+   - If partial → ask: "Enter the WHERE condition."
+     Example: `WHERE is_deleted = FALSE`
+   - Stores: `context.current_db.index_where_clause`
+
+---
+
+### Phase 3 — File Placement
+5. Run task: `ask-index-file-placement`
+   - Ask: "Where should this index be defined?"
+   - Options:
+     1. In the table's own setup file (for new/just-created tables)
+     2. In 111-setup-database-indexes.sql (for existing tables, shared use)
+   - Auto-suggest option 2 if table already has a setup file in migrations
+   - Stores: `context.current_db.index_file`
+
+---
+
+### Phase 4 — Generate
+6. Agent auto-generates the index name following convention:
+   - In table file: `idx_<table_without_tbl_prefix>_<columns_joined>`
+   - In shared file: `idx_tbl_<table_without_tbl_prefix>_<columns_joined>`
+   - Show name to user: "Index will be named: <n> — OK? (yes / rename)"
+
+7. Confirm: "Generate this index? (yes / no)"
+
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/` before generating the index.
+
+8. Delegate to `database-agent`:
+   - If table file placement → append to `<repo_root>/database/<db_type>/migrations/<table_file>.sql`
+   - If shared file → append to `<repo_root>/database/<db_type>/migrations/111-setup-database-indexes.sql`
+
+   Generated SQL:
+   ```sql
+   -- Standard
+   CREATE INDEX <index_name> ON public.<table_name> (<col> [DESC], ...);
+
+   -- Partial
+   CREATE INDEX <index_name> ON public.<table_name> (<col> [DESC], ...)
+     WHERE <where_clause>;
+   ```
+
+   With standard header comment:
+   ```sql
+   --
+   -- Name: <index_name>; Type: INDEX; Schema: public
+   --
+   ```
+
+9. Run task: `write-context`
+   - Append index name to `context.db.schema.tables[<table>].indexes`
+   - Append to `context.db.schema.change_log`
+   - Clear `context.current_db`
+
+10. Run task: `show-final-summary`

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

@@ -1,11 +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: Add, rename, or drop a column via ALTER migration
+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
-Delegates to: `.codeninja/commands/db-modify-table.workflow.md`
-Before: `context_read`, `migration_next_number`.
-Show existing columns from context.db.schema before asking which to change.
-After: `context_write` with updated column list.
+
+# Workflow: @db:modify-table
+
+## 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.
+
+## 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
+
+---
+
+## 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`
+
+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-Specific Collection
+
+#### If "Add a new column":
+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":
+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":
+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":
+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 a new index":
+→ Route to `@db:add-index` workflow instead.
+
+---
+
+### Phase 3 — File Numbering
+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)"
+
+> **Multi-agent:** Delegate to `database-architect` via Task invocation for parallel execution.
+> Read `.codeninja/tasks/` before generating each migration file.
+
+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>
+
+   BEGIN;
+
+   ALTER TABLE public.<table_name>
+     <operation>;
+
+   -- Optional: COMMENT ON COLUMN if enum/flag column
+   -- Optional: CREATE INDEX if new column needs one
+
+   COMMIT;
+   ```
+
+   - Update: `database/<db_type>/create-schema.sql`
+
+10. Run task: `write-context`
+    - Update `context.db.schema.tables[<table>].columns`
+    - Append to `context.db.schema.change_log`
+    - Clear `context.current_db`
+
+11. Run task: `show-final-summary`

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

@@ -1,10 +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 or update seed data for 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
-Delegates to: `.codeninja/commands/db-seed.workflow.md`
-Before: `context_read` — load context.db.schema for real column names.
-After: `context_write` to record seed file location.
+
+# 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.
+
+## 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`
+
+---
+
+## 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`
+
+---
+
+### 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/
+
+   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)
+
+   Stores: `context.current_db.seed_target`
+
+---
+
+### 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[]`
+
+---
+
+### Phase 4 — Generate
+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,12 +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 migration files and rebuild context.db.schema
----
-# /codeninja:db:sync
-Delegates to: `.codeninja/commands/db-sync.workflow.md`
-Before: `context_read`, `fs_list` all migration files.
-Compare files on disk vs context.db.schema — surface all gaps.
-User approves before context is updated.
-After: `context_write` with fully rebuilt context.db.schema.
+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.
+---
+
+# 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.
+
+---
+
+## 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`
+
+---
+
+### Phase 2 — Parse Each File
+For each setup file (in order):
+- Extract table name from CREATE TABLE statement
+- Extract all column names and types
+- 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):
+- 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 that table as dropped in the scan result
+
+For the index file:
+- Parse all CREATE INDEX statements
+- Associate each index with its table
+
+---
+
+### Phase 3 — Rebuild Context
+For each discovered table (not dropped):
+- Compare with existing `context.db.schema.tables[<table>]`
+- 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 list
+
+---
+
+### 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 that are in create-schema.sql but missing from disk (stale)
+- Report any files on disk not in create-schema.sql (missing)
+
+---
+
+### 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