crewly 1.8.4 → 1.8.5

package/config/skills/orchestrator/wiki-process-queue/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: Wiki Process Queue
+description: Claim the next pending wiki-queue item and get the vault context your LLM needs to classify it into llm-curated/<folder>/<page>.md. No preset taxonomy — your LLM picks the target.
+version: 1.0.0
+category: knowledge
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+---
+
+# Wiki Process Queue
+
+Claim the next pending queue item and get back the vault state your runtime's LLM should classify against. **This skill does not call an LLM.** It returns the structured context; your runtime concatenates with the per-LLM task-instruction prompt and synthesizes a target page.
+
+## After this skill returns, YOUR runtime MUST:
+
+1. Read `result.item.content` + `result.item.reason` (the agent who queued it justified why).
+2. Read `result.vaultContext` (SCHEMA, frozen paths, recent log, candidate pages).
+3. Use your LLM to pick a target. Options:
+   - **Merge** into an existing `result.vaultContext.candidatePages[i].path` — preferred if a candidate fits.
+   - **Create** a new page under `llm-curated/<freshly-invented-subfolder>/<slug>.md`. You may invent subfolder names; there is NO preset taxonomy.
+   - **Skip** if you decide the item isn't wiki-worthy after all.
+4. Commit:
+   - To write: call `wiki-ingest` with `--vault`, `--source-type`, `--source-ref`, `--source-body`, and `--target <relative-path>`.
+   - Then POST `/api/wiki/queue/<id>/process` with `{ingested:true, pagesWritten:[…], targetPath:'…', summary:'…'}`.
+   - To skip: POST `/api/wiki/queue/<id>/skip` with `{skipReason:'…'}`.
+
+## Hard rules your LLM must honor
+
+- **NEVER target a frozen folder** (`result.vaultContext.schemaSummary.frozenPaths`). The ingest call will reject these with HTTP 422.
+- **PREFER merging into an existing page** over creating a new one. Only create new when nothing fits.
+- **DO NOT re-justify wiki-worthiness** — the agent who queued the item already did (`result.item.reason`). Your job is classification, not gatekeeping. The exception is skip: if context reveals the item is a duplicate / low signal, skip with a `skipReason`.
+
+## Inputs
+
+| Flag | Required | Description |
+|---|---|---|
+| `--claimed-by <session>` | yes | Your agent session name. Defaults to `$CREWLY_SESSION_NAME` or `crewly-orc`. |
+| `--vault <path>` | no | Filter to a specific vault. Default: any vault with pending items. |
+| `--offset <n>` | no | Skip the first N pending items. Useful for retry after a skip. |
+| `--top-k <n>` | no | How many candidate pages to surface (default 5). |
+| `--recent-log <n>` | no | How many tail log entries to include (default 10). |
+
+## Output
+
+```json
+{
+  "success": true,
+  "result": {
+    "item": { "id": "uuid", "content": "...", "reason": "...", "status": "claimed", ... },
+    "vaultContext": {
+      "vault": { "scope": "project", "id": "crewly", "path": "..." },
+      "schemaSummary": { "hardcoded": [...], "llmCurated": [...], "frozenPaths": ["memory/", "sop-overrides/"], "writePolicy": {...} },
+      "recentLog": [...],
+      "candidatePages": [{"path": "llm-curated/customers/anthropic.md", "score": 9, "excerpt": "..."}],
+      "callerNotes": ["Cite pages by path.", "Refuse writes into frozenPaths.", ...]
+    },
+    "classifierNotes": [
+      "You have ALREADY decided this item is wiki-worthy at queue-add time...",
+      "Pick the target page path under llm-curated/...",
+      ...
+    ]
+  }
+}
+```
+
+## Failure modes
+
+- `404 no_pending_items` — queue is empty (for the filter you provided). Not an error; nothing to do this turn.
+- `400 claimedBy is required` — every claim is owned by a session for audit.

package/config/skills/orchestrator/wiki-process-queue/execute.sh

@@ -0,0 +1,93 @@
+#!/bin/bash
+# wiki-process-queue — claim the next pending wiki item + return the
+# system-context your runtime should classify it against.
+#
+# This skill does NOT call an LLM. It returns the queue item + the
+# vault's current state (SCHEMA, frozen paths, recent log, candidate
+# pages by keyword overlap). Your runtime concatenates with the per-LLM
+# task-instruction prompt at prompts/<runtime>.md and synthesizes a
+# target path. After the LLM picks a target you (the agent) MUST:
+#
+#   1. POST /api/wiki/ingest with { vaultPath, targetRelativePath, ... }
+#   2. POST /api/wiki/queue/<id>/process with { ingested, pagesWritten,
+#      targetPath, summary }
+#   …OR…
+#   3. POST /api/wiki/queue/<id>/skip with { skipReason } if you decided
+#      the item isn't actually wiki-worthy after seeing the vault context.
+#
+# Usage:
+#   bash execute.sh --claimed-by <session>
+#   bash execute.sh --claimed-by <session> --vault /path --top-k 5
+#   bash execute.sh --json '{"claimedBy":"crewly-orc","vaultPath":"/path"}'
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT_JSON=""
+CLAIMED_BY=""
+VAULT_PATH=""
+OFFSET=""
+TOP_K=""
+RECENT_LOG=""
+
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --claimed-by|-b) CLAIMED_BY="$2"; shift 2 ;;
+    --vault|-v)      VAULT_PATH="$2"; shift 2 ;;
+    --offset|-o)     OFFSET="$2";     shift 2 ;;
+    --top-k|-k)      TOP_K="$2";      shift 2 ;;
+    --recent-log|-r) RECENT_LOG="$2"; shift 2 ;;
+    --json|-j)       INPUT_JSON="$2"; shift 2 ;;
+    --help|-h)
+      cat <<EOF
+Usage:
+  execute.sh --claimed-by <session> [--vault <path>] [--offset N] [--top-k 5] [--recent-log 10]
+  execute.sh --json '{"claimedBy":"crewly-orc","vaultPath":"...","offset":0}'
+
+Claims the next pending queue item AND returns the vault context for
+your runtime's LLM to classify. After the LLM picks a target, call:
+  - /api/wiki/ingest         (write the page)
+  - /api/wiki/queue/<id>/process  (mark this item processed)
+…or:
+  - /api/wiki/queue/<id>/skip     (mark not-wiki-worthy after all)
+EOF
+      exit 0 ;;
+    --) shift; break ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then INPUT_JSON="$1"; shift
+      else error_exit "Unknown argument: $1"; fi ;;
+  esac
+done
+
+if [ -z "$INPUT_JSON" ] && [ -z "$CLAIMED_BY" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then INPUT_JSON="$STDIN_DATA"; fi
+fi
+
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$CLAIMED_BY" ] && CLAIMED_BY=$(printf '%s' "$INPUT" | jq -r '.claimedBy        // empty')
+  [ -z "$VAULT_PATH" ] && VAULT_PATH=$(printf '%s' "$INPUT" | jq -r '.vaultPath        // empty')
+  [ -z "$OFFSET" ]     && OFFSET=$(printf     '%s' "$INPUT" | jq -r '.offset           // empty')
+  [ -z "$TOP_K" ]      && TOP_K=$(printf      '%s' "$INPUT" | jq -r '.topK             // empty')
+  [ -z "$RECENT_LOG" ] && RECENT_LOG=$(printf '%s' "$INPUT" | jq -r '.recentLogEntries // empty')
+fi
+
+if [ -z "$CLAIMED_BY" ]; then
+  CLAIMED_BY="${CREWLY_SESSION_NAME:-crewly-orc}"
+fi
+
+export _WPQ_BY="$CLAIMED_BY"
+BODY=$(jq -n '{claimedBy: env._WPQ_BY}')
+[ -n "$VAULT_PATH" ] && { export _WPQ_V="$VAULT_PATH"; BODY=$(echo "$BODY" | jq '. + {vaultPath: env._WPQ_V}'); unset _WPQ_V; }
+[ -n "$OFFSET" ]     && BODY=$(echo "$BODY" | jq --argjson o "$OFFSET" '. + {offset: $o}')
+[ -n "$TOP_K" ]      && BODY=$(echo "$BODY" | jq --argjson k "$TOP_K"  '. + {topK: $k}')
+[ -n "$RECENT_LOG" ] && BODY=$(echo "$BODY" | jq --argjson n "$RECENT_LOG" '. + {recentLogEntries: $n}')
+unset _WPQ_BY
+
+api_call POST "/wiki/queue/claim-next" "$BODY"

package/config/skills/orchestrator/wiki-queue-add/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: Wiki Queue Add
+description: Enqueue wiki-worthy content (from a chat turn, spec write, PR merge, learning) for later agent-driven classification + ingest. Agents must justify with --reason.
+version: 1.0.0
+category: knowledge
+skillType: claude-skill
+assignableRoles:
+  - orchestrator
+  - team-leader
+---
+
+# Wiki Queue Add
+
+Enqueue a candidate item for the LLM-wiki. This skill **does not write** to the vault — it adds the item to a queue. A separate `wiki-process-queue` run (later, batch or bookkeep-triggered) decides whether the item is actually worth saving and where in the vault it lands.
+
+## When to use
+
+After a chat turn (yours OR a teammate's), pause briefly and ask:
+
+- Did this turn produce content with **lasting value**?
+  - a decision (pricing, scope, scheduling)
+  - a fact about a person, customer, partner
+  - a pattern that future-me would want to find
+  - a new constraint, gotcha, or learning
+- Was a fact mentioned that the team will need to look up later?
+
+If YES, call `wiki-queue-add`. **DO NOT call it for**:
+
+- Routine status checks ("standup", "?", "ok")
+- Implementation details captured in code/PRs
+- Conversation pleasantries
+- Anything already in the wiki
+
+## Required arguments
+
+| Flag | Required | Purpose |
+|---|---|---|
+| `--vault <path>` | yes | Absolute path to the vault root. |
+| `--content <text>` | yes | The text to capture. |
+| `--reason <text>` | **yes** | One sentence: WHY is this wiki-worthy? Audit + helps the processor decide where it goes. |
+| `--source-ref <ref>` | yes | Stable reference: chat msg id, slack thread, file path, WI id. |
+| `--source-type <type>` | no | Default `user_chat`. Use `slack_message`, `spec_file`, `pr_merge`, `record_learning`, `task_verified` when appropriate. |
+| `--queued-by <sess>` | no | Defaults to `$CREWLY_SESSION_NAME` or `crewly-orc`. |
+
+## Examples
+
+**A pricing decision the team should remember:**
+```bash
+bash execute.sh \
+  --vault ~/Desktop/projects/crewly-projects/crewly/.crewly/wiki \
+  --content "Anthropic SMB pilot signed at \$799/month, 12-month commit, 30-day onboarding clause" \
+  --reason "first paid SMB customer + concrete pricing validation point + new contract pattern" \
+  --source-ref "slack://D0AC7NF5N7L/1779509999.111"
+```
+
+**A learning a worker just surfaced:**
+```bash
+bash execute.sh \
+  --vault ~/.crewly/teams/ad923b66-…/wiki \
+  --content "Gemini text-embedding-004 returned 404 — deprecated. Falling back to keyword search." \
+  --reason "infra gotcha — affects every team using vector search; future-me will hit this" \
+  --source-ref "wi:6cf2d54d-…" \
+  --source-type record_learning
+```
+
+## Output
+
+```json
+{
+  "success": true,
+  "item": {
+    "id": "uuid",
+    "status": "pending",
+    "queuedAt": "2026-05-22T...",
+    "vaultPath": "...",
+    "content": "...",
+    "reason": "...",
+    ...
+  }
+}
+```
+
+The item sits in the queue until processed. Use `wiki-queue-list` to see pending items and `wiki-process-queue` to claim + classify + ingest.
+
+## Failure modes
+
+- `400 reason is required` — agents MUST justify wiki-worthiness; refusal protects future-me from low-signal noise
+- `400 content/sourceRef empty` — every queued item needs identifiable provenance
+- `400 vaultPath must be absolute` — relative paths are rejected; the vault root is part of the audit trail

package/config/skills/orchestrator/wiki-queue-add/execute.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+# wiki-queue-add — enqueue wiki-worthy content the agent just saw or said.
+#
+# Per the 2026-05-22 redesign (Steve): there's NO automatic ingest. Agents
+# decide what's worth saving as the conversation unfolds and queue it
+# explicitly. A separate `wiki-process-queue` skill (run later, batch or
+# bookkeep-triggered) classifies + writes to llm-curated/<folder>/<page>.md.
+#
+# The `--reason` is REQUIRED — agents must justify why this is wiki-worthy.
+#
+# Usage:
+#   bash execute.sh --vault /path --content "..." --reason "..." --source-ref "..."
+#   bash execute.sh --json '{"vaultPath":"...","content":"...","reason":"...","sourceRef":"...","sourceType":"user_chat"}'
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/../../_common/lib.sh"
+
+INPUT_JSON=""
+VAULT_PATH=""
+CONTENT=""
+REASON=""
+SOURCE_REF=""
+SOURCE_TYPE="user_chat"
+QUEUED_BY=""
+
+# Legacy positional JSON
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --vault|-v)        VAULT_PATH="$2";  shift 2 ;;
+    --content|-c)      CONTENT="$2";     shift 2 ;;
+    --reason|-r)       REASON="$2";      shift 2 ;;
+    --source-ref)      SOURCE_REF="$2";  shift 2 ;;
+    --source-type)     SOURCE_TYPE="$2"; shift 2 ;;
+    --queued-by)       QUEUED_BY="$2";   shift 2 ;;
+    --json|-j)         INPUT_JSON="$2";  shift 2 ;;
+    --help|-h)
+      cat <<EOF
+Usage:
+  execute.sh --vault <vault> --content "<text>" --reason "<why this matters>" --source-ref "<id|url|path>" [--source-type user_chat|slack_message|spec_file|pr_merge|record_learning|task_verified] [--queued-by <session>]
+
+Required:
+  --vault       Absolute path to the vault root.
+  --content     The text to capture (the thing future-you wants to remember).
+  --reason      WHY this is wiki-worthy. One sentence. Audit + helps the processor.
+  --source-ref  Stable reference: chat id, slack thread, file path, WI id.
+
+Optional:
+  --source-type Default: user_chat. Use slack_message for Slack inbound; spec_file
+                for written specs; pr_merge for commit-driven learnings; etc.
+  --queued-by   Session name. Defaults to \$CREWLY_SESSION_NAME or "crewly-orc".
+
+Emit a JSON {success, item} on stdout. The item has status=pending until a
+later wiki-process-queue run classifies it.
+EOF
+      exit 0 ;;
+    --) shift; break ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then INPUT_JSON="$1"; shift
+      else error_exit "Unknown argument: $1"; fi ;;
+  esac
+done
+
+# stdin JSON fallback
+if [ -z "$INPUT_JSON" ] && [ -z "$CONTENT" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then INPUT_JSON="$STDIN_DATA"
+  else CONTENT="$STDIN_DATA"; fi
+fi
+
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$VAULT_PATH" ]  && VAULT_PATH=$(printf  '%s' "$INPUT" | jq -r '.vaultPath  // empty')
+  [ -z "$CONTENT" ]     && CONTENT=$(printf     '%s' "$INPUT" | jq -r '.content    // empty')
+  [ -z "$REASON" ]      && REASON=$(printf      '%s' "$INPUT" | jq -r '.reason     // empty')
+  [ -z "$SOURCE_REF" ]  && SOURCE_REF=$(printf  '%s' "$INPUT" | jq -r '.sourceRef  // empty')
+  [ "$SOURCE_TYPE" = "user_chat" ] && {
+    TY=$(printf '%s' "$INPUT" | jq -r '.sourceType // empty'); [ -n "$TY" ] && SOURCE_TYPE="$TY"
+  }
+  [ -z "$QUEUED_BY" ]   && QUEUED_BY=$(printf   '%s' "$INPUT" | jq -r '.queuedBy   // empty')
+fi
+
+require_param "vaultPath  (--vault)"      "$VAULT_PATH"
+require_param "content    (--content)"    "$CONTENT"
+require_param "reason     (--reason)"     "$REASON"
+require_param "sourceRef  (--source-ref)" "$SOURCE_REF"
+
+# Default queuedBy: session name from env, else "crewly-orc"
+if [ -z "$QUEUED_BY" ]; then
+  QUEUED_BY="${CREWLY_SESSION_NAME:-crewly-orc}"
+fi
+
+export _WQA_VAULT="$VAULT_PATH"
+export _WQA_CONTENT="$CONTENT"
+export _WQA_REASON="$REASON"
+export _WQA_REF="$SOURCE_REF"
+export _WQA_TYPE="$SOURCE_TYPE"
+export _WQA_BY="$QUEUED_BY"
+
+BODY=$(jq -n '{
+  vaultPath:  env._WQA_VAULT,
+  queuedBy:   env._WQA_BY,
+  sourceType: env._WQA_TYPE,
+  sourceRef:  env._WQA_REF,
+  content:    env._WQA_CONTENT,
+  reason:     env._WQA_REASON
+}')
+
+unset _WQA_VAULT _WQA_CONTENT _WQA_REASON _WQA_REF _WQA_TYPE _WQA_BY
+
+api_call POST "/wiki/queue" "$BODY"

package/dist/backend/backend/src/controllers/wiki/wiki.controller.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Wiki REST Controller
+ *
+ * Exposes the LLM-wiki ingest/query operations over HTTP so the bash
+ * skills (`wiki-ingest`, `wiki-query`) and in-process subscribers
+ * (`WikiChatSubscriberService`) all funnel through the same code path.
+ *
+ * @module controllers/wiki/wiki.controller
+ */
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * POST /api/wiki/ingest
+ *
+ * Write a single source into a vault's `llm-curated/log.md` (or other
+ * non-frozen target). The handler enforces request validation; per-call
+ * routing / frozen-path / size limits live in `WikiIngestService`.
+ *
+ * Request body:
+ *   {
+ *     vaultPath: string,
+ *     sourceType: WikiSourceType,
+ *     sourceRef: string,
+ *     sourceBody: string,
+ *     callerSession?: string,
+ *     targetRelativePath?: string
+ *   }
+ *
+ * Response:
+ *   200 { success: true,  result: WikiIngestOutcome (ok=true variant) }
+ *   400 { success: false, error: string, outcome?: WikiIngestOutcome }
+ *   422 { success: false, error: 'frozen_path', outcome: WikiIngestOutcome }
+ */
+export declare function ingest(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/query
+ *
+ * Build the system-context payload for a single-vault read. The skill /
+ * caller's runtime concatenates this with its per-LLM task-instruction
+ * prompt (`config/skills/<role>/wiki-query/prompts/<runtime>.md`) before
+ * the actual LLM call.
+ *
+ * Request body:
+ *   {
+ *     vaultPath: string,
+ *     query: string,
+ *     topK?: number,
+ *     recentLogEntries?: number
+ *   }
+ *
+ * Response:
+ *   200 { success: true,  result: { context: WikiQuerySystemContext } }
+ *   400 { success: false, error: string, outcome?: failure }
+ *   404 { success: false, error: 'schema_missing', outcome }
+ */
+export declare function queryVault(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/queue
+ *
+ * Enqueue a candidate item. Agents call this when a turn produces
+ * content worth saving to the wiki. The `reason` is REQUIRED — the
+ * agent has to justify why this is wiki-worthy (audit trail + helps
+ * the processor decide where it goes).
+ */
+export declare function queueAdd(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/wiki/queue?vaultPath=…&status=…&queuedBy=…&limit=…
+ */
+export declare function queueList(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/queue/:id/claim
+ *   body: { claimedBy: string }
+ */
+export declare function queueClaim(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/queue/:id/process
+ *   body: { ingested: boolean, pagesWritten?: string[], targetPath?: string, summary?: string }
+ */
+export declare function queueProcess(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/queue/:id/skip
+ *   body: { skipReason: string }
+ */
+export declare function queueSkip(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/queue/claim-next
+ *   body: { claimedBy: string, vaultPath?: string, offset?: number, topK?: number, recentLogEntries?: number }
+ *
+ * Claims the next pending item AND returns the vault context the
+ * agent's LLM should classify against. The agent then picks a target
+ * page, calls /wiki/ingest, and commits via /queue/:id/process.
+ */
+export declare function queueClaimNext(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/bookkeep
+ *   body: { vaultPath: string, windowDays?: number, threshold?: number }
+ */
+export declare function bookkeep(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/wiki/vaults
+ *
+ * Returns the list of all known vaults (project + team + global) with
+ * stats so the UI can render a sidebar. Discovery uses the same logic
+ * the bookkeep trigger uses.
+ */
+export declare function listVaults(_req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/wiki/tree?vaultPath=...
+ *
+ * Walks the vault directory and returns the file tree. Frozen folders
+ * are marked so the UI can render them differently. SCHEMA.md is
+ * surfaced as a top-level file.
+ */
+export declare function getVaultTree(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/wiki/page?vaultPath=...&relativePath=...
+ *
+ * Returns the raw markdown content of a single page. The relativePath
+ * is validated to ensure it doesn't escape the vault directory.
+ */
+export declare function getPage(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * POST /api/wiki/bookkeep/trigger-now
+ *
+ * Force one tick of the bookkeep trigger NOW. Used for manual testing
+ * (curl, the chat UI, an admin button) — production cadence is the
+ * automatic interval scan, but operators sometimes want to invoke it
+ * synchronously to verify wiring or to clear a backlog.
+ */
+export declare function bookkeepTriggerNow(_req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * GET /api/wiki/queue/stats?vaultPath=…
+ */
+export declare function queueStats(req: Request, res: Response, next: NextFunction): Promise<void>;
+//# sourceMappingURL=wiki.controller.d.ts.map

package/dist/backend/backend/src/controllers/wiki/wiki.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiki.controller.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/controllers/wiki/wiki.controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AA+B/D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,MAAM,CAC1B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAmEf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAgDf;AAgBD;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAwDf;AAED;;GAEG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA4Bf;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAmCf;AAED;;;GAGG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAwBD;;;;;;GAMG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAmDf;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAqFf;AAQD;;;;;GAKG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAmDf;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAQf"}