wip

Author: omargfh

apps/modeling-commons-backend/.claude/skills/antigravity/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: antigravity-protocol
+description: Use this skill ALWAYS whenever the user asks you to write code, modify files, fix bugs, plan features, or do any software development task. Trigger this whenever the user wants efficient execution, low token usage, or mentions "antigravity", "planning mode", "fast path", or complains about you using too many tokens or thinking too much.
+---
+
+# Antigravity Protocol (v2.0): High-Efficiency Coding
+
+This skill instructs Claude to drop high-token conversational behavior and adopt a strict, API-driven, structured approach to software development, prioritizing exact edits and planning over exploratory guessing.
+
+## 1. Core Directives (Always Follow These)
+
+1. **Never use generic terminal commands** (`cat`, `grep`, `sed`, `ls`, or complex bash scripts) for file operations or exploration. Use your built-in edit/search tools.
+2. **Chunk-based editing ONLY**. Never output full file contents. Issue search-and-replace style edits targeting exact line numbers.
+3. **Stop guessing**. If a request is ambiguous, do NOT write test scripts to "figure it out". Stop and ask the user a specific question.
+4. **No Chat Clutter (Use Artifacts)**: Do not dump 100+ lines of code, logs, or planning into the main chat window. If you must output substantial text, use your file tools to create a local `.md` artifact file instead, and provide the user a link.
+5. **Acknowledge and Act**. Do NOT write preambles ("I understand you want to..."). Output the tool call and state "Done."
+
+## 2. Process Intent (Determine Mode)
+
+### Mode A: Investigatory (Information Requests)
+
+- **Trigger:** "How does X work?", "Find where Y happens."
+- **Action:** Search the codebase silently. Output only the short answer. Do not create a plan.
+
+### Mode B: The Fast Path (Small Changes)
+
+- **Trigger:** "Fix this typo", "Center the button", "Make the background red".
+- **Action:**
+  1. Retrieve the file context to find exact line numbers.
+  2. Issue a precise file-replacement tool call.
+  3. Close turn with a 1-sentence summary. No planning required.
+
+### Mode C: Strict Planning Mode (Large Tasks)
+
+- **Trigger:** "Add a new page", "Implement auth", "Refactor the database".
+- **Action Flow:**
+  1. **Silent Phase:** Trace dependencies silently. Do NOT modify any code.
+  2. **Plan Artifact:** Create `implementation_plan.md` in the project root. Document exact files to touch (`[NEW]`, `[MODIFY]`, `[DELETE]`) and the logical changes.
+  3. **Halt for Approval:** Stop generating text entirely. Wait for the user to approve the plan.
+  4. **Execution Checklist:** Create `task.md`. Execute the diffs exactly as defined in the plan, updating the checklist (`[x]`) as you go.
+  5. **Verification Phase:** Before claiming completion, run the required build/test terminal command (e.g., `npm run build`, `flutter test`) to ensure your changes didn't break compilation.
+
+## 3. Persistent Knowledge Management
+
+To minimize tokens on future prompts, you must create a "save state" for complex architectural changes.
+
+- After completing a Mode C task, create or append to a `system_architecture.md` or `.cursorrules` file detailing the design pattern you just used (e.g., "The subscription cache uses Riverpod and must be updated in X file").
+- Always read this file before starting new Mode C plans.
+
+## 4. Tool Hierarchy
+
+Evaluate tools in this strict priority order:
+
+1. `Read / Search Tools`: (Highest Priority - Targeted reads, low token).
+2. `Edit / Replace Tools`: (For targeted code edits).
+3. `Create File Tools`: (For brand new files and Markdown artifacts).
+4. `Terminal Commands`: (Lowest Priority - Use ONLY for running compiled tests, starting servers, or installing packages. NEVER for edits or file reading).

apps/modeling-commons-backend/src/modules/model/database/model.repository.port.ts

@@ -1,3 +1,4 @@
+import type { Model } from '#prisma/index';
 import type {
   ModelEntity,
   ModelSearchFilters,
@@ -7,6 +8,8 @@ import type { Paginated, PaginatedQueryParams } from '#src/shared/db/repository.
 import type { RepositoryPort } from '#src/shared/db/repository.port.ts';
 import type { TransactionContext } from '#src/shared/db/transaction.port.ts';
 
+export type ModelRecord = Model;
+
 export interface ModelRepository extends RepositoryPort<ModelEntity> {
   findByIdIncludeDeleted(id: string): Promise<ModelEntity | undefined>;
   setLatestVersion(ctx: TransactionContext, modelId: string, versionNumber: number): Promise<void>;

apps/modeling-commons-backend/src/modules/model/database/model.repository.ts

@@ -4,7 +4,7 @@ import type {
   ModelSearchFilters,
   ModelVisibility,
 } from '#src/modules/model/domain/model.types.ts';
-import type { ModelRecord } from '#src/modules/model/model.mapper.ts';
+import type { ModelRecord } from '#src/modules/model/database/model.repository.port.ts';
 import type { Paginated, PaginatedQueryParams } from '#src/shared/db/repository.port.ts';
 import type { TransactionContext } from '#src/shared/db/transaction.port.ts';
 import { resolveTransaction } from '#src/shared/db/prisma-transaction.manager.ts';

apps/modeling-commons-backend/src/modules/model/domain/model.types.ts

@@ -1,21 +1,13 @@
+import type { ModelRecord } from '../database/model.repository.port.ts';
+
 export const ModelVisibility = {
   public: 'public',
   private: 'private',
   unlisted: 'unlisted',
 } as const;
 export type ModelVisibility = (typeof ModelVisibility)[keyof typeof ModelVisibility];
 
-export type ModelEntity = {
-  id: string;
-  latestVersionNumber: number | null;
-  parentModelId: string | null;
-  parentVersionNumber: number | null;
-  visibility: ModelVisibility;
-  isEndorsed: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date | null;
-};
+export type ModelEntity = ModelRecord;
 
 export type CreateModelProps = {
   title: string;

apps/modeling-commons-backend/src/modules/model/index.ts

@@ -1,6 +1,6 @@
 import type { Mapper } from '#src/shared/ddd/mapper.interface.ts';
 import type { ModelEntity } from '#src/modules/model/domain/model.types.ts';
-import type { ModelRecord } from '#src/modules/model/model.mapper.ts';
+import type { ModelRecord } from '#src/modules/model/database/model.repository.port.ts';
 import type { ModelResponseDto } from '#src/modules/model/dtos/model.response.dto.ts';
 import type { ModelRepository } from '#src/modules/model/database/model.repository.port.ts';
 import type modelDomain from '#src/modules/model/domain/model.domain.ts';

apps/modeling-commons-backend/src/modules/model/model.mapper.ts

@@ -1,21 +1,10 @@
 import type { Mapper } from '#src/shared/ddd/mapper.interface.ts';
-import type { ModelEntity, ModelVisibility } from '#src/modules/model/domain/model.types.ts';
+import type { ModelEntity } from '#src/modules/model/domain/model.types.ts';
+import type { ModelRecord } from '#src/modules/model/database/model.repository.port.ts';
 import type { ModelResponseDto } from '#src/modules/model/dtos/model.response.dto.ts';
 import { ajv } from '#src/shared/utils/index.ts';
 import { ArgumentInvalidException } from '#src/shared/exceptions/index.ts';
 
-export type ModelRecord = {
-  id: string;
-  latestVersionNumber: number | null;
-  parentModelId: string | null;
-  parentVersionNumber: number | null;
-  visibility: ModelVisibility;
-  isEndorsed: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-  deletedAt: Date | null;
-};
-
 const modelSchema = {
   type: 'object',
   properties: {

apps/modeling-commons-backend/src/shared/ddd/create-mapper.ts

@@ -0,0 +1,70 @@
+import type { Mapper } from './mapper.interface.ts';
+
+class NotImplementedException extends Error {}
+
+const identity = <T, U>(x: T): U => x as unknown as U;
+
+function createMapperHelper<Entity, Record, Response>(
+  input: Partial<Mapper<Entity, Record, Response>>,
+): Mapper<Entity, Record, Response> {
+  return {
+    toDomain:
+      input.toDomain ??
+      (() => {
+        throw new NotImplementedException('toDomain not implemented on this mapper');
+      }),
+    toPersistence:
+      input.toPersistence ??
+      (() => {
+        throw new NotImplementedException('toPersistence not implemented on this mapper');
+      }),
+    toResponse: input.toResponse
+      ? (e) => applyGlobalResponseFormat(input.toResponse!(e))
+      : () => {
+          throw new NotImplementedException('toResponse not implemented on this mapper');
+        },
+  };
+}
+
+// Read requests can be satisfied with the identity function
+// if a custom domain shape is not required.
+// -- Omar Ibrahim, Apr 16 26
+export function createReadOnlyMapper<Record, Response>(input: {
+  toResponse: (record: Record) => Response;
+}): Mapper<Record, Record, Response> {
+  return createMapperHelper<Record, Record, Response>({
+    toDomain: identity as (record: Record) => Record,
+    toResponse: input.toResponse,
+  });
+}
+
+export function createWriteOnlyMapper<Entity extends Record, Record, Response>(input: {
+  toDomain: (record: Record) => Entity;
+  toResponse: (entity: Entity) => Response;
+}): Mapper<Entity, Record, Response> {
+  return createMapperHelper<Entity, Record, Response>({
+    toDomain: input.toDomain,
+    toPersistence: identity as (entity: Entity) => Record,
+    toResponse: input.toResponse,
+  });
+}
+
+export function createMapper<Entity, Record, Response>(
+  input: Mapper<Entity, Record, Response>,
+): Mapper<Entity, Record, Response> {
+  return createMapperHelper(input);
+}
+
+export { identity };
+function applyGlobalResponseFormat<T>(dto: T): T {
+  // Date → ISO, Buffer → base64 data-url, null passthrough, etc.
+  // Keep the list small and documented.
+  // -- Omar Ibrahim, Apr 16 26
+  if (dto === null || typeof dto !== 'object') return dto;
+  const out: { [key: string]: unknown } = { ...(dto as object) };
+  for (const key of Object.keys(out)) {
+    const value = out[key];
+    if (value instanceof Date) out[key] = value.toISOString();
+  }
+  return out as T;
+}

apps/modeling-commons-backend/tsconfig.json

@@ -5,7 +5,7 @@
       "#src/*": ["./src/*"],
       "#modules/*": ["./src/modules/*"],
       "#tests/*": ["./tests/*"],
-      "#prisma/*": ["./generated/prisma/*.js"]
+      "#prisma/*": ["./generated/prisma/*"]
     }
   },
   "include": ["src", "tests"],

apps/modeling-commons-frontend/app/app.config.ts

@@ -156,6 +156,9 @@ export default defineAppConfig({
           md: "px-6 py-[0.625rem] gap-3 text-md",
           lg: "px-5 py-2 gap-2",
         },
+        variant: {
+          link: "p-0",
+        },
       },
       compoundVariants: [
         {
@@ -181,5 +184,12 @@ export default defineAppConfig({
         },
       ],
     },
+
+    table: {
+      slots: {
+        root: "ring ring-neutral-darkest/15 rounded-sm",
+        base: "mb-0",
+      },
+    },
   },
 });

apps/modeling-commons-frontend/app/assets/styles/main.scss

@@ -8,7 +8,27 @@
 
 @layer website {
   @include meta.load-css("@repo/tailwind-config/scss/normalize.scss");
-  @include meta.load-css("@repo/tailwind-config/scss/netlogo-theme.scss");
+
+  @include meta.load-css(
+    "@repo/tailwind-config/scss/netlogo-theme.scss",
+    $with: ("netlogo-table": false)
+  );
+
+  // Reset some critical values for @nuxt/ui to behave
+  // as expected. data-slot="root" is the root element of a
+  // a @nuxt/ui component.
+  // -- Omar Ibrahim, Apr 16 26
+  [data-slot="root"] {
+    & p {
+      margin-bottom: 0;
+    }
+    & ul {
+      margin: 0;
+    }
+    & li {
+      margin-inline: 0;
+    }
+  }
 
   h1,
   h2,