@xano/cli 1.0.6-beta.7 → 1.1.0

package/dist/commands/workspace/pull/index.js

@@ -3,7 +3,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
-import { buildApiGroupFolderResolver, buildChannelServerResolver, parseDocument, resolveDocumentPath, } from '../../../utils/document-parser.js';
+import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
 import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 export default class Pull extends BaseCommand {
     static description = 'Pull a workspace multidoc from the Xano Metadata API and split into individual files';
@@ -134,19 +134,96 @@ Pulled 58 documents
         // Resolve api_group names to unique folder names, disambiguating collisions
         // where different names produce the same snakeCase (e.g., "Authentication" vs "authentication")
         const getApiGroupFolder = buildApiGroupFolderResolver(documents, snakeCase);
-        // Resolve a realtime v2 channel path -> owning realtime_server name, so
-        // messages can nest under their channel's server (see resolver docs).
-        const getChannelServer = buildChannelServerResolver(documents);
         // Track filenames per type to handle duplicates
         const filenameCounters = new Map();
         let writtenCount = 0;
         for (const doc of documents) {
-            const { baseName, typeDir } = resolveDocumentPath(doc, outputDir, {
-                getApiGroupFolder,
-                getChannelServer,
-                join: path.join,
-                snakeCase,
-            });
+            let typeDir;
+            let baseName;
+            if (doc.type === 'workspace') {
+                // workspace → workspace/{name}.xs
+                typeDir = path.join(outputDir, 'workspace');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'workspace_trigger') {
+                // workspace_trigger → workspace/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'error_trigger') {
+                // error_trigger → workspace/trigger/{name}.xs (singleton, colocated with workspace triggers)
+                typeDir = path.join(outputDir, 'workspace', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent') {
+                // agent → ai/agent/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'agent');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server') {
+                // mcp_server → ai/mcp_server/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'mcp_server');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'tool') {
+                // tool → ai/tool/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'tool');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'agent_trigger') {
+                // agent_trigger → ai/agent/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'agent', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'mcp_server_trigger') {
+                // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'ai', 'mcp_server', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'table_trigger') {
+                // table_trigger → table/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'table', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_channel') {
+                // realtime_channel → realtime/channel/{name}.xs
+                typeDir = path.join(outputDir, 'realtime', 'channel');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'realtime_trigger') {
+                // realtime_trigger → realtime/trigger/{name}.xs
+                typeDir = path.join(outputDir, 'realtime', 'trigger');
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'api_group') {
+                // api_group "test" → api/{resolved_folder}/{name}.xs
+                const groupFolder = getApiGroupFolder(doc.name);
+                typeDir = path.join(outputDir, 'api', groupFolder);
+                baseName = this.sanitizeFilename(doc.name);
+            }
+            else if (doc.type === 'query' && doc.apiGroup) {
+                // query in group "test" → api/{resolved_folder}/{query_name}.xs
+                const groupFolder = getApiGroupFolder(doc.apiGroup);
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, 'api', groupFolder, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
+            else {
+                // Default: split folder path from name
+                const nameParts = doc.name.split('/');
+                const leafName = nameParts.pop();
+                const folderParts = nameParts.map((part) => snakeCase(part));
+                typeDir = path.join(outputDir, doc.type, ...folderParts);
+                baseName = this.sanitizeFilename(leafName);
+                if (doc.verb) {
+                    baseName = `${baseName}_${doc.verb}`;
+                }
+            }
             fs.mkdirSync(typeDir, { recursive: true });
             // Track duplicates per directory
             const dirKey = path.relative(outputDir, typeDir);
@@ -175,4 +252,12 @@ Pulled 58 documents
             parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
         this.log(`Pulled ${parts.join(' + ')} to ${flags.directory}`);
     }
+    /**
+     * Sanitize a document name for use as a filename.
+     * Strips quotes, replaces spaces with underscores, and removes
+     * characters that are unsafe in filenames.
+     */
+    sanitizeFilename(name) {
+        return snakeCase(name.replaceAll('"', ''));
+    }
 }

package/dist/utils/document-parser.d.ts

@@ -1,13 +1,9 @@
 export interface ParsedDocument {
     apiGroup?: string;
     canonical?: string;
-    /** Owning channel path for realtime v2 `message` documents. */
-    channel?: string;
     content: string;
     guid?: string;
     name: string;
-    /** Owning realtime_server name for realtime v2 `channel` documents. */
-    server?: string;
     type: string;
     verb?: string;
 }
@@ -16,87 +12,6 @@ export interface ParsedDocument {
  * Skips leading comment lines (starting with //) to find the first meaningful line.
  */
 export declare function parseDocument(content: string): null | ParsedDocument;
-/**
- * Map a realtime v2 channel path onto directory segments.
- *
- * A channel name IS a path template — "rooms/{room_id}" — so the directory tree
- * mirrors it rather than flattening it. That is the whole reason messages nest
- * under channels: the tree should show the structure, and
- * "channel/rooms/[room_id]/post.xs" says immediately that `post` lives on a
- * parameterized rooms channel.
- *
- *   "rooms"                    -> ["rooms"]
- *   "rooms/{room_id}"          -> ["rooms", "[room_id]"]
- *   "org/{org_id}/room/{id}"   -> ["org", "[org_id]", "room", "[id]"]
- *
- * Braces become brackets because "{" and "}" are awkward in shells, while "["
- * and "]" are legal on every filesystem. They are still glob character classes,
- * so scripting against a checkout needs the path quoted.
- *
- * Escaping the braces rather than dropping them is what keeps a parameterized
- * channel distinct from a literal one: without it, "rooms/{room_id}" and a
- * literal channel named "rooms/room_id" collide on the same directory.
- *
- * Mirrors Vfs::channelSegment() on the server.
- */
-export declare function channelPathSegments(name: string, snakeCaseFn: (s: string) => string): string[];
-/**
- * Build a map of realtime v2 channel path -> owning realtime_server name.
- *
- * This is the cross-document lookup the on-disk nesting needs: a `message`
- * document names its channel (`channel = "..."`), while a `channel` document
- * names its server (`realtime_server = "..."`). To place a message under
- * `realtime/server/<server>/channel/<path>/...` we resolve the message's channel
- * to that channel's server — which the channel document carries. (Messages now
- * also carry `realtime_server` directly, but resolving via the channel keeps a
- * single source of truth for the channel→server mapping.)
- *
- * Because every pull path parses the WHOLE multidoc into memory before writing,
- * we can build this map from the `channel` docs in the same batch (a two-pass
- * resolve), keyed by the channel's own name (its path). A channel with no
- * `realtime_server` (e.g. a pre-server export) simply isn't in the map, and
- * callers fall back accordingly.
- */
-export declare function buildChannelServerResolver(documents: ParsedDocument[]): (channelName: string) => string | undefined;
-/**
- * Sanitize a document name for use as a single on-disk filename segment.
- * Strips quotes and snake_cases the rest. Mirrors the per-command
- * `sanitizeFilename` the pull commands used to each define privately.
- */
-export declare function sanitizeDocumentName(name: string, snakeCaseFn: (s: string) => string): string;
-/**
- * The directory + base filename (no extension, no duplicate suffix) a document
- * is written to on disk. `resolveDocumentPath` returns this; callers append the
- * `.xs` extension and any `_N` duplicate suffix.
- */
-export interface DocumentPlacement {
-    baseName: string;
-    typeDir: string;
-}
-/**
- * Resolve where a parsed document lands on disk — the SINGLE source of truth for
- * the pull layout, shared by every pull command (workspace, tenant, release,
- * sandbox, ephemeral). Previously each command inlined a ~130-line copy of this
- * decision; the copies drifted (the realtime v2 realtime_server/channel/message
- * branches existed only in workspace/tenant), so an ephemeral pull dumped v2
- * objects into flat top-level channel/, message/ and realtime_server/ folders —
- * detaching messages from their channels and risking name collisions (message
- * names are unique only WITHIN a channel).
- *
- * @param doc - the parsed document
- * @param outputDir - the resolved pull output root
- * @param deps - injected dependencies
- * @param deps.getApiGroupFolder - resolves an api_group name to its unique folder
- * @param deps.getChannelServer - resolves a v2 channel path to its owning realtime_server
- * @param deps.join - the path.join implementation (injectable for testing)
- * @param deps.snakeCase - the snakeCase implementation the caller uses
- */
-export declare function resolveDocumentPath(doc: ParsedDocument, outputDir: string, deps: {
-    getApiGroupFolder: (groupName: string) => string;
-    getChannelServer: (channelName: string) => string | undefined;
-    join: (...parts: string[]) => string;
-    snakeCase: (s: string) => string;
-}): DocumentPlacement;
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.
  * Used to match server GUID map entries back to local files.

package/dist/utils/document-parser.js

@@ -45,25 +45,6 @@ export function parseDocument(content) {
     if (apiGroupMatch) {
         apiGroup = apiGroupMatch[1];
     }
-    // Extract channel if present (e.g., channel = "rooms/{room_id}").
-    // Realtime v2 messages reference their owning channel by PATH, which is what
-    // nests them under it on disk.
-    let channel;
-    const channelMatch = content.match(/^\s*channel\s*=\s*"([^"]*)"/m);
-    if (channelMatch) {
-        channel = channelMatch[1];
-    }
-    // Extract realtime_server if present (e.g., realtime_server = "chat").
-    // Realtime v2 channels/messages reference their owning realtime_server by NAME
-    // via a top-level `realtime_server = "..."`, which is what nests them under it
-    // on disk (mirrors how a message names its channel via `channel = "..."`).
-    // The keyword is `realtime_server` (renamed from a bare `server` to match the
-    // api_group/mcp_server convention — reference the container by its full type).
-    let server;
-    const serverMatch = content.match(/^\s*realtime_server\s*=\s*"([^"]*)"/m);
-    if (serverMatch) {
-        server = serverMatch[1];
-    }
     // Extract canonical if present (e.g., canonical = "abc123")
     let canonical;
     const canonicalMatch = content.match(/canonical\s*=\s*"([^"]*)"/);
@@ -76,201 +57,7 @@ export function parseDocument(content) {
     if (guidMatch) {
         guid = guidMatch[1];
     }
-    return { apiGroup, canonical, channel, content, guid, name, server, type, verb };
-}
-/**
- * Map a realtime v2 channel path onto directory segments.
- *
- * A channel name IS a path template — "rooms/{room_id}" — so the directory tree
- * mirrors it rather than flattening it. That is the whole reason messages nest
- * under channels: the tree should show the structure, and
- * "channel/rooms/[room_id]/post.xs" says immediately that `post` lives on a
- * parameterized rooms channel.
- *
- *   "rooms"                    -> ["rooms"]
- *   "rooms/{room_id}"          -> ["rooms", "[room_id]"]
- *   "org/{org_id}/room/{id}"   -> ["org", "[org_id]", "room", "[id]"]
- *
- * Braces become brackets because "{" and "}" are awkward in shells, while "["
- * and "]" are legal on every filesystem. They are still glob character classes,
- * so scripting against a checkout needs the path quoted.
- *
- * Escaping the braces rather than dropping them is what keeps a parameterized
- * channel distinct from a literal one: without it, "rooms/{room_id}" and a
- * literal channel named "rooms/room_id" collide on the same directory.
- *
- * Mirrors Vfs::channelSegment() on the server.
- */
-export function channelPathSegments(name, snakeCaseFn) {
-    // A parameter keeps the author's name verbatim so it matches the `input`
-    // block; only the delimiters are swapped.
-    const isParam = /^\{.*\}$/;
-    return name.split('/').map((segment) => (isParam.test(segment) ? `[${segment.slice(1, -1)}]` : snakeCaseFn(segment)));
-}
-/**
- * Build a map of realtime v2 channel path -> owning realtime_server name.
- *
- * This is the cross-document lookup the on-disk nesting needs: a `message`
- * document names its channel (`channel = "..."`), while a `channel` document
- * names its server (`realtime_server = "..."`). To place a message under
- * `realtime/server/<server>/channel/<path>/...` we resolve the message's channel
- * to that channel's server — which the channel document carries. (Messages now
- * also carry `realtime_server` directly, but resolving via the channel keeps a
- * single source of truth for the channel→server mapping.)
- *
- * Because every pull path parses the WHOLE multidoc into memory before writing,
- * we can build this map from the `channel` docs in the same batch (a two-pass
- * resolve), keyed by the channel's own name (its path). A channel with no
- * `realtime_server` (e.g. a pre-server export) simply isn't in the map, and
- * callers fall back accordingly.
- */
-export function buildChannelServerResolver(documents) {
-    const channelToServer = new Map();
-    for (const doc of documents) {
-        if (doc.type === 'channel' && doc.server) {
-            channelToServer.set(doc.name, doc.server);
-        }
-    }
-    return (channelName) => channelToServer.get(channelName);
-}
-/**
- * Sanitize a document name for use as a single on-disk filename segment.
- * Strips quotes and snake_cases the rest. Mirrors the per-command
- * `sanitizeFilename` the pull commands used to each define privately.
- */
-export function sanitizeDocumentName(name, snakeCaseFn) {
-    return snakeCaseFn(name.replaceAll('"', ''));
-}
-/**
- * Resolve where a parsed document lands on disk — the SINGLE source of truth for
- * the pull layout, shared by every pull command (workspace, tenant, release,
- * sandbox, ephemeral). Previously each command inlined a ~130-line copy of this
- * decision; the copies drifted (the realtime v2 realtime_server/channel/message
- * branches existed only in workspace/tenant), so an ephemeral pull dumped v2
- * objects into flat top-level channel/, message/ and realtime_server/ folders —
- * detaching messages from their channels and risking name collisions (message
- * names are unique only WITHIN a channel).
- *
- * @param doc - the parsed document
- * @param outputDir - the resolved pull output root
- * @param deps - injected dependencies
- * @param deps.getApiGroupFolder - resolves an api_group name to its unique folder
- * @param deps.getChannelServer - resolves a v2 channel path to its owning realtime_server
- * @param deps.join - the path.join implementation (injectable for testing)
- * @param deps.snakeCase - the snakeCase implementation the caller uses
- */
-export function resolveDocumentPath(doc, outputDir, deps) {
-    const { getApiGroupFolder, getChannelServer, join, snakeCase } = deps;
-    const sanitize = (name) => sanitizeDocumentName(name, snakeCase);
-    if (doc.type === 'workspace') {
-        // workspace → workspace/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace') };
-    }
-    if (doc.type === 'workspace_trigger' || doc.type === 'error_trigger') {
-        // workspace_trigger / error_trigger → workspace/trigger/{name}.xs
-        // (error_trigger is a singleton, colocated with workspace triggers)
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'workspace', 'trigger') };
-    }
-    if (doc.type === 'agent') {
-        // agent → ai/agent/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent') };
-    }
-    if (doc.type === 'mcp_server') {
-        // mcp_server → ai/mcp_server/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server') };
-    }
-    if (doc.type === 'tool') {
-        // tool → ai/tool/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'tool') };
-    }
-    if (doc.type === 'agent_trigger') {
-        // agent_trigger → ai/agent/trigger/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'agent', 'trigger') };
-    }
-    if (doc.type === 'mcp_server_trigger') {
-        // mcp_server_trigger → ai/mcp_server/trigger/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'ai', 'mcp_server', 'trigger') };
-    }
-    if (doc.type === 'table_trigger') {
-        // table_trigger → table/trigger/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'table', 'trigger') };
-    }
-    if (doc.type === 'realtime_channel') {
-        // Realtime v1: realtime_channel → realtime/channel/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'channel') };
-    }
-    if (doc.type === 'realtime_trigger') {
-        // Realtime v1: realtime_trigger → realtime/trigger/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'trigger') };
-    }
-    if (doc.type === 'realtime_server') {
-        // Realtime v2. The realtime_server is the top-level container that owns
-        // channels (which own messages). Its own document is named after itself
-        // inside its name directory, mirroring api_group (api/<group>/<group>.xs).
-        //   realtime_server "chat" → realtime/server/chat/chat.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.name)) };
-    }
-    if (doc.type === 'channel') {
-        // Realtime v2. The channel owns a directory named after itself (the full
-        // channel name, snake_cased into a single flat segment), and its messages
-        // live in a message/ subfolder inside it. It nests under its owning
-        // realtime_server (from `realtime_server = "..."`):
-        //   channel "rooms/{room_id}" (server "chat")
-        //     → realtime/server/chat/channel/rooms_room_id/rooms_room_id.xs
-        //
-        // A channel with no resolvable server (e.g. a pre-server export) falls back
-        // to the legacy flat channel/<path>/_channel.xs layout.
-        if (doc.server) {
-            return {
-                baseName: snakeCase(doc.name),
-                typeDir: join(outputDir, 'realtime', 'server', sanitize(doc.server), 'channel', snakeCase(doc.name)),
-            };
-        }
-        return { baseName: '_channel', typeDir: join(outputDir, 'channel', ...channelPathSegments(doc.name, snakeCase)) };
-    }
-    if (doc.type === 'message' && doc.channel) {
-        // Realtime v2 message → nests in a message/ subfolder under its channel,
-        // under that channel's server (resolved via the two-pass channel→server map).
-        //   message "post" on channel "rooms/{room_id}" (server "chat")
-        //     → realtime/server/chat/channel/rooms_room_id/message/post.xs
-        //
-        // Nesting matters beyond tidiness: message names are unique only WITHIN a
-        // channel, so a flat message/ directory would collide when two channels
-        // both define e.g. "say". A channel whose server can't be resolved falls
-        // back to the legacy flat channel/ layout.
-        const messageServer = getChannelServer(doc.channel);
-        return {
-            baseName: sanitize(doc.name),
-            typeDir: messageServer
-                ? join(outputDir, 'realtime', 'server', sanitize(messageServer), 'channel', snakeCase(doc.channel), 'message')
-                : join(outputDir, 'channel', ...channelPathSegments(doc.channel, snakeCase)),
-        };
-    }
-    if (doc.type === 'api_group') {
-        // api_group "test" → api/{resolved_folder}/{name}.xs
-        return { baseName: sanitize(doc.name), typeDir: join(outputDir, 'api', getApiGroupFolder(doc.name)) };
-    }
-    if (doc.type === 'query' && doc.apiGroup) {
-        // query in group "test" → api/{resolved_folder}/{folders}/{query_name}[_verb].xs
-        const groupFolder = getApiGroupFolder(doc.apiGroup);
-        const nameParts = doc.name.split('/');
-        const leafName = nameParts.pop();
-        const folderParts = nameParts.map((part) => snakeCase(part));
-        const baseName = sanitize(leafName);
-        return {
-            baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
-            typeDir: join(outputDir, 'api', groupFolder, ...folderParts),
-        };
-    }
-    // Default: split folder path from name
-    const nameParts = doc.name.split('/');
-    const leafName = nameParts.pop();
-    const folderParts = nameParts.map((part) => snakeCase(part));
-    const baseName = sanitize(leafName);
-    return {
-        baseName: doc.verb ? `${baseName}_${doc.verb}` : baseName,
-        typeDir: join(outputDir, doc.type, ...folderParts),
-    };
+    return { apiGroup, canonical, content, guid, name, type, verb };
 }
 /**
  * Build a unique key for a document based on its type, name, verb, and api_group.

package/dist/utils/knowledge-sync.d.ts

@@ -17,7 +17,6 @@ export interface KnowledgeObject {
     mode?: string;
     name: string;
     scope?: string;
-    tag?: string[];
 }
 /** A locally-collected object that also remembers its primary file on disk (for GUID writeback). */
 export interface LocalKnowledgeObject extends KnowledgeObject {

package/dist/utils/knowledge-sync.js

@@ -12,7 +12,7 @@ import { dirname, join, relative, sep } from 'node:path';
 // let the server dictate file paths.
 export const KNOWLEDGE_DIR = 'knowledge';
 // ── Frontmatter ──────────────────────────────────────────────────────────────
-const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'inclusion', 'tags', 'guid'];
+const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'scope', 'inclusion', 'enabled', 'guid'];
 /**
  * Build a primary `.md` file body: YAML frontmatter (built from the object's
  * structured fields) followed by the markdown content.
@@ -23,10 +23,12 @@ export function buildPrimaryContent(obj) {
     if (obj.description !== undefined)
         meta.description = obj.description;
     meta.knowledge_type = obj.knowledge_type;
+    if (obj.scope !== undefined)
+        meta.scope = obj.scope;
     if (obj.mode !== undefined)
         meta.inclusion = modeToInclusion(obj.mode);
-    if (obj.tag !== undefined && obj.tag.length > 0)
-        meta.tags = obj.tag;
+    if (obj.enabled !== undefined)
+        meta.enabled = obj.enabled;
     if (obj.guid !== undefined)
         meta.guid = obj.guid;
     // Emit keys in a stable, human-friendly order.
@@ -105,10 +107,6 @@ const MODE_TO_INCLUSION = {
 function modeToInclusion(mode) {
     return MODE_TO_INCLUSION[mode] ?? mode;
 }
-/** Parse the on-disk `tags:` frontmatter value into a string array, or `undefined` if absent/malformed. */
-function parseTags(tags) {
-    return Array.isArray(tags) && tags.every((t) => typeof t === 'string') ? tags : undefined;
-}
 // ── Path mapping (CLI-owned layout) ────────────────────────────────────────────
 /**
  * Allocate a unique snake_case folder/file segment per call, suffixing
@@ -248,9 +246,6 @@ export function collectKnowledgeObjects(inputDir, include, exclude) {
         };
         if (typeof meta.guid === 'string')
             obj.guid = meta.guid;
-        const tags = parseTags(meta.tags);
-        if (tags)
-            obj.tag = tags;
         if (knowledgeType === 'skill') {
             const skillFolder = posixPath.slice('skills/'.length, posixPath.indexOf('/SKILL.md'));
             const refPrefix = `skills/${skillFolder}/references/`;
@@ -350,7 +345,6 @@ function canonical(obj) {
         files,
         mode: obj.mode ?? '',
         scope: obj.scope ?? '',
-        tag: [...(obj.tag ?? [])].sort(),
     });
 }
 /**

package/dist/utils/paging.d.ts

@@ -16,8 +16,7 @@
  *                         so the item count IS the total.
  *
  * There is deliberately no tier for endpoints that page but return a bare array
- * with no metadata (tenants, releases, platforms, clusters, ephemerals, tenant
- * backups). Those commands are left alone: the only has-more signal available
+ * with no metadata (tenants, releases, platforms, clusters, tenant backups). Those commands are left alone: the only has-more signal available
  * would be "the page came back full", which is a guaranteed false positive when
  * the result set is an exact multiple of the page size — sending the user to an
  * empty page. Better to offer nothing than to offer a lie.

package/dist/utils/reference-checker.js

@@ -28,16 +28,6 @@ const REFERENCE_PATTERNS = [
     },
     // Schema foreign key references: table = "name" inside field definitions
     { keyword: 'table (FK)', regex: /\btable\s*=\s*"([^"]*)"/gm, targetType: 'table' },
-    // Realtime v2: a channel references its owning realtime_server by name via a
-    // top-level `realtime_server = "..."` (renamed from a bare `server` to match
-    // the api_group/mcp_server convention). The full keyword is unambiguous, so no
-    // false-match against another object type's `server` field.
-    {
-        keyword: 'channel (realtime_server)',
-        regex: /^\s*realtime_server\s*=\s*"([^"]*)"/gm,
-        sourceType: 'channel',
-        targetType: 'realtime_server',
-    },
 ];
 /**
  * Strip surrounding quotes from a name if present.
@@ -129,9 +119,6 @@ export function checkReferences(documents, serverOperations) {
         if (!parsed)
             continue;
         for (const pattern of REFERENCE_PATTERNS) {
-            // Skip patterns scoped to a different source document type.
-            if (pattern.sourceType && pattern.sourceType !== parsed.type)
-                continue;
             // Reset regex state for each document
             pattern.regex.lastIndex = 0;
             let match;