@bernierllc/content-management-suite 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -110,6 +110,9 @@ var ContentManagementConfigSchema = z.object({
       { name: "user", permissions: ["content.view"], description: "Content viewing only" }
     ])
   }).default({}),
+  workflows: z.object({
+    defaults: z.record(z.string(), z.string()).default({})
+  }).default({}),
   logging: z.object({
     level: z.enum(["error", "warn", "info", "debug"]).default("info")
   }).default({}),
@@ -167,144 +170,431 @@ var InternalError = class extends ContentManagementError {
   }
 };
 
+// src/in-memory-adapter.ts
+var InMemoryContentStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.type) {
+      items = items.filter((item) => item.type === filters.type);
+    }
+    if (filters?.status) {
+      items = items.filter((item) => item.status === filters.status);
+    }
+    const total = items.length;
+    const page = filters?.page ?? 1;
+    const limit = filters?.limit ?? items.length;
+    const start = (page - 1) * limit;
+    const paged = items.slice(start, start + limit);
+    return { items: paged, total, page, limit };
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(item) {
+    this.store.set(item.id, item);
+    return item;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Content item not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async findBySource(sourceType, sourceId) {
+    for (const item of this.store.values()) {
+      if (item.sourceType === sourceType && item.sourceId === sourceId) {
+        return item;
+      }
+    }
+    return null;
+  }
+  async search(query, options) {
+    const lowerQuery = query.toLowerCase();
+    let items = Array.from(this.store.values()).filter((item) => {
+      const titleMatch = item.title && item.title.toLowerCase().includes(lowerQuery);
+      const bodyMatch = item.body && item.body.toLowerCase().includes(lowerQuery);
+      const dataMatch = item.data && Object.values(item.data).some(
+        (value) => typeof value === "string" && value.toLowerCase().includes(lowerQuery)
+      );
+      return titleMatch || bodyMatch || dataMatch;
+    });
+    if (options?.type) {
+      items = items.filter((item) => item.type === options.type);
+    }
+    if (options?.status) {
+      items = items.filter((item) => item.status === options.status);
+    }
+    const total = items.length;
+    const page = options?.page ?? 1;
+    const limit = options?.limit ?? items.length;
+    const start = (page - 1) * limit;
+    const paged = items.slice(start, start + limit);
+    return { items: paged, total, page, limit };
+  }
+};
+var InMemoryWorkflowStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.contentTypeMap = /* @__PURE__ */ new Map();
+  }
+  // contentType -> workflowId
+  async list() {
+    return Array.from(this.store.values());
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(workflow) {
+    this.store.set(workflow.id, workflow);
+    return workflow;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Workflow not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+    for (const [ct, wId] of this.contentTypeMap.entries()) {
+      if (wId === id) {
+        this.contentTypeMap.delete(ct);
+      }
+    }
+  }
+  async findByContentType(contentType) {
+    const workflowId = this.contentTypeMap.get(contentType);
+    if (!workflowId) {
+      return null;
+    }
+    return this.store.get(workflowId) ?? null;
+  }
+  setContentTypeMapping(contentType, workflowId) {
+    this.contentTypeMap.set(contentType, workflowId);
+  }
+};
+var InMemoryContentTypeStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list() {
+    return Array.from(this.store.values());
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(def) {
+    this.store.set(def.id, def);
+    return def;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Content type not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+};
+var InMemorySocialPostStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.contentId) {
+      items = items.filter((p) => p.contentId === filters.contentId);
+    }
+    if (filters?.platform) {
+      items = items.filter((p) => p.platform === filters.platform);
+    }
+    if (filters?.status) {
+      items = items.filter((p) => p.status === filters.status);
+    }
+    return items;
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(post) {
+    this.store.set(post.id, post);
+    return post;
+  }
+  async update(id, partial) {
+    const existing = this.store.get(id);
+    if (!existing) {
+      throw new Error(`Social post not found: ${id}`);
+    }
+    const updated = { ...existing, ...partial };
+    this.store.set(id, updated);
+    return updated;
+  }
+  async delete(id) {
+    this.store.delete(id);
+  }
+  async findByContent(contentId) {
+    return Array.from(this.store.values()).filter((p) => p.contentId === contentId);
+  }
+};
+var InMemoryAIReviewStorage = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+  }
+  async list(filters) {
+    let items = Array.from(this.store.values());
+    if (filters?.contentId) {
+      items = items.filter((r) => r.contentId === filters.contentId);
+    }
+    return items;
+  }
+  async get(id) {
+    return this.store.get(id) ?? null;
+  }
+  async create(review) {
+    this.store.set(review.id, review);
+    return review;
+  }
+  async findByContent(contentId) {
+    return Array.from(this.store.values()).filter((r) => r.contentId === contentId);
+  }
+  async getLatestForContent(contentId) {
+    const reviews = await this.findByContent(contentId);
+    if (reviews.length === 0) {
+      return null;
+    }
+    reviews.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return reviews[0] ?? null;
+  }
+};
+function createInMemoryAdapter() {
+  return {
+    content: new InMemoryContentStorage(),
+    workflows: new InMemoryWorkflowStorage(),
+    contentTypes: new InMemoryContentTypeStorage(),
+    socialPosts: new InMemorySocialPostStorage(),
+    aiReviews: new InMemoryAIReviewStorage()
+  };
+}
+
 // src/namespaces/content.ts
 import * as crypto from "crypto";
 var ContentNamespaceImpl = class {
-  constructor(emitter) {
-    this.store = /* @__PURE__ */ new Map();
+  constructor(emitter, storage, getContentTypes, getPublishers) {
     this.emitter = emitter;
+    this.storage = storage;
+    this.getContentTypes = getContentTypes;
+    this.getPublishers = getPublishers;
   }
   async create(input) {
+    const contentTypes = this.getContentTypes();
+    const typeDef = contentTypes.get(input.type);
+    if (typeDef && typeDef.schema) {
+      const dataToValidate = {
+        ...input.title !== void 0 ? { title: input.title } : {},
+        ...input.body !== void 0 ? { body: input.body } : {},
+        ...input.data ?? {}
+      };
+      const result = contentTypes.validate(input.type, dataToValidate);
+      if (!result.valid) {
+        throw new ValidationError("Content type schema validation failed", {
+          details: { errors: result.errors }
+        });
+      }
+    }
     const item = {
       id: crypto.randomUUID(),
       type: input.type,
-      data: { ...input.data },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: "draft",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      ...input.title !== void 0 ? { title: input.title } : {},
+      ...input.body !== void 0 ? { body: input.body } : {},
+      ...input.data !== void 0 ? { data: { ...input.data } } : {},
+      ...input.channels !== void 0 ? { channels: input.channels } : {},
+      ...input.metadata !== void 0 ? { metadata: input.metadata } : {}
     };
-    this.store.set(item.id, item);
-    this.emitter.emit("content:created", item);
-    return item;
+    const created = await this.storage.content.create(item);
+    this.emitter.emit("content:created", created);
+    return created;
   }
   async get(id) {
-    const item = this.store.get(id);
+    const item = await this.storage.content.get(id);
     if (!item) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
     return item;
   }
   async list(filters) {
-    let items = Array.from(this.store.values());
-    if (filters?.type) {
-      items = items.filter((item) => item.type === filters.type);
-    }
-    if (filters?.status) {
-      items = items.filter((item) => item.status === filters.status);
-    }
-    const total = items.length;
-    const page = filters?.page ?? 1;
-    const limit = filters?.limit ?? items.length;
-    const start = (page - 1) * limit;
-    const paged = items.slice(start, start + limit);
-    return { items: paged, total, page, limit };
+    return this.storage.content.list(filters);
   }
   async update(id, input) {
-    const existing = this.store.get(id);
+    const existing = await this.storage.content.get(id);
     if (!existing) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
-    const updated = {
-      ...existing,
-      data: { ...existing.data, ...input.data },
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    const partial = {
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input.title !== void 0 ? { title: input.title } : {},
+      ...input.body !== void 0 ? { body: input.body } : {},
+      ...input.status !== void 0 ? { status: input.status } : {},
+      ...input.channels !== void 0 ? { channels: input.channels } : {},
+      ...input.metadata !== void 0 ? { metadata: input.metadata } : {}
     };
-    this.store.set(id, updated);
+    if (input.data !== void 0) {
+      partial.data = { ...existing.data ?? {}, ...input.data };
+    }
+    const updated = await this.storage.content.update(id, partial);
     this.emitter.emit("content:updated", updated);
     return updated;
   }
   async delete(id) {
-    if (!this.store.has(id)) {
+    const existing = await this.storage.content.get(id);
+    if (!existing) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
-    this.store.delete(id);
+    await this.storage.content.delete(id);
     this.emitter.emit("content:deleted", { id });
   }
-  async publish(id) {
-    const existing = this.store.get(id);
+  async publish(id, options) {
+    const existing = await this.storage.content.get(id);
     if (!existing) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
-    const published = {
-      ...existing,
+    if (existing.workflowId) {
+      const workflow = await this.storage.workflows.get(existing.workflowId);
+      if (workflow && workflow.stages && workflow.stages.length > 0) {
+        const currentStage = workflow.stages.find((s) => s.id === existing.workflowStage);
+        const publishStage = workflow.stages.find((s) => s.isPublishStage);
+        if (publishStage && (!currentStage || !currentStage.isPublishStage)) {
+          throw new ValidationError(
+            `Content is not at a publish-eligible stage. Current stage: "${existing.workflowStage ?? "none"}", required publish stage: "${publishStage.id}"`,
+            {
+              details: {
+                currentStage: existing.workflowStage ?? null,
+                requiredStage: publishStage.id
+              }
+            }
+          );
+        }
+      }
+    }
+    const publishers = this.getPublishers();
+    const allPublishers = publishers.list();
+    const channelIds = options?.channels ?? existing.channels;
+    let targetPublishers;
+    if (channelIds && channelIds.length > 0) {
+      targetPublishers = allPublishers.filter((p) => channelIds.includes(p.id));
+    } else {
+      targetPublishers = allPublishers.filter((p) => p.acceptedTypes.includes(existing.type));
+    }
+    const results = [];
+    for (const publisher of targetPublishers) {
+      if (!publisher.acceptedTypes.includes(existing.type)) {
+        results.push({
+          channelId: publisher.id,
+          success: false,
+          error: `Content type "${existing.type}" not accepted by publisher "${publisher.id}". Accepted: ${publisher.acceptedTypes.join(", ")}`
+        });
+        continue;
+      }
+      if (publisher.validate) {
+        const validationErrors = await publisher.validate(existing);
+        if (validationErrors.length > 0) {
+          results.push({
+            channelId: publisher.id,
+            success: false,
+            error: `Validation failed: ${validationErrors.map((e) => e.message).join(", ")}`
+          });
+          continue;
+        }
+      }
+      try {
+        const result = await publisher.publish(existing);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          channelId: publisher.id,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = await this.storage.content.update(id, {
       status: "published",
-      publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.store.set(id, published);
-    this.emitter.emit("content:published", published);
-    return published;
+      publishedAt: now,
+      updatedAt: now
+    });
+    const publishResult = { item: updated, results };
+    this.emitter.emit("content:published", publishResult);
+    return publishResult;
   }
   async unpublish(id) {
-    const existing = this.store.get(id);
+    const existing = await this.storage.content.get(id);
     if (!existing) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
-    const unpublished = {
-      ...existing,
+    const updated = await this.storage.content.update(id, {
       status: "draft",
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.store.set(id, unpublished);
-    this.emitter.emit("content:unpublished", unpublished);
-    return unpublished;
+    });
+    this.emitter.emit("content:unpublished", updated);
+    return updated;
   }
   async schedule(id, date) {
-    const existing = this.store.get(id);
+    const existing = await this.storage.content.get(id);
     if (!existing) {
       throw new NotFoundError(`Content item not found: ${id}`);
     }
-    const scheduled = {
-      ...existing,
+    const updated = await this.storage.content.update(id, {
       scheduledFor: date,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.store.set(id, scheduled);
-    this.emitter.emit("content:scheduled", { item: scheduled, date });
-    return scheduled;
+    });
+    this.emitter.emit("content:scheduled", { item: updated, date });
+    return updated;
   }
   async search(query, options) {
-    const lowerQuery = query.toLowerCase();
-    let items = Array.from(this.store.values()).filter((item) => {
-      return Object.values(item.data).some(
-        (value) => typeof value === "string" && value.toLowerCase().includes(lowerQuery)
-      );
-    });
-    if (options?.type) {
-      items = items.filter((item) => item.type === options.type);
-    }
-    if (options?.status) {
-      items = items.filter((item) => item.status === options.status);
-    }
-    const total = items.length;
-    const page = options?.page ?? 1;
-    const limit = options?.limit ?? items.length;
-    const start = (page - 1) * limit;
-    const paged = items.slice(start, start + limit);
-    return { items: paged, total, page, limit };
+    return this.storage.content.search(query, options);
   }
 };
 
 // src/namespaces/content-types.ts
+import { z as z2 } from "zod";
 var ContentTypesNamespaceImpl = class {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
   }
-  register(contentType) {
-    const id = contentType.id ?? contentType.name;
-    if (!id) {
-      throw new Error("Content type must have an id or name");
+  register(definition) {
+    if ("schema" in definition && definition.schema) {
+      const def = definition;
+      this.store.set(def.id, def);
+    } else {
+      const id = definition.id ?? definition.name;
+      if (!id) {
+        throw new Error("Content type must have an id or name");
+      }
+      const name = definition.name ?? definition.id ?? id;
+      this.store.set(id, {
+        id,
+        name,
+        schema: null
+      });
     }
-    this.store.set(id, contentType);
   }
   unregister(id) {
     if (!this.store.has(id)) {
@@ -313,25 +603,54 @@ var ContentTypesNamespaceImpl = class {
     this.store.delete(id);
   }
   get(id) {
-    const contentType = this.store.get(id);
-    if (contentType === void 0) {
-      throw new NotFoundError(`Content type not found: ${id}`);
-    }
-    return { id, contentType };
+    return this.store.get(id);
   }
   list() {
-    return Array.from(this.store.entries()).map(([id, contentType]) => ({
-      id,
-      contentType
-    }));
+    return Array.from(this.store.values());
+  }
+  validate(type, data) {
+    const def = this.store.get(type);
+    if (!def || !def.schema) {
+      return { valid: true };
+    }
+    try {
+      const schema = def.schema;
+      schema.parse(data);
+      return { valid: true };
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        return {
+          valid: false,
+          errors: error.issues.map((issue) => ({
+            message: issue.message,
+            path: issue.path.map(String)
+          }))
+        };
+      }
+      return {
+        valid: false,
+        errors: [{ message: error instanceof Error ? error.message : String(error) }]
+      };
+    }
   }
 };
 
 // src/namespaces/workflows.ts
 import * as crypto2 from "crypto";
 var WorkflowsNamespaceImpl = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
+  constructor(storage) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.storage = storage;
+  }
+  /** Load workflows from storage into cache. Called during suite initialization. */
+  async loadFromStorage() {
+    if (!this.storage) {
+      return;
+    }
+    const workflows = await this.storage.workflows.list();
+    for (const w of workflows) {
+      this.cache.set(w.id, w);
+    }
   }
   async create(input) {
     const workflow = {
@@ -341,33 +660,56 @@ var WorkflowsNamespaceImpl = class {
       ...input.stages !== void 0 ? { stages: input.stages } : {},
       ...input.transitions !== void 0 ? { transitions: input.transitions } : {}
     };
-    this.store.set(workflow.id, workflow);
+    if (this.storage) {
+      await this.storage.workflows.create(workflow);
+    }
+    this.cache.set(workflow.id, workflow);
     return workflow;
   }
   async get(id) {
-    const workflow = this.store.get(id);
+    const workflow = this.cache.get(id);
     if (!workflow) {
       throw new NotFoundError(`Workflow not found: ${id}`);
     }
     return workflow;
   }
   async list() {
-    return Array.from(this.store.values());
+    return Array.from(this.cache.values());
   }
   async update(id, input) {
-    const existing = this.store.get(id);
+    const existing = this.cache.get(id);
     if (!existing) {
       throw new NotFoundError(`Workflow not found: ${id}`);
     }
-    const updated = { ...existing, ...input };
-    this.store.set(id, updated);
+    const updated = {
+      ...existing,
+      ...input.name !== void 0 ? { name: input.name } : {},
+      ...input.description !== void 0 ? { description: input.description } : {},
+      ...input.stages !== void 0 ? { stages: input.stages } : {},
+      ...input.transitions !== void 0 ? { transitions: input.transitions } : {}
+    };
+    if (this.storage) {
+      await this.storage.workflows.update(id, updated);
+    }
+    this.cache.set(id, updated);
     return updated;
   }
   async delete(id) {
-    if (!this.store.has(id)) {
+    if (!this.cache.has(id)) {
       throw new NotFoundError(`Workflow not found: ${id}`);
     }
-    this.store.delete(id);
+    if (this.storage) {
+      const contentResult = await this.storage.content.list();
+      const assignedContent = contentResult.items.filter((item) => item.workflowId === id);
+      if (assignedContent.length > 0) {
+        throw new ConflictError(
+          `Cannot delete workflow "${id}": ${assignedContent.length} content item(s) are assigned to it. Reassign or archive them first.`,
+          { details: { assignedCount: assignedContent.length } }
+        );
+      }
+      await this.storage.workflows.delete(id);
+    }
+    this.cache.delete(id);
   }
 };
 
@@ -512,6 +854,357 @@ var PluginsNamespaceImpl = class {
   }
 };
 
+// src/namespaces/publishers.ts
+var WebsitePublisher = class {
+  constructor() {
+    this.id = "website";
+    this.name = "Website";
+    this.acceptedTypes = ["blog-post", "article", "page", "generic", "text"];
+  }
+  async publish(content) {
+    const slug = content.title ? content.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") : content.id;
+    return {
+      channelId: this.id,
+      success: true,
+      url: `/content/${slug}`
+    };
+  }
+};
+var RSSPublisher = class {
+  constructor() {
+    this.id = "rss";
+    this.name = "RSS Feed";
+    this.acceptedTypes = ["blog-post", "article", "rss-article", "generic", "text"];
+  }
+  async publish(content) {
+    return {
+      channelId: this.id,
+      success: true,
+      url: `/feed/rss/${content.id}`
+    };
+  }
+};
+var PublishersNamespaceImpl = class {
+  constructor(emitter) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.store.set("website", new WebsitePublisher());
+    this.store.set("rss", new RSSPublisher());
+  }
+  register(publisher) {
+    this.store.set(publisher.id, publisher);
+    this.emitter.emit("publisher:registered", { publisher });
+  }
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Publisher not found: ${id}`);
+    }
+    this.store.delete(id);
+  }
+  list() {
+    return Array.from(this.store.values());
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+};
+
+// src/namespaces/sources.ts
+import * as crypto4 from "crypto";
+var SourcesNamespaceImpl = class {
+  constructor(emitter, storage, workflowDefaults) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.storage = storage;
+    this.workflowDefaults = workflowDefaults;
+  }
+  register(source) {
+    this.store.set(source.id, source);
+    this.emitter.emit("source:registered", { source });
+  }
+  unregister(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Source not found: ${id}`);
+    }
+    this.store.delete(id);
+  }
+  list() {
+    return Array.from(this.store.values());
+  }
+  get(id) {
+    return this.store.get(id);
+  }
+  async ingest(sourceId, rawPayload) {
+    const source = this.store.get(sourceId);
+    if (!source) {
+      throw new NotFoundError(`Source not found: ${sourceId}`);
+    }
+    if (source.validate) {
+      const validationErrors = await source.validate(rawPayload);
+      if (validationErrors.length > 0) {
+        throw new ValidationError("Source validation failed", {
+          details: { errors: validationErrors }
+        });
+      }
+    }
+    const rawItem = await source.ingest(rawPayload);
+    if (rawItem.sourceId) {
+      const existing = await this.storage.content.findBySource(source.id, rawItem.sourceId);
+      if (existing) {
+        return { created: false, content: existing };
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workflowId = this.workflowDefaults[rawItem.type] ?? this.workflowDefaults["generic"];
+    const item = {
+      id: crypto4.randomUUID(),
+      type: rawItem.type,
+      createdAt: now,
+      status: "review",
+      sourceType: source.id,
+      sourceId: rawItem.sourceId ?? null,
+      ...rawItem.title !== void 0 ? { title: rawItem.title } : {},
+      ...rawItem.body !== void 0 ? { body: rawItem.body } : {},
+      ...rawItem.data !== void 0 ? { data: rawItem.data } : {},
+      ...rawItem.metadata !== void 0 ? { metadata: rawItem.metadata } : {},
+      ...workflowId !== void 0 ? { workflowId } : {}
+    };
+    const created = await this.storage.content.create(item);
+    this.emitter.emit("content:ingested", { item: created, sourceType: source.id });
+    this.emitter.emit("content:created", created);
+    return { created: true, content: created };
+  }
+};
+
+// src/namespaces/ai.ts
+import * as crypto5 from "crypto";
+var AINamespaceImpl = class {
+  constructor(emitter, storage, options) {
+    this.emitter = emitter;
+    this.storage = storage;
+    this.reviewService = options.reviewService;
+    this.socialGeneratorService = options.socialGeneratorService;
+    this.enhanceService = options.enhanceService;
+    this.workflowDefaults = options.workflowDefaults ?? {};
+  }
+  async review(contentId) {
+    if (!this.reviewService) {
+      throw new InternalError("AI review service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textToReview = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    const result = await this.reviewService.review(textToReview);
+    const suggestions = result.issues.map((issue) => ({
+      category: issue.category,
+      severity: issue.severity === "info" || issue.severity === "warning" || issue.severity === "error" ? issue.severity : "info",
+      message: issue.message,
+      ...issue.originalText !== void 0 ? { originalText: issue.originalText } : {},
+      ...issue.suggestedFix !== void 0 ? { suggestedFix: issue.suggestedFix } : {}
+    }));
+    const review = {
+      id: crypto5.randomUUID(),
+      contentId,
+      score: result.overallScore,
+      suggestions,
+      passesThreshold: result.passesThreshold,
+      rawResult: result.raw,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.storage.aiReviews.create(review);
+    this.emitter.emit("ai:review:completed", { contentId, review });
+    return review;
+  }
+  async generateSocialPosts(contentId, platforms) {
+    if (!this.socialGeneratorService) {
+      throw new InternalError("AI social generator service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    const generated = await this.socialGeneratorService.generate(textContent, platforms);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workflowId = this.workflowDefaults["social-post"] ?? this.workflowDefaults["generic"];
+    const posts = generated.map((g) => ({
+      id: crypto5.randomUUID(),
+      contentId,
+      platform: g.platform,
+      body: g.body,
+      status: "draft",
+      platformPostId: null,
+      publishedAt: null,
+      createdAt: now,
+      ...workflowId !== void 0 ? { workflowId } : {}
+    }));
+    for (const post of posts) {
+      await this.storage.socialPosts.create(post);
+    }
+    this.emitter.emit("ai:social:generated", { contentId, posts });
+    return posts;
+  }
+  async enhance(contentId, opts) {
+    if (!this.enhanceService) {
+      throw new InternalError("AI enhance service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    return this.enhanceService.enhance(textContent, opts);
+  }
+  async suggest(contentId) {
+    if (!this.enhanceService) {
+      throw new InternalError("AI enhance service not configured");
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    const textContent = [content.title, content.body].filter(Boolean).join("\n\n") || JSON.stringify(content.data ?? {});
+    return this.enhanceService.suggest(textContent);
+  }
+};
+
+// src/namespaces/social.ts
+var SocialNamespaceImpl = class {
+  constructor(emitter, storage) {
+    this.store = /* @__PURE__ */ new Map();
+    this.emitter = emitter;
+    this.storage = storage;
+  }
+  registerPlatform(adapter) {
+    this.store.set(adapter.id, adapter);
+  }
+  unregisterPlatform(id) {
+    if (!this.store.has(id)) {
+      throw new NotFoundError(`Social platform not found: ${id}`);
+    }
+    this.store.delete(id);
+  }
+  listPlatforms() {
+    return Array.from(this.store.values()).map((adapter) => ({
+      id: adapter.id,
+      name: adapter.name,
+      acceptedTypes: adapter.acceptedTypes,
+      hasPreview: typeof adapter.preview === "function",
+      hasMetrics: typeof adapter.getMetrics === "function"
+    }));
+  }
+  async publish(contentId, platforms) {
+    const missing = platforms.filter((p) => !this.store.has(p));
+    if (missing.length > 0) {
+      throw new ValidationError(
+        `Unregistered social platform(s): ${missing.join(", ")}`,
+        { details: { missingPlatforms: missing } }
+      );
+    }
+    const content = await this.storage.content.get(contentId);
+    if (!content) {
+      throw new NotFoundError(`Content item not found: ${contentId}`);
+    }
+    if (content.workflowId) {
+      const workflow = await this.storage.workflows.get(content.workflowId);
+      if (workflow && workflow.stages && workflow.stages.length > 0) {
+        const currentStage = workflow.stages.find((s) => s.id === content.workflowStage);
+        const publishStage = workflow.stages.find((s) => s.isPublishStage);
+        if (publishStage && (!currentStage || !currentStage.isPublishStage)) {
+          throw new ValidationError(
+            `Content is not at a publish-eligible stage. Current stage: "${content.workflowStage ?? "none"}", required publish stage: "${publishStage.id}"`,
+            {
+              details: {
+                currentStage: content.workflowStage ?? null,
+                requiredStage: publishStage.id
+              }
+            }
+          );
+        }
+      }
+    }
+    const socialPosts = await this.storage.socialPosts.findByContent(contentId);
+    const results = [];
+    for (const platformId of platforms) {
+      const adapter = this.store.get(platformId);
+      if (!adapter) {
+        continue;
+      }
+      if (!adapter.acceptedTypes.includes(content.type)) {
+        results.push({
+          platform: platformId,
+          success: false,
+          error: `Content type "${content.type}" not accepted by platform "${platformId}". Accepted: ${adapter.acceptedTypes.join(", ")}`
+        });
+        continue;
+      }
+      const post = socialPosts.find((p) => p.platform === platformId && p.status === "draft");
+      if (!post) {
+        results.push({
+          platform: platformId,
+          success: false,
+          error: `No draft social post found for platform "${platformId}"`
+        });
+        continue;
+      }
+      try {
+        const result = await adapter.publish(post);
+        results.push(result);
+        if (result.success) {
+          await this.storage.socialPosts.update(post.id, {
+            status: "published",
+            publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            ...result.platformPostId !== void 0 ? { platformPostId: result.platformPostId } : {}
+          });
+          this.emitter.emit("social:published", { contentId, platform: platformId, result });
+        } else {
+          await this.storage.socialPosts.update(post.id, { status: "failed" });
+        }
+      } catch (error) {
+        await this.storage.socialPosts.update(post.id, { status: "failed" });
+        results.push({
+          platform: platformId,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  }
+  async preview(contentId, platform) {
+    const adapter = this.store.get(platform);
+    if (!adapter) {
+      throw new NotFoundError(`Social platform not found: ${platform}`);
+    }
+    if (!adapter.preview) {
+      throw new InternalError(`Platform "${platform}" does not support preview`);
+    }
+    const posts = await this.storage.socialPosts.findByContent(contentId);
+    const post = posts.find((p) => p.platform === platform);
+    if (!post) {
+      throw new NotFoundError(`No social post found for content "${contentId}" on platform "${platform}"`);
+    }
+    return adapter.preview(post);
+  }
+  async getMetrics(contentId, platform) {
+    const adapter = this.store.get(platform);
+    if (!adapter) {
+      throw new NotFoundError(`Social platform not found: ${platform}`);
+    }
+    if (!adapter.getMetrics) {
+      throw new InternalError(`Platform "${platform}" does not support metrics`);
+    }
+    const posts = await this.storage.socialPosts.findByContent(contentId);
+    const post = posts.find((p) => p.platform === platform && p.platformPostId);
+    if (!post || !post.platformPostId) {
+      throw new NotFoundError(`No published social post found for content "${contentId}" on platform "${platform}"`);
+    }
+    return adapter.getMetrics(post.platformPostId);
+  }
+};
+
 // src/content-management-suite.ts
 var ContentManagementSuiteImpl = class extends EventEmitter {
   constructor(options) {
@@ -519,16 +1212,40 @@ var ContentManagementSuiteImpl = class extends EventEmitter {
     this._initialized = false;
     this._options = options ?? {};
     this._logger = this._options.logger;
+    this._storage = this._options.storage ?? createInMemoryAdapter();
     const parsedConfig = ContentManagementConfigSchema.parse(
       this._options.config ?? {}
     );
-    this.content = new ContentNamespaceImpl(this);
+    const workflowDefaults = this._options.workflows?.defaults ?? {};
     this.contentTypes = new ContentTypesNamespaceImpl();
-    this.workflows = new WorkflowsNamespaceImpl();
+    this.publishers = new PublishersNamespaceImpl(this);
+    this.content = new ContentNamespaceImpl(
+      this,
+      this._storage,
+      () => this.contentTypes,
+      () => this.publishers
+    );
+    this.workflows = new WorkflowsNamespaceImpl(this._storage);
     this.users = new UsersNamespaceImpl(this);
     this.permissions = new PermissionsNamespaceImpl();
     this.config = new ConfigNamespaceImpl(parsedConfig, this);
     this.plugins = new PluginsNamespaceImpl(this);
+    this.sources = new SourcesNamespaceImpl(this, this._storage, workflowDefaults);
+    const aiOpts = {};
+    if (this._options.ai?.reviewService) {
+      aiOpts.reviewService = this._options.ai.reviewService;
+    }
+    if (this._options.ai?.socialGeneratorService) {
+      aiOpts.socialGeneratorService = this._options.ai.socialGeneratorService;
+    }
+    if (this._options.ai?.enhanceService) {
+      aiOpts.enhanceService = this._options.ai.enhanceService;
+    }
+    if (Object.keys(workflowDefaults).length > 0) {
+      aiOpts.workflowDefaults = workflowDefaults;
+    }
+    this.ai = new AINamespaceImpl(this, this._storage, aiOpts);
+    this.social = new SocialNamespaceImpl(this, this._storage);
   }
   async initialize() {
     if (this._initialized) {
@@ -538,11 +1255,53 @@ var ContentManagementSuiteImpl = class extends EventEmitter {
     this.contentTypes.register({ id: "image", name: "image" });
     this.contentTypes.register({ id: "audio", name: "audio" });
     this.contentTypes.register({ id: "video", name: "video" });
+    const workflowsImpl = this.workflows;
+    if (typeof workflowsImpl.loadFromStorage === "function") {
+      await workflowsImpl.loadFromStorage();
+    }
     if (this._options.plugins) {
       for (const plugin of this._options.plugins) {
         await this.plugins.register(plugin);
       }
     }
+    this.on("ai:review:completed", async ({ contentId, review }) => {
+      try {
+        const content = await this._storage.content.get(contentId);
+        if (!content || !content.workflowId || !content.workflowStage) {
+          return;
+        }
+        const workflow = await this._storage.workflows.get(content.workflowId);
+        if (!workflow || !workflow.stages) {
+          return;
+        }
+        const currentStage = workflow.stages.find((s) => s.id === content.workflowStage);
+        if (!currentStage || !currentStage.conditions) {
+          return;
+        }
+        const { autoAdvance, minScore, requiresHumanReview } = currentStage.conditions;
+        if (requiresHumanReview) {
+          return;
+        }
+        if (autoAdvance && review.passesThreshold && (minScore === void 0 || review.score >= minScore)) {
+          const sortedStages = [...workflow.stages].sort((a, b) => a.order - b.order);
+          const currentIndex = sortedStages.findIndex((s) => s.id === currentStage.id);
+          const nextStage = sortedStages[currentIndex + 1];
+          if (nextStage) {
+            const fromStage = content.workflowStage;
+            await this._storage.content.update(contentId, {
+              workflowStage: nextStage.id
+            });
+            this.emit("workflow:stage:changed", {
+              contentId,
+              workflowId: content.workflowId,
+              from: fromStage,
+              to: nextStage.id
+            });
+          }
+        }
+      } catch {
+      }
+    });
     this._initialized = true;
     this.emit("initialized", void 0);
   }
@@ -563,36 +1322,16 @@ var ContentManagementSuiteImpl = class extends EventEmitter {
 function createContentManagementSuite(options) {
   return new ContentManagementSuiteImpl(options);
 }
-
-// src/index.ts
-import { ContentTypeRegistry } from "@bernierllc/content-type-registry";
-import { EditorialWorkflowEngine, WorkflowBuilder, WorkflowTemplates, WorkflowFactory } from "@bernierllc/content-editorial-workflow";
-import { AutosaveManager } from "@bernierllc/content-autosave-manager";
-import { ContentSoftDelete } from "@bernierllc/content-soft-delete";
-import { TextContentType } from "@bernierllc/content-type-text";
-import { ImageContentType } from "@bernierllc/content-type-image";
-import { AudioContentTypeManager } from "@bernierllc/content-type-audio";
-import { VideoContentType } from "@bernierllc/content-type-video";
 export {
-  AudioContentTypeManager,
-  AutosaveManager,
   ConflictError,
   ContentManagementConfigSchema,
   ContentManagementError,
-  ContentSoftDelete,
-  ContentTypeRegistry,
-  EditorialWorkflowEngine,
   ForbiddenError,
-  ImageContentType,
   InternalError,
   NotFoundError,
-  TextContentType,
   UnauthorizedError,
   ValidationError,
-  VideoContentType,
-  WorkflowBuilder,
-  WorkflowFactory,
-  WorkflowTemplates,
-  createContentManagementSuite
+  createContentManagementSuite,
+  createInMemoryAdapter
 };
 //# sourceMappingURL=index.mjs.map