@xpert-ai/plugin-spaces 0.2.0 → 0.3.0

package/dist/documents.d.ts

@@ -2,6 +2,7 @@ import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
 import { SpaceAccess } from './access.js';
 import { Space, SpaceItem } from './entities.js';
 import { type SpaceActor } from './domain.js';
+import { type ContentPathCoverage } from './content-coverage.js';
 export declare const contentHash: (buffer: Buffer) => string;
 export declare const safeName: (name: string) => string;
 /** Runtime memory and Space checkpoints are infrastructure, not library content. */
@@ -17,6 +18,7 @@ export declare class SpaceDocuments {
         actor: SpaceActor;
         projectId: string;
     };
+    resourceCoverage(actor: SpaceActor, space: Space): Promise<ContentPathCoverage[]>;
     path(actor: SpaceActor, item: SpaceItem): Promise<string>;
     initialize(actor: SpaceActor, space: Space, item: SpaceItem, content?: Buffer): Promise<SpaceItem>;
     /** Register the file on creation/discovery; opening a page never migrates or mutates its model. */
@@ -32,5 +34,5 @@ export declare class SpaceDocuments {
     } | null>;
     private editableMarkdown;
     /** Discover files created by other Assistants without importing hidden version/trash storage. */
-    discover(actor: SpaceActor, space: Space, canWrite: boolean): Promise<void>;
+    discover(actor: SpaceActor, space: Space, canWrite: boolean, coverage?: ContentPathCoverage[]): Promise<void>;
 }

package/dist/documents.js

@@ -11,10 +11,11 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { BadRequestException, ConflictException, Inject, Injectable } from '@nestjs/common';
-import { ContentDocumentsRuntimeCapability, ProjectFilesRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
+import { ContentDocumentsRuntimeCapability, ContentResourcesRuntimeCapability, ProjectFilesRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
 import { createHash, randomUUID } from 'node:crypto';
 import { SpaceAccess } from './access.js';
 import { denied, scoped } from './domain.js';
+import { contentCoverage, coveredByContent } from './content-coverage.js';
 export const contentHash = (buffer) => createHash('sha256').update(buffer).digest('hex');
 export const safeName = (name) => name.replace(/[\\/\u0000-\u001f]/gu, '_').replace(/^\.+/u, '_').slice(0, 180) || 'Untitled';
 /** Runtime memory and Space checkpoints are infrastructure, not library content. */
@@ -34,6 +35,24 @@ let SpaceDocuments = class SpaceDocuments {
             throw denied();
         return { actor, projectId: space.projectId };
     }
+    async resourceCoverage(actor, space) {
+        const catalog = this.runtime.require(ContentResourcesRuntimeCapability).catalog;
+        const coverage = [];
+        for (const deleted of [false, true]) {
+            let offset = 0;
+            for (;;) {
+                const page = await catalog.list({ ...this.scope(actor, space), assistantId: actor.assistantId,
+                    excludedProviderKeys: ['spaces'], deleted, offset, limit: 100 });
+                coverage.push(...contentCoverage(page.items));
+                if (!page.hasMore)
+                    break;
+                offset += page.items.length;
+                if (!page.items.length)
+                    throw new Error('spaces.invalid_catalog_page');
+            }
+        }
+        return coverage;
+    }
     async path(actor, item) {
         const parent = item.parentId ? await this.access.items.findOneByOrFail({ ...scoped(actor), id: item.parentId }) : null;
         if (parent && (parent.kind !== 'folder' || !parent.filePath))
@@ -101,7 +120,7 @@ let SpaceDocuments = class SpaceDocuments {
         }
     }
     /** Discover files created by other Assistants without importing hidden version/trash storage. */
-    async discover(actor, space, canWrite) {
+    async discover(actor, space, canWrite, coverage = []) {
         if (!space.projectId)
             throw denied();
         const files = await this.api().list({ ...this.scope(actor, space), depth: 12 });
@@ -110,7 +129,7 @@ let SpaceDocuments = class SpaceDocuments {
             return;
         const byPath = new Map(existing.filter((item) => item.filePath && !item.deleted).map((item) => [item.filePath, item]));
         for (const file of files.sort((a, b) => a.path.split('/').length - b.path.split('/').length)) {
-            if (isInternalSpacePath(file.path))
+            if (isInternalSpacePath(file.path) || coveredByContent(file.path, coverage))
                 continue;
             const known = byPath.get(file.path);
             if (known) {

package/dist/entities.d.ts

@@ -65,4 +65,27 @@ export declare class SpaceFileVersion extends ScopedEntity {
     revisionId: string | null;
     sha256: string;
 }
-export declare const entities: (typeof Space | typeof SpaceItem | typeof SpaceFileVersion)[];
+/** Organizational placement only. Native resources keep one authoritative provider and
+ * stable project bundle; moving a library entry never duplicates business content. */
+export declare class SpaceResourcePlacement extends ScopedEntity {
+    spaceId: string;
+    contentId: string;
+    parentId: string | null;
+    version: number;
+}
+/** Disposable revision-bound knowledge state, never a source body or permission cache. */
+export declare class SpaceContentIndex extends ScopedEntity {
+    spaceId: string;
+    contentId: string;
+    revision: string | null;
+    bindingRevision: number | null;
+    status: 'pending' | 'processing' | 'ready' | 'failed';
+    documents: Array<{
+        id: string;
+        anchor: {
+            kind: string;
+            id: string;
+        };
+    }>;
+}
+export declare const entities: (typeof Space | typeof SpaceItem | typeof SpaceFileVersion | typeof SpaceResourcePlacement | typeof SpaceContentIndex)[];

package/dist/entities.js

@@ -248,4 +248,71 @@ SpaceFileVersion = __decorate([
     Index(['tenantId', 'organizationId', 'itemId'])
 ], SpaceFileVersion);
 export { SpaceFileVersion };
-export const entities = [Space, SpaceItem, SpaceFileVersion];
+/** Organizational placement only. Native resources keep one authoritative provider and
+ * stable project bundle; moving a library entry never duplicates business content. */
+let SpaceResourcePlacement = class SpaceResourcePlacement extends ScopedEntity {
+    spaceId;
+    contentId;
+    parentId;
+    version;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceResourcePlacement.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceResourcePlacement.prototype, "contentId", void 0);
+__decorate([
+    Column({ type: 'uuid', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceResourcePlacement.prototype, "parentId", void 0);
+__decorate([
+    Column({ type: 'int', default: 1 }),
+    __metadata("design:type", Number)
+], SpaceResourcePlacement.prototype, "version", void 0);
+SpaceResourcePlacement = __decorate([
+    Entity('plugin_spaces_resource_placement'),
+    Index('IDX_space_resource_placement', ['tenantId', 'organizationId', 'spaceId', 'contentId'], { unique: true })
+], SpaceResourcePlacement);
+export { SpaceResourcePlacement };
+/** Disposable revision-bound knowledge state, never a source body or permission cache. */
+let SpaceContentIndex = class SpaceContentIndex extends ScopedEntity {
+    spaceId;
+    contentId;
+    revision;
+    bindingRevision;
+    status;
+    documents;
+};
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "spaceId", void 0);
+__decorate([
+    Column({ type: 'uuid' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "contentId", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 256, nullable: true }),
+    __metadata("design:type", Object)
+], SpaceContentIndex.prototype, "revision", void 0);
+__decorate([
+    Column({ type: 'int', nullable: true }),
+    __metadata("design:type", Object)
+], SpaceContentIndex.prototype, "bindingRevision", void 0);
+__decorate([
+    Column({ type: 'varchar', length: 24, default: 'pending' }),
+    __metadata("design:type", String)
+], SpaceContentIndex.prototype, "status", void 0);
+__decorate([
+    Column({ type: 'jsonb', default: () => "'[]'::jsonb" }),
+    __metadata("design:type", Array)
+], SpaceContentIndex.prototype, "documents", void 0);
+SpaceContentIndex = __decorate([
+    Entity('plugin_spaces_content_index'),
+    Index('IDX_space_content_index', ['tenantId', 'organizationId', 'spaceId', 'contentId'], { unique: true })
+], SpaceContentIndex);
+export { SpaceContentIndex };
+export const entities = [Space, SpaceItem, SpaceFileVersion, SpaceResourcePlacement, SpaceContentIndex];

package/dist/imports.d.ts

@@ -28,18 +28,18 @@ export declare const importSelection: z.ZodObject<{
     spaceId: string;
     parentId: string | null;
     expectedHash: string;
+    expectedRevision: string;
+    requestId: string;
     bindingId: string;
     locator: string;
-    requestId: string;
-    expectedRevision: string;
     confirmed: true;
 }, {
     spaceId: string;
     expectedHash: string;
+    expectedRevision: string;
+    requestId: string;
     bindingId: string;
     locator: string;
-    requestId: string;
-    expectedRevision: string;
     confirmed: true;
     parentId?: string | null | undefined;
 }>;

package/dist/index.js

@@ -4,6 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { SpaceItemCatalog } from './item-catalog.js';
+import { SpaceCatalog } from './catalog.js';
+import { SpaceContentKnowledge } from './content-knowledge.js';
 import { SpaceImports } from './imports.js';
 import 'reflect-metadata';
 import { readFileSync } from 'node:fs';
@@ -32,7 +35,7 @@ let SpacesPlugin = class SpacesPlugin {
 SpacesPlugin = __decorate([
     XpertServerPlugin({
         imports: [TypeOrmModule.forFeature(entities)], entities,
-        providers: [SpacesCapabilityProvider, SpaceImports, SpaceReferences, SpaceSubpages, SpaceContent, SpaceAccess, SpaceKnowledge, SpaceDocuments, SpacesResourceProvider, SpacesService, SpacePages, SpaceAi, SpaceFiles, SpaceEditors, SpaceArtifacts, SpacesMiddleware, SpacesView]
+        providers: [SpaceItemCatalog, SpaceContentKnowledge, SpaceCatalog, SpacesCapabilityProvider, SpaceImports, SpaceReferences, SpaceSubpages, SpaceContent, SpaceAccess, SpaceKnowledge, SpaceDocuments, SpacesResourceProvider, SpacesService, SpacePages, SpaceAi, SpaceFiles, SpaceEditors, SpaceArtifacts, SpacesMiddleware, SpacesView]
     })
 ], SpacesPlugin);
 export { SpacesPlugin };

package/dist/item-catalog.d.ts

@@ -0,0 +1,13 @@
+import type { ContentCatalogProvider } from '@xpert-ai/plugin-sdk';
+import { SpaceAccess } from './access.js';
+import { SpaceContentKnowledge } from './content-knowledge.js';
+/** Exposes native SpaceItems to the platform content catalog without copying content.
+ * Pages/files retain their identities, file paths and editing protocols. Creation
+ * uses the page/upload workflows; discovery rebuilds only derived catalog entries. */
+export declare class SpaceItemCatalog {
+    private readonly access;
+    private readonly knowledge;
+    constructor(access: SpaceAccess, knowledge: SpaceContentKnowledge);
+    readonly catalog: ContentCatalogProvider;
+    private describe;
+}

package/dist/item-catalog.js

@@ -0,0 +1,71 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injectable } from '@nestjs/common';
+import { In } from 'typeorm';
+import { SpaceAccess } from './access.js';
+import { scoped, denied } from './domain.js';
+import { SpaceContentKnowledge } from './content-knowledge.js';
+const models = {
+    page: { typeId: 'xpert.markdown', modelId: 'markdown.tiptap', schemaVersion: '1', editProtocol: { id: 'platform.text-document', version: '1' } },
+    file: { typeId: 'xpert.file', modelId: 'platform.file', schemaVersion: '1', editProtocol: { id: 'platform.file.cas', version: '1' } }
+};
+/** Exposes native SpaceItems to the platform content catalog without copying content.
+ * Pages/files retain their identities, file paths and editing protocols. Creation
+ * uses the page/upload workflows; discovery rebuilds only derived catalog entries. */
+let SpaceItemCatalog = class SpaceItemCatalog {
+    access;
+    knowledge;
+    constructor(access, knowledge) {
+        this.access = access;
+        this.knowledge = knowledge;
+    }
+    catalog = {
+        types: [
+            { ...models.page, creatable: false, title: { en_US: 'Pages', zh_Hans: '页面' }, implementationKey: 'spaces.page', implementationTitle: { en_US: 'Markdown', zh_Hans: 'Markdown' }, defaultEditorKey: 'markdown.tiptap' },
+            { ...models.file, creatable: false, title: { en_US: 'Files', zh_Hans: '文件' }, implementationKey: 'spaces.file', implementationTitle: { en_US: 'File', zh_Hans: '文件' }, defaultEditorKey: 'platform.file' }
+        ],
+        discover: async (input) => {
+            const space = await this.access.spaces.findOneBy({ ...scoped(input.actor), projectId: input.projectId, deleted: false });
+            if (!space)
+                return { resourceIds: [] };
+            await this.access.project({ ...input.actor, assistantId: input.assistantId }, input.projectId);
+            const offset = Number(input.cursor ?? 0);
+            if (!Number.isSafeInteger(offset) || offset < 0)
+                throw denied();
+            const items = await this.access.items.find({ where: { ...scoped(input.actor), spaceId: space.id, kind: In(['page', 'file', 'artifact']), deleted: false }, order: { id: 'ASC' }, skip: offset, take: 100 });
+            return { resourceIds: items.filter(item => item.filePath).map(item => item.id), ...(items.length === 100 ? { nextCursor: String(offset + 100) } : {}) };
+        },
+        describe: input => this.describe(input),
+        onResourceReconciled: async (input) => {
+            if (input.item.resourceRef.providerKey === 'spaces')
+                return;
+            const space = await this.access.spaces.findOneBy({ ...scoped(input.actor), projectId: input.projectId, deleted: false });
+            if (!space?.knowledgebaseId)
+                return;
+            const actor = { ...input.actor, projectId: input.projectId, assistantId: input.assistantId };
+            await this.access.project(actor, input.projectId, 'write');
+            await this.knowledge.refreshItem(actor, space, input.item);
+        },
+        create: async () => { throw denied(); }
+    };
+    async describe(input) {
+        const { item, space } = await this.access.resource({ ...input.actor, projectId: input.projectId, assistantId: input.assistantId }, input.sourceResourceId, 'read');
+        if (!item?.filePath || item.kind === 'folder')
+            throw denied();
+        return { ...(item.kind === 'page' ? models.page : models.file), projectId: space.projectId, title: item.title,
+            revision: `${item.version}:${item.projectedSequence}:${item.fileHash ?? ''}`, updatedAt: item.updatedAt.toISOString(),
+            deleted: item.deleted, source: { kind: 'file', path: item.filePath }, defaultEditorKey: item.editorKey ?? 'platform.file', allowedActions: [] };
+    }
+};
+SpaceItemCatalog = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [SpaceAccess, SpaceContentKnowledge])
+], SpaceItemCatalog);
+export { SpaceItemCatalog };

package/dist/knowledge.d.ts

@@ -1,11 +1,13 @@
 import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+import { SpaceContentKnowledge } from './content-knowledge.js';
 import { SpaceAccess } from './access.js';
 import { type SpaceActor } from './domain.js';
 import { Space, SpaceItem } from './entities.js';
 export declare class SpaceKnowledge {
     private readonly access;
     private readonly runtime;
-    constructor(access: SpaceAccess, runtime: RuntimeCapabilityRegistry);
+    private readonly content;
+    constructor(access: SpaceAccess, runtime: RuntimeCapabilityRegistry, content: SpaceContentKnowledge);
     enable(actor: SpaceActor, spaceId: string): Promise<{
         knowledgebaseId: string;
     }>;
@@ -13,24 +15,36 @@ export declare class SpaceKnowledge {
     refresh(actor: SpaceActor, spaceId: string): Promise<{
         knowledgebaseId: string | null;
         mode: string;
-        items: {
+        items: ({
+            itemId: string;
+            title: string;
+            status: string;
+            error: string | null;
+            document: null;
+        } | {
             itemId: string;
             title: string;
             status: "pending" | "ready" | "failed" | "processing";
             error: string | null;
             document: import("@xpert-ai/plugin-sdk").KnowledgebaseDocumentRecord | null;
-        }[];
+        })[];
     }>;
     status(actor: SpaceActor, spaceId: string): Promise<{
         knowledgebaseId: string | null;
         mode: string;
-        items: {
+        items: ({
+            itemId: string;
+            title: string;
+            status: string;
+            error: string | null;
+            document: null;
+        } | {
             itemId: string;
             title: string;
             status: "pending" | "ready" | "failed" | "processing";
             error: string | null;
             document: import("@xpert-ai/plugin-sdk").KnowledgebaseDocumentRecord | null;
-        }[];
+        })[];
     }>;
     search(actor: SpaceActor, spaceId: string, query: string): Promise<{
         itemId: string;
@@ -39,5 +53,5 @@ export declare class SpaceKnowledge {
         filePath: string;
         hash: string;
     }[]>;
-    verify(actor: SpaceActor, itemId: string, hash: string): Promise<boolean>;
+    verify(actor: SpaceActor, itemId: string, hash: string, contentId?: string): Promise<boolean>;
 }

package/dist/knowledge.js

@@ -14,6 +14,7 @@ import { ForbiddenException, Inject, Injectable } from '@nestjs/common';
 import { ProjectKnowledgeRuntimeCapability, KnowledgebaseDocumentsRuntimeCapability, KnowledgebaseRuntimeCapability, ProjectFilesRuntimeCapability, XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
 import { z } from 'zod/v3';
 import { KBDocumentStatusEnum } from '@xpert-ai/contracts';
+import { SpaceContentKnowledge } from './content-knowledge.js';
 import { SpaceAccess } from './access.js';
 import { denied, scoped } from './domain.js';
 const metadata = z.object({ spaceItemId: z.string().uuid(), spaceFileHash: z.string() }).passthrough();
@@ -21,9 +22,11 @@ const documentMetadata = z.object({ documentId: z.string().uuid() }).passthrough
 let SpaceKnowledge = class SpaceKnowledge {
     access;
     runtime;
-    constructor(access, runtime) {
+    content;
+    constructor(access, runtime, content) {
         this.access = access;
         this.runtime = runtime;
+        this.content = content;
     }
     async enable(actor, spaceId) {
         const { space } = await this.access.resource(actor, spaceId, 'manage');
@@ -88,6 +91,7 @@ let SpaceKnowledge = class SpaceKnowledge {
         const items = await this.access.items.findBy({ ...scoped(actor), spaceId });
         for (const item of items)
             await this.sync(actor, space, item);
+        await this.content.refresh(actor, space);
         return this.status(actor, spaceId);
     }
     async status(actor, spaceId) {
@@ -108,10 +112,10 @@ let SpaceKnowledge = class SpaceKnowledge {
             item.indexStatus = status;
             item.indexError = error;
         }
-        return { knowledgebaseId: space.knowledgebaseId, mode: 'keyword', items: items.filter((item) => item.kind !== 'folder' && !item.deleted).map((item) => ({
-                itemId: item.id, title: item.title, status: item.indexStatus, error: item.indexError,
-                document: documents.documents.find((doc) => doc.id === item.knowledgeDocumentId) ?? null
-            })) };
+        return { knowledgebaseId: space.knowledgebaseId, mode: 'keyword', items: [...await this.content.status(actor, space), ...items.filter((item) => item.kind !== 'folder' && !item.deleted).map((item) => ({
+                    itemId: item.id, title: item.title, status: item.indexStatus, error: item.indexError,
+                    document: documents.documents.find((doc) => doc.id === item.knowledgeDocumentId) ?? null
+                }))] };
     }
     async search(actor, spaceId, query) {
         const { space } = await this.access.resource(actor, spaceId, 'read');
@@ -148,9 +152,11 @@ let SpaceKnowledge = class SpaceKnowledge {
                 continue;
             matches.push({ itemId: item.id, title: item.title, text: document.pageContent, filePath: item.filePath, hash });
         }
-        return matches;
+        return [...matches, ...await this.content.matches(actor, space, result.documents)];
     }
-    async verify(actor, itemId, hash) {
+    async verify(actor, itemId, hash, contentId) {
+        if (contentId)
+            return this.content.verify(actor, contentId, hash);
         const { item, space } = await this.access.resource(actor, itemId, 'read');
         if (!item?.filePath || !space.projectId)
             return false;
@@ -161,6 +167,6 @@ let SpaceKnowledge = class SpaceKnowledge {
 SpaceKnowledge = __decorate([
     Injectable(),
     __param(1, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
-    __metadata("design:paramtypes", [SpaceAccess, Object])
+    __metadata("design:paramtypes", [SpaceAccess, Object, SpaceContentKnowledge])
 ], SpaceKnowledge);
 export { SpaceKnowledge };