@smartsoft001-mobilems/claude-plugins 2.85.0 → 2.87.0

package/plugins/mobilems/skills/mobilems-articles/references/lib-contents.md

@@ -0,0 +1,164 @@
+# libs/museum-<name> — structure to create
+
+Copy from an existing article module in the reference MobilEMS app and substitute the module's
+`<name>` / `<entity>`, threading `<PREFIX>`. The library has two projects: a
+thin `domain` (one entity extending the npm `Article`) and a `shell/angular` (the Angular module +
+list/item pages + service). Article modules use the npm `Article` entity directly through
+`ArticlesSharedModule.forFeature`; the local domain entity is a near-empty subclass.
+
+```
+libs/museum-<name>/
+├── domain/                              # project: museum-<name>-domain
+│   └── src/
+│       ├── index.ts                     # export * from './lib/entities';
+│       └── lib/
+│           ├── entities/                # Museum<Name> extends Article (+ index)
+│           ├── enums/                   # .gitkeep
+│           ├── specifications/          # .gitkeep
+│           └── value-objects/           # .gitkeep
+└── shell/angular/                       # project: museum-<name>-shell-angular
+    └── src/
+        ├── index.ts                     # public barrel (pages + module [+ service])
+        └── lib/
+            ├── <name>.module.ts         # Museum<Name>Module (references/module-and-routes.md)
+            ├── <name>.routes.ts
+            ├── index.ts                 # SERVICES const + barrel (see below)
+            ├── +state/                  # ONLY if the module keeps feature state: <name>.reducer.ts
+            ├── pages/                   # list (ListComponent), item (ItemComponent) + index (PAGES)
+            └── services/                # optional module service (e.g. a visit logger)
+```
+
+## Domain entity (thin subclass of the npm `Article`)
+
+`domain/src/lib/entities/museum-<name>.entity.ts`:
+
+```ts
+import { Model } from '@smartsoft001/models';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+
+@Model({})
+export class Museum<Name> extends Article {}
+```
+
+Then `entities/index.ts` re-exports it and `domain/src/index.ts` does `export * from './lib/entities';`.
+(If the module needs extra fields, add them to this subclass.)
+
+## shell `lib/index.ts` — `SERVICES` + barrel
+
+Define a `SERVICES` const here binding `ArticlesService` as the `CrudService`; a module that keeps
+feature state spreads it into its providers:
+
+```ts
+import { CrudService } from '@smartsoft001/crud-shell-angular';
+import { ArticlesService } from '@smartsoft001-mobilems/articles-shell-angular';
+
+export * from './pages/index';
+export * from './<name>.module';
+
+export const SERVICES = [
+  ArticlesService,
+  { provide: CrudService, useClass: ArticlesService },
+];
+```
+
+## shell `src/index.ts` (public barrel)
+
+`export * from './lib/pages';` + `export * from './lib/<name>.module';` (plus the module's own service
+if it ships one — see below).
+
+## `pages/index.ts`
+
+```ts
+import { ItemComponent } from './item/item.component';
+import { ListComponent } from './list/list.component';
+
+export * from './item/item.component';
+export * from './list/list.component';
+
+export const PAGES = [ListComponent, ItemComponent];
+```
+
+Copy the `list/` and `item/` `.component.ts` + `.html` from a reference article module, threading
+`<PREFIX>`.
+
+## Optional: `+state/<name>.reducer.ts` (feature-local ngrx state)
+
+Build this only if the module keeps its own ngrx state (Step 1 "feature state? = yes"). It wraps the
+smart CRUD reducer keyed by the module's `<entity>`:
+
+```ts
+import { Action } from '@ngrx/store';
+import {
+  State as SmartState,
+  initialState as smartInitialState,
+  getReducer as smartGetReducer,
+} from '@smartsoft001/crud-shell-angular';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+
+export type State = SmartState<Article>;
+
+export const initialState = { ...smartInitialState };
+
+const reducer = (state = initialState, action: any) => {
+  switch (action.type) {
+    default:
+      return smartGetReducer('<entity>')(state, action);
+  }
+};
+
+export function getReducer() {
+  return (state: any, action: Action) => reducer(state, action);
+}
+```
+
+The module then passes `reducerFactory: getReducer` to `forFeature` (see
+`references/module-and-routes.md`). A module without feature state omits `+state/` entirely.
+
+## Optional: a module service
+
+A module may ship a small injectable (for example, a visit logger). Copy it from the reference module
+if it has one, threading `<PREFIX>`, and export it from `src/index.ts`:
+
+```ts
+import { HttpClient } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+
+import { environment } from '@<PREFIX>/angular';
+
+@Injectable({ providedIn: 'root' })
+export class Museum<Name>Service {
+  private http = inject(HttpClient);
+
+  logVisit(id: string | number): Promise<void> {
+    const url = environment.apiUrl + 'api/article/' + id + '/visit';
+    return firstValueFrom(this.http.post<void>(url, {}));
+  }
+}
+```
+
+> **Watch for cross-module service imports.** In the reference, some article modules' pages inject
+> _another_ article module's service (e.g. a `news` page importing `MuseumArticlesService` from
+> `@<ref-prefix>/museum-articles/shell/angular`). A generic article module must be self-contained — when
+> a copied page injects a sibling module's service, give this module its **own** `Museum<Name>Service`
+> (the template above) and rewire the page's import to it, rather than depending on a module that may
+> not exist in the target.
+
+## Wiring
+
+- **tsconfig.base.json paths** (add both):
+  ```json
+  "@<PREFIX>/museum-<name>/domain": ["libs/museum-<name>/domain/src/index.ts"],
+  "@<PREFIX>/museum-<name>/shell/angular": ["libs/museum-<name>/shell/angular/src/index.ts"]
+  ```
+- **project.json / build config** — copy each project's build config and normalize every path field
+  the reference baked to its origin location — `sourceRoot`, `dest`, `outputPath`, `coverageDirectory`,
+  `jestConfig`, `lintFilePatterns`, and the jest `displayName` — to `libs/museum-<name>/...`. Some reference modules carry
+  stale values (e.g. a `sourceRoot` missing the `shell/angular` segment, or a `coverageDirectory`
+  under `packages/...`) while others are already correct — verify each against a known-good sibling and
+  fix only the stale ones. Set each `package.json` `name` to match (`museum-<name>-domain` /
+  `museum-<name>-shell-angular`) — a copied `package.json` may carry a stale name. A `domain` with no
+  `project.json` (Nx-inferred) is fine.
+- **commit scope** — `commitlint.config.js` reads `libs/` dir names, so `museum-<name>` becomes a valid
+  scope automatically; no edit needed.
+- **jest** — keep the reference `jest.config.ts` / `tsconfig.spec.json` so the shell unit-tests run.

package/plugins/mobilems/skills/mobilems-articles/references/module-and-routes.md

@@ -0,0 +1,146 @@
+# `Museum<Name>Module` + route registration
+
+An article module wraps `ArticlesSharedModule.forFeature` over the npm `Article` entity and filters
+its API requests with a `template` value. Thread `<PREFIX>` (the `environment` import) and the chosen
+`<name>` / `<entity>` / `<template>`. The `Masonry` factory returns the real library in the browser
+and a no-op mock during SSR. Copy the file structure from an existing article module in the reference
+MobilEMS app and substitute the parameters.
+
+## `libs/museum-<name>/shell/angular/src/lib/<name>.module.ts`
+
+```ts
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { SharedModule as SmartSharedModule } from '@smartsoft001/angular';
+import { Article } from '@smartsoft001-mobilems/articles-domain';
+import { ArticlesSharedModule } from '@smartsoft001-mobilems/articles-shell-angular';
+import { Masonry } from '@thisissoon/angular-masonry';
+
+import { environment } from '@<PREFIX>/angular';
+
+import { routes } from './<name>.routes';
+
+@NgModule({
+  providers: [
+    {
+      provide: Masonry,
+      useFactory: () => {
+        if (typeof window !== 'undefined' && (window as any)['Masonry']) {
+          return (window as any)['Masonry'];
+        }
+        // Return a mock for SSR
+        return class {
+          constructor() {
+            // no-op
+          }
+          layout() { return; }
+          reloadItems() { return; }
+          destroy() { return; }
+        };
+      },
+    },
+  ],
+  imports: [
+    FormsModule,
+    SmartSharedModule,
+    ArticlesSharedModule.forFeature({
+      routing: false,
+      config: {
+        type: Article,
+        apiUrl: environment.apiUrl,
+        entity: '<entity>',
+        baseQuery: [
+          { value: '<template>', key: 'template', type: '=', hidden: true },
+        ],
+      },
+    }),
+    RouterModule.forChild(routes),
+  ],
+})
+export class Museum<Name>Module {}
+```
+
+The **`baseQuery`** is what scopes the module to its content: `key` is always `'template'`, `type` is
+`'='`, `hidden` is `true`, and `value` is the module's `<template>` (the API then returns only records
+matching that template). Change only the `value` between modules.
+
+### Optional: feature-local ngrx state
+
+If the module keeps its own ngrx state, build `+state/<name>.reducer.ts` (see
+`references/lib-contents.md`) exporting a `getReducer`, then in the module:
+
+- pass `reducerFactory: getReducer` inside the `forFeature` `config`,
+- define a `SERVICES` const in `lib/index.ts` that binds `ArticlesService` as the `CrudService`, and
+  spread it into the `providers` (alongside the `Masonry` provider).
+
+(In the reference, the stateful article module also omits `SmartSharedModule` from its `imports` and
+imports `ConfigsModule` from `@<PREFIX>/angular` — mirror whichever the reference module you copy
+uses.) A module with no feature state omits `+state/` and the `reducerFactory` entirely.
+
+## `<name>.routes.ts`
+
+```ts
+import { Route } from '@angular/router';
+
+import { ItemComponent, ListComponent } from './pages';
+
+export const routes: Route[] = [
+  { path: ':id/:slug', component: ItemComponent },
+  { path: ':id', component: ItemComponent },
+  { path: '', component: ListComponent },
+];
+```
+
+## Register in `apps/web/src/app/app.routes.ts`
+
+Add the module's `<route>` to the `appRoutes` array (idempotently — if a `<route>` route already
+exists, skip). Add it as a top-level route, and — if the module's results belong in site search — as a
+child of the `wyszukaj/:text` route so `/wyszukaj/:text/<route>` works.
+
+Top-level — add to `appRoutes`:
+
+```ts
+  {
+    path: '<route>',
+    loadChildren: () =>
+      import('@<PREFIX>/museum-<name>/shell/angular').then(
+        (m) => m.Museum<Name>Module,
+      ),
+  },
+```
+
+Search child — add to the `children` of the `wyszukaj/:text` route, before the
+`{ path: '', redirectTo: ... }` default:
+
+```ts
+          {
+            path: '<route>',
+            loadChildren: () =>
+              import('@<PREFIX>/museum-<name>/shell/angular').then(
+                (m) => m.Museum<Name>Module,
+              ),
+          },
+```
+
+## The `/article-preview` page (build once)
+
+The app's content-preview page (`apps/web/src/app/article-preview/`) renders an `Article` for CMS
+preview mode, so it imports `@smartsoft001-mobilems/articles-domain` and belongs to the articles
+feature — the foundation deliberately leaves it out. Build it the first time an article module is
+added, and skip it if it already exists (idempotent across article-module runs):
+
+1. Copy `apps/web/src/app/article-preview/` (`.component.ts` + `.html`) from the reference app, thread
+   `<PREFIX>`.
+2. Add its route to `appRoutes` in `apps/web/src/app/app.routes.ts` (a plain top-level route, before
+   the `**` catch-all):
+
+```ts
+  {
+    path: 'article-preview',
+    loadComponent: () =>
+      import('./article-preview/article-preview.component').then(
+        (m) => m.ArticlePreviewComponent,
+      ),
+  },
+```

package/plugins/mobilems/skills/mobilems-articles/references/shared-components.md

@@ -0,0 +1,56 @@
+# Article module shared components
+
+An article module renders its records as cards in the grid view and rows in the list view, so it
+contributes a pair of shared components to `libs/shared/angular` named after the module. Build them by
+copying the card components of an existing article module in the reference MobilEMS app and adapting
+them to the module's `<name>` and `<PREFIX>`. Every step is idempotent — if the target already exists,
+leave it.
+
+All paths below are under `libs/shared/angular/src/lib`.
+
+## Article card components — build + export
+
+Build these two component directories and export them from `components/index.ts`:
+
+| Component                     | Renders                          |
+| ----------------------------- | -------------------------------- |
+| `components/<name>-grid-item` | an article card in the grid view |
+| `components/<name>-list-item` | an article row in the list view  |
+
+```ts
+// components/index.ts — these exports belong to the <name> module:
+export * from './<name>-grid-item';
+export * from './<name>-list-item';
+```
+
+These render an `Article` (via the foundation's generic `IArticle` model), so they depend on
+`@smartsoft001-mobilems/articles-domain` — which this skill installs. There is no module-specific
+model type to add (contrast `mobilems-objects`, which adds `ISpecificObject` to `objects.model.ts`).
+
+## Optional: article gallery widget
+
+If the project renders **article-gallery content blocks** (a page widget that embeds a gallery of
+articles), build the article gallery widget once and register it in the widget content-type map. This
+is shared by all article modules — build it the first time an article module needs it, and skip if a
+previous article module already added it.
+
+```ts
+// components/widget/index.ts:
+export * from './gallery-article/widget-gallery-article.component';
+```
+
+Register it in the widget content-type map in `components/widget/widget.component.ts`:
+
+```ts
+import { WidgetGalleryArticleComponent } from './gallery-article/widget-gallery-article.component';
+// …in the ArticleWidgetType → component map:
+[ArticleWidgetType.GALLERY_ARTICLE]: WidgetGalleryArticleComponent,
+```
+
+The widget container renders sub-widgets via `NgComponentOutlet`, so the gallery widget goes in the
+type-map only — it does **not** go in the container's `imports` array.
+
+## Verify
+
+`scripts/verify-module.sh <workspace> <PREFIX> <name>` checks the module's `<name>-grid-item` and
+`<name>-list-item` exist and are exported from the components barrel.

package/plugins/mobilems/skills/mobilems-articles/scripts/detect-init.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+#
+# detect-init.sh <workspace-root>
+#
+# Precondition gate for mobilems-objects (and the other module skills follow the same shape):
+# confirm the MobilEMS foundation from mobilems-project-init is present.
+#
+# Exit 0 → foundation present, OK to add the module.
+# Exit 3 → foundation missing (tell the user to run /mobilems:project-init first).
+set -eu
+
+ROOT="${1:?usage: detect-init.sh <workspace-root>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+miss() {
+  echo "FOUNDATION MISSING: $1" >&2
+  echo "Run /mobilems:project-init first to lay down the MobilEMS foundation." >&2
+  exit 3
+}
+
+[ -f apps/web/src/app/app.config.ts ] || miss "app.config.ts missing"
+grep -q "SharedModule.forRoot" apps/web/src/app/app.config.ts || miss "SharedModule.forRoot not in app.config.ts (foundation not applied)"
+grep -q "./lib/components" libs/shared/angular/src/index.ts 2>/dev/null || miss "shared-lib components barrel not populated"
+[ -f apps/web/src/app/app.routes.ts ] || miss "app.routes.ts missing"
+
+PREFIX="$(grep -oE '@[a-z0-9-]+/angular' tsconfig.base.json | head -1 | sed -E 's#@([a-z0-9-]+)/angular#\1#')"
+echo "FOUNDATION OK. Detected prefix: ${PREFIX:-<unknown>}"
+[ -d libs/museum-objects ] && echo "NOTE: libs/museum-objects already exists — build steps must be idempotent." >&2
+exit 0

package/plugins/mobilems/skills/mobilems-articles/scripts/verify-module.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+#
+# verify-module.sh <workspace-root> <PREFIX> <name> [template]
+#
+# Post-condition check for one article module named <name>: library created, ArticlesSharedModule
+# .forFeature wired (with the template value if given), route registered, and the module's article
+# card shared components built + exported.
+set -eu
+
+ROOT="${1:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+PREFIX="${2:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+NAME="${3:?usage: verify-module.sh <workspace-root> <PREFIX> <name> [template]}"
+TEMPLATE="${4:-}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+LIBF="museum-$NAME"
+fail=0
+pass() { echo "  PASS: $1"; }
+bad()  { echo "  FAIL: $1" >&2; fail=1; }
+info() { echo "  INFO: $1"; }
+
+echo "== Verifying article module: name=$NAME lib=$LIBF =="
+
+echo "== Library =="
+MOD="$(ls libs/$LIBF/shell/angular/src/lib/*.module.ts 2>/dev/null | head -1)"
+[ -n "$MOD" ] && pass "module file present ($MOD)" || bad "no *.module.ts in libs/$LIBF/shell/angular/src/lib"
+[ -f "libs/$LIBF/domain/src/lib/entities/index.ts" ] && pass "domain entity present" || bad "domain entity missing"
+grep -q "$LIBF/shell/angular" tsconfig.base.json && pass "tsconfig shell path added" || bad "tsconfig.base.json shell path missing"
+grep -q "$LIBF/domain" tsconfig.base.json && pass "tsconfig domain path added" || bad "tsconfig.base.json domain path missing"
+
+echo "== forFeature wiring =="
+if [ -n "$MOD" ]; then
+  grep -q "ArticlesSharedModule.forFeature" "$MOD" && pass "ArticlesSharedModule.forFeature wired" || bad "ArticlesSharedModule.forFeature missing"
+  grep -q "key: 'template'" "$MOD" && pass "baseQuery filters on key 'template'" || bad "baseQuery key 'template' missing"
+  if [ -n "$TEMPLATE" ]; then
+    grep -q "$TEMPLATE" "$MOD" && pass "template value '$TEMPLATE' present" || bad "template value '$TEMPLATE' missing"
+  fi
+  grep -q "reducerFactory" "$MOD" && info "module keeps feature state (reducerFactory present)" || info "module has no feature state"
+fi
+
+echo "== Route registration =="
+ROUTES=apps/web/src/app/app.routes.ts
+n=$(grep -c "$LIBF/shell/angular" "$ROUTES" 2>/dev/null || true)
+[ "${n:-0}" -ge 1 ] && pass "route registered ($n occurrence(s) — top-level$([ "${n:-0}" -ge 2 ] && echo ' + search child'))" || bad "route not in app.routes.ts"
+
+echo "== Article card shared components =="
+COMP=libs/shared/angular/src/lib/components
+for d in "$NAME-grid-item" "$NAME-list-item"; do
+  [ -d "$COMP/$d" ] && pass "built $d" || bad "missing $COMP/$d"
+done
+grep -q "$NAME-grid-item" "$COMP/index.ts" && pass "$NAME-grid-item exported" || bad "$NAME-grid-item export missing"
+grep -q "$NAME-list-item" "$COMP/index.ts" && pass "$NAME-list-item exported" || bad "$NAME-list-item export missing"
+
+echo "== Deps =="
+for p in articles-domain articles-shell-angular articles-shell-dtos; do
+  grep -q "@smartsoft001-mobilems/$p" package.json && pass "$p dep" || bad "$p dep missing"
+done
+
+echo
+if [ "$fail" = 0 ]; then echo "VERIFY: all checks passed."; else echo "VERIFY: FAILED — fix the items above and re-run." >&2; fi
+exit "$fail"

package/plugins/mobilems/skills/mobilems-docs-reader/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: mobilems-docs-reader
+description: Answer questions about the MuzaCMS / MobileMS indexer API by reading a freshly-fetched OpenAPI spec. Use whenever the user asks about endpoints, request/response shapes, status codes, auth, or behavior of the indexer API (host develop-indexer-api.mobilems.pl). Read-only — never fabricates endpoints.
+allowed-tools:
+  - Bash
+  - Read
+  - Glob
+  - Grep
+---
+
+You answer questions about the **MuzaCMS / MobileMS indexer API** strictly from the OpenAPI (Swagger 2.0) specification. You never invent endpoints, schemas, or status codes — if it is not in the spec, you say so plainly.
+
+The spec is **not bundled**. It is fetched from the live MuzaCMS instance by a refresh script that lives next to this skill, using credentials supplied via environment variables. The script caches the fetched spec per Claude Code session (with an 8-hour TTL safety net), so it may skip the actual network call and reuse a cached copy on follow-up invocations within the same session.
+
+## Step 1 — Run the refresh script (mandatory)
+
+On every invocation, run the refresh script via Bash. The script itself decides whether to actually fetch — it owns the cache. Your job is only to run it and react to the result. A successful run may be either:
+
+- A real fetch (`Refreshing MuzaCMS API spec from ... → GET /admin/login → POST /admin/login → GET /docs/api → ✓ Refreshed N bytes ...`), or
+- A cache hit (`✓ spec cached for this Claude Code session (refreshed N min ago at ...), skipping fetch`).
+
+Both are exit-code-0 successes. Treat them identically and proceed to Step 2. **Do not** attempt to bypass the cache, delete the cache file, or force a refetch — the cache is intentional and the script's decision is authoritative.
+
+### Invocation
+
+The refresh script is shipped under `plugins/mobilems/scripts/`. Invoke it through `bash` so the executable bit is irrelevant:
+
+```
+bash ./node_modules/@smartsoft001-mobilems/claude-plugins/plugins/mobilems/scripts/refresh-mobilems-api-spec.sh --quiet
+```
+
+Outcomes:
+
+- **Success (exit 0)** → jump to Step 2.
+- **Script-level error** (missing env vars, missing tooling, auth rejected, HTTP error, parse failure, etc.) → jump to the matching Fail mode below.
+- **Permission denied by Claude Code** → jump to "Fail mode — permission denied".
+
+The script reads two environment variables — `MOBILEMS_LOGIN` and `MOBILEMS_PASSWORD` — performs the Symfony CSRF + session login against `https://develop-indexer.mobilems.pl`, fetches `/docs/api`, and writes the spec to `shared-assets/mobilems-api.json` inside the installed package. It also auto-loads `.env` from the current working directory; no shell sourcing is needed.
+
+### Fail mode — permission denied by Claude Code
+
+If the Bash call is rejected by Claude Code's permission system, stop and tell the user verbatim:
+
+> The MuzaCMS spec could not be refreshed because Claude Code denied permission to run the refresh script. To allow it, add this entry to your project's `.claude/settings.json` (committed) or `.claude/settings.local.json` (per-dev, gitignored) under `permissions.allow`, then ask again:
+>
+> - `"Bash(bash ./node_modules/@smartsoft001-mobilems/claude-plugins/plugins/mobilems/scripts/refresh-mobilems-api-spec.sh:*)"`
+
+Do not attempt to answer the user's question from training knowledge. Do not invent alternative invocation patterns to try to bypass the denial.
+
+### Fail mode — missing env vars
+
+If the script exits non-zero with a message starting `✗ Brak wymaganych zmiennych środowiskowych` (or English equivalent listing `MOBILEMS_LOGIN` / `MOBILEMS_PASSWORD`), **stop immediately**. Relay the script's message verbatim to the user.
+
+Do not attempt to answer the user's question from training knowledge. Do not guess. Do not read any pre-existing `mobilems-api.json` that may be lying around in `node_modules/` — without a successful refresh you have no confirmation it is current.
+
+### Fail mode — missing tooling
+
+If the script exits with a message about missing `curl` or `jq`, relay it verbatim. The script tells the user exactly how to install the missing dependency (`brew install jq` / `apt install jq`).
+
+### Fail mode — other script failures
+
+If the script fails for any other reason (HTTP error, auth rejected, parse failure), report the exact error message from the script back to the user and stop. Do not answer the API question.
+
+## Step 2 — Locate the freshly-written spec
+
+Use `Glob` with this pattern:
+
+```
+**/claude-plugins/**/shared-assets/mobilems-api.json
+```
+
+The hit lives under `node_modules/@smartsoft001-mobilems/claude-plugins/shared-assets/` after a successful refresh. Exclude `dist/` and `tmp/` from the Glob, but **do** allow `node_modules/`.
+
+If the Glob returns nothing after the refresh script reported success, something is wrong with the install layout — tell the user and stop.
+
+## Step 3 — Answer from the spec
+
+The spec is **Swagger 2.0** with this wrapping shape:
+
+```
+{ "spec": { "swagger": "2.0", "paths": {...}, "definitions": {...} } }
+```
+
+Always traverse into `.spec` first.
+
+When the user asks about endpoints:
+
+1. **Locate the path** in `spec.paths`. Look for the exact path the user mentioned, including any path parameters (`{id}`).
+2. **Quote the HTTP method(s) and path verbatim.** Example: `GET /api/objects/{id}`.
+3. For request bodies and responses, cite the `$ref` target by name and (briefly) summarize its shape from `spec.definitions`.
+4. For status codes, list each documented response from `responses` with its `description`.
+5. For auth, check both the operation-level `security` and the global `spec.securityDefinitions`.
+
+If the user asks about a path that is **not in the spec**, say so explicitly:
+
+> The spec does not document a `DELETE /api/articles/{id}` endpoint. The articles paths in the spec are: `[list actual paths]`. If you've seen this endpoint elsewhere, it may exist in the running service without being documented — verify with a live request.
+
+## Known caveats — always surface when relevant
+
+- **Response schemas occasionally diverge from runtime.** Documented response shapes have, in practice, not always matched what the live API actually returns. When the user is about to implement against a response schema, add a brief reminder to verify with a real request before relying on the documented shape.
+- **Spec is regenerated server-side from PHP annotations.** Newly added endpoints in the live service may not appear until the next backend deployment, even with a fresh fetch.
+- **Auth flow nuance:** the spec describes the indexer API itself; the `/admin/login` flow used by the refresh script is separate and not documented in the spec.
+
+## Answering style
+
+- Be terse. The user wants a specific fact, not a tutorial on Swagger.
+- Always include exact path + method + relevant status codes when applicable.
+- When quoting definitions, use the schema name (e.g., `Object`, `Unauthorised`) as it appears in `spec.definitions`.
+- If multiple endpoints match a vague question, list them — don't pick one arbitrarily.
+
+## When NOT to use this skill
+
+- Non-MobileMS APIs (any other host).
+- Generic REST/OpenAPI guidance unrelated to the indexer.
+- Schema design decisions ("should I add X field?") — this skill only describes what exists.
+- Anything requiring a live network call to the API itself.

package/plugins/mobilems/skills/mobilems-events/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: mobilems-events
+description: Add the museum EVENTS feature module (wydarzenia) to a MobilEMS app initialized with mobilems-project-init. Use whenever the user wants to add / scaffold / wire the events module, the "wydarzenia" pages (event list + event detail + booking/reservation flow with confirm + cancel), event booking, event reservation, an event calendar / available-dates picker, or asks to "dodaj moduł wydarzeń / rezerwacji wydarzeń". Creates libs/museum-events (shell/angular only — a standalone booking module), registers the /wydarzenia route, and confirms the foundation packages it reuses are present. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS events module
+
+Add the **events** (wydarzenia) feature module to a MobilEMS app whose foundation was built by
+`mobilems-project-init`. Events is a self-contained booking / reservation system: a list of events,
+an event detail page, and a reservation flow (booking form -> confirmation -> cancellation) driven by
+its own `EventsReservationService` over the event / event-periods / event-reservations API. This
+skill builds the `libs/museum-events` library and registers a single top-level `/wydarzenia` route.
+
+Events has a leaner shape than the other feature modules: a pure `RouterModule.forChild` module with
+**lazy `loadComponent` routes** and **no shared-module `forFeature`**, and it ships **only a
+`shell/angular` project** (there is no `domain` library). All of its UI and data access live inside
+its own `shell/angular`.
+
+## Precondition
+
+Run `scripts/detect-init.sh <workspace-root>`. It confirms the MobilEMS foundation is present
+(`SharedModule.forRoot` in `app.config.ts`, a populated shared-lib barrel). If not, tell the user to
+run `/mobilems:project-init` first. Hold `<PREFIX>` (from `tsconfig.base.json`; the reference
+MobilEMS app uses `@msr`) and the reference repo path (same one init used).
+
+## Steps
+
+1. **npm deps (precondition check)** — events imports only foundation packages:
+   `@smartsoft001-mobilems/angular`, `@smartsoft001-mobilems/models`, `@smartsoft001/angular`,
+   `@thisissoon/angular-masonry`, and `@ngx-translate/core` — all already installed by
+   `mobilems-project-init`. So this step is a CHECK: confirm those lines are in `package.json`; there
+   is nothing new to add. As a safeguard, grep the copied lib for any third-party import not in that
+   foundation set and add only what is genuinely missing. Do not `npm install` unless asked.
+2. **Library** — create `libs/museum-events/shell/angular` per `references/lib-contents.md`: copy the
+   shell (`MuseumEventsModule`, `events.routes.ts`, `pages/{list,item,booking,confirm,cancel}`,
+   `services/events-reservation.service.ts`, `models/events.models.ts`, `pipes/time-format.pipe.ts`,
+   and the `src/__mocks__/@smartsoft001-mobilems/{angular,models}.ts` jest mocks), thread `<PREFIX>`.
+   Add the single `tsconfig.base.json` path `@<PREFIX>/museum-events/shell/angular` and the
+   `museum-events` commit scope.
+3. **Module + routes** — see `references/module-and-routes.md`: `MuseumEventsModule` is just
+   `@NgModule({ imports: [RouterModule.forChild(eventsRoutes)] })`; `eventsRoutes` uses lazy
+   `loadComponent` for every page and provides the `Masonry` SSR factory on the list route. Add the
+   lazy `wydarzenia` route to the `appRoutes` array in `apps/web/src/app/app.routes.ts` as a single
+   top-level route.
+4. **Verify** — run `scripts/verify-module.sh <workspace-root> <PREFIX>`: asserts the
+   `libs/museum-events/shell/angular` lib exists with `MuseumEventsModule` (`RouterModule.forChild`)
+   and `events.routes.ts`, the `@<PREFIX>/museum-events/shell/angular` tsconfig path is added, the
+   five pages + `EventsReservationService` + `events.models.ts` + `TimeFormatPipe` are present, the
+   `wydarzenia` route is registered as a single top-level route, and the foundation deps it reuses are
+   in `package.json`. Fix and re-run.
+
+## Notes
+
+- Events is a standalone booking module: it owns its data access (`EventsReservationService` calling
+  the events API) and contributes **nothing** to `libs/shared/angular`. The shared lib stays
+  untouched.
+- Events ships **only** a `shell/angular` project — there is no `domain` library and no shared-module
+  `forFeature`; its event/reservation types live in `shell/angular/src/lib/models/events.models.ts`.
+- `/wydarzenia` is a top-level route only. Events is a booking destination, not a search result, so it
+  is NOT added under the `wyszukaj/:text` search children.
+- This skill ONLY touches the events module + its route. It never adds other feature modules, never
+  re-runs the foundation, and never edits `libs/shared/angular`.
+- Bundled `references/` + `scripts/` ship automatically. Do not hand-edit `plugin.json`.