@deployxai/dxc 0.1.5 → 0.1.7

package/dist/chunks/{chunk-JGUPNE36.js → chunk-N4CMLINP.js}

@@ -605,9 +605,21 @@ var publishingApprovalSchema = z4.object({
   accountId: z4.uuid(),
   confirmedAt: z4.iso.datetime(),
   id: z4.uuid(),
+  rootSnapshotHash: sha256Schema,
+  rootSnapshotId: z4.uuid(),
+  selectedSnapshotHash: sha256Schema,
+  selectedSnapshotId: z4.uuid(),
   snapshotHash: sha256Schema,
-  snapshotId: z4.uuid()
-}).strict();
+  snapshotId: z4.uuid(),
+  templateId: wechatTemplateIdSchema
+}).strict().superRefine((approval, context) => {
+  if (approval.snapshotId !== approval.selectedSnapshotId || approval.snapshotHash !== approval.selectedSnapshotHash) {
+    context.addIssue({
+      code: "custom",
+      message: "legacy snapshot aliases must identify the selected snapshot"
+    });
+  }
+});
 var createPublishingDraftIntentRequestSchema = z4.object({
   approvalId: z4.uuid()
 }).strict();
@@ -668,33 +680,33 @@ var contentArtifactKindSchema = z5.enum(CONTENT_ARTIFACT_KINDS);
 var CONTENT_STAGE_SKILLS = {
   article: { name: "dxc-article-write", version: "0.1.0" },
   brief: { name: "dxc-content-brief", version: "0.1.0" },
-  delivery: { name: "dxc-wechat-publisher", version: "0.5.0" },
+  delivery: { name: "dxc-wechat-publisher", version: "0.6.0" },
   outline: { name: "dxc-article-outline", version: "0.1.0" },
   "quality-review": { name: "dxc-content-review", version: "0.3.0" },
-  research: { name: "dxc-research", version: "0.1.0" },
+  research: { name: "dxc-research", version: "0.2.0" },
   titles: { name: "dxc-title-write", version: "0.3.0" },
   "visual-plan": { name: "dxc-visual-plan", version: "0.3.0" }
 };
 var CONTENT_STAGE_INPUTS = {
   article: {
-    optional: ["research"],
-    required: ["brief", "outline"]
+    optional: [],
+    required: ["research", "brief", "outline"]
   },
   brief: {
     optional: [],
     required: ["research"]
   },
   delivery: {
-    optional: ["visual-plan", "quality-review"],
-    required: ["article", "titles"]
+    optional: [],
+    required: ["article", "titles", "visual-plan", "quality-review"]
   },
   outline: {
-    optional: ["research"],
-    required: ["brief"]
+    optional: [],
+    required: ["research", "brief"]
   },
   "quality-review": {
-    optional: ["research", "visual-plan"],
-    required: ["article", "titles"]
+    optional: ["visual-plan"],
+    required: ["research", "article", "titles"]
   },
   research: {
     optional: [],
@@ -824,14 +836,128 @@ var contentStageMetadataBaseShape = {
   skill: z5.string().regex(/^dxc-[a-z0-9]+(?:-[a-z0-9]+)*@\d+\.\d+\.\d+$/u),
   workflowId: z5.literal(CONTENT_WORKFLOW_ID)
 };
+var researchSourceSchema = z5.object({
+  id: z5.string().regex(/^source-[a-z0-9][a-z0-9-]{0,63}$/u),
+  locator: z5.string().trim().min(1).max(2048),
+  observedAt: z5.iso.datetime(),
+  stance: z5.enum(["support", "oppose", "supplement", "neutral", "not-applicable"]),
+  type: z5.enum(["primary", "public-fact", "public-opinion", "local-history", "user-provided"]),
+  verification: z5.enum(["verified", "unverified"])
+}).strict().superRefine((value, context) => {
+  if (["primary", "public-fact", "public-opinion"].includes(value.type)) {
+    try {
+      const url = new URL(value.locator);
+      if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("unsupported protocol");
+      }
+    } catch {
+      context.addIssue({
+        code: "custom",
+        message: "public research sources require a complete HTTP(S) URL",
+        path: ["locator"]
+      });
+    }
+  }
+  if (value.type === "public-opinion" && !["support", "oppose", "supplement"].includes(value.stance)) {
+    context.addIssue({
+      code: "custom",
+      message: "public opinion sources require a stance",
+      path: ["stance"]
+    });
+  }
+});
+var researchStanceCoverageSchema = z5.object({
+  oppose: z5.enum(["covered", "not-found", "not-applicable"]),
+  supplement: z5.enum(["covered", "not-found", "not-applicable"]),
+  support: z5.enum(["covered", "not-found", "not-applicable"])
+}).strict();
 var researchStageArtifactFrontmatterSchema = z5.object({
+  coverageNote: z5.string().trim().min(1).max(1e3),
   dxc: z5.object({
     ...contentStageMetadataBaseShape,
     stage: z5.literal("research")
   }).strict(),
+  externalOpinionStatus: z5.enum(["covered", "not-applicable", "user-skipped"]),
   origin: z5.enum(["hotspot", "article", "keywords", "intent"]),
-  sourceCount: z5.number().int().nonnegative()
-}).strict();
+  researchMode: z5.enum(["fact-only", "viewpoint-scan"]),
+  sourceCount: z5.number().int().nonnegative(),
+  sources: z5.array(researchSourceSchema).max(100),
+  stanceCoverage: researchStanceCoverageSchema
+}).strict().superRefine((value, context) => {
+  if (value.sourceCount !== value.sources.length) {
+    context.addIssue({
+      code: "custom",
+      message: "sourceCount must equal the number of structured sources",
+      path: ["sourceCount"]
+    });
+  }
+  if (new Set(value.sources.map((source) => source.id)).size !== value.sources.length) {
+    context.addIssue({
+      code: "custom",
+      message: "research source ids must be unique",
+      path: ["sources"]
+    });
+  }
+  if (new Set(value.sources.map((source) => source.locator)).size !== value.sources.length) {
+    context.addIssue({
+      code: "custom",
+      message: "research source locators must be unique",
+      path: ["sources"]
+    });
+  }
+  if (value.researchMode === "fact-only") {
+    const expectedStatus = value.origin === "hotspot" ? "user-skipped" : "not-applicable";
+    if (value.externalOpinionStatus !== expectedStatus) {
+      context.addIssue({
+        code: "custom",
+        message: `fact-only ${value.origin} research requires externalOpinionStatus ${expectedStatus}`,
+        path: ["externalOpinionStatus"]
+      });
+    }
+    if (Object.values(value.stanceCoverage).some((coverage) => coverage !== "not-applicable")) {
+      context.addIssue({
+        code: "custom",
+        message: "fact-only research must mark stance coverage not-applicable",
+        path: ["stanceCoverage"]
+      });
+    }
+    return;
+  }
+  if (value.externalOpinionStatus !== "covered") {
+    context.addIssue({
+      code: "custom",
+      message: "viewpoint-scan research requires covered external opinions",
+      path: ["externalOpinionStatus"]
+    });
+  }
+  const opinionSources = value.sources.filter(
+    (source) => source.type === "public-opinion" && source.verification === "verified"
+  );
+  if (opinionSources.length < 3) {
+    context.addIssue({
+      code: "custom",
+      message: "viewpoint-scan research requires at least three verified public opinions",
+      path: ["sources"]
+    });
+  }
+  for (const stance of ["support", "supplement"]) {
+    if (value.stanceCoverage[stance] !== "covered" || !opinionSources.some((source) => source.stance === stance)) {
+      context.addIssue({
+        code: "custom",
+        message: `viewpoint-scan research requires covered ${stance} material`,
+        path: ["stanceCoverage", stance]
+      });
+    }
+  }
+  const hasOpposition = opinionSources.some((source) => source.stance === "oppose");
+  if (hasOpposition && value.stanceCoverage.oppose !== "covered" || !hasOpposition && value.stanceCoverage.oppose !== "not-found") {
+    context.addIssue({
+      code: "custom",
+      message: "opposition coverage must be covered or explicitly recorded as not-found",
+      path: ["stanceCoverage", "oppose"]
+    });
+  }
+});
 var briefStageArtifactFrontmatterSchema = z5.object({
   dxc: z5.object({
     ...contentStageMetadataBaseShape,
@@ -866,6 +992,7 @@ var articleStageArtifactFrontmatterSchema = z5.object({
     quoteSnapshots: z5.array(contentQuoteSnapshotSchema).max(50).default([]),
     stage: z5.literal("article")
   }).strict(),
+  dxc_wechat_template_hint: z5.string().trim().min(1).optional(),
   goldenLinesPath: portableRelativePathSchema,
   goldenLinesSha256: z5.string().regex(/^[a-f0-9]{64}$/u),
   tags: z5.array(z5.string().trim().min(1)).default([]),
@@ -932,6 +1059,7 @@ var qualityReviewStageArtifactFrontmatterSchema = z5.object({
     stage: z5.literal("quality-review")
   }).strict(),
   verdict: z5.enum(["pass", "block"]),
+  researchCoverage: z5.enum(["not-applicable", "pass", "warning"]),
   warningCount: z5.number().int().nonnegative()
 }).strict().superRefine((value, context) => {
   if (value.verdict === "pass" && value.blockerCount !== 0) {
@@ -948,6 +1076,13 @@ var qualityReviewStageArtifactFrontmatterSchema = z5.object({
       path: ["blockerCount"]
     });
   }
+  if (value.researchCoverage === "warning" && value.warningCount === 0) {
+    context.addIssue({
+      code: "custom",
+      message: "research coverage warnings must be counted",
+      path: ["warningCount"]
+    });
+  }
 });
 var deliveryStageArtifactFrontmatterSchema = z5.object({
   accountId: z5.uuid(),
@@ -959,9 +1094,12 @@ var deliveryStageArtifactFrontmatterSchema = z5.object({
   intentId: z5.uuid().nullable(),
   mediaId: z5.string().trim().min(1).max(256).nullable().optional(),
   previewExpiresAt: z5.iso.datetime(),
-  snapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
-  snapshotId: z5.uuid(),
-  state: z5.enum(["previewed", "processing", "completed", "requires-attention", "failed"])
+  rootSnapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
+  rootSnapshotId: z5.uuid(),
+  selectedSnapshotHash: z5.string().regex(/^[a-f0-9]{64}$/u),
+  selectedSnapshotId: z5.uuid(),
+  state: z5.enum(["previewed", "processing", "completed", "requires-attention", "failed"]),
+  templateId: z5.string().regex(/^wechat-[a-z0-9-]+@\d+$/u)
 }).strict().superRefine((value, context) => {
   if (value.dxc.artifactStatus === "complete" && (value.state !== "completed" || value.intentId === null || value.mediaId === void 0 || value.mediaId === null)) {
     context.addIssue({
@@ -1476,6 +1614,8 @@ var contentProfileErrorResultSchema = z5.object({
   command: contentProfileCommandSchema,
   error: z5.object({
     code: z5.enum(["DXC_PROFILE_INPUT_INVALID", "DXC_PROFILE_INVALID", "DXC_PROFILE_IO_FAILED"]),
+    fields: z5.array(z5.string().trim().min(1)).optional(),
+    hint: z5.string().trim().min(1).optional(),
     message: z5.string().trim().min(1)
   }).strict(),
   ok: z5.literal(false)

package/dist/chunks/{chunk-GCGIIKQJ.js → chunk-NAL5UOUZ.js}

@@ -1,7 +1,7 @@
 import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
 import {
   sourceFetchResultSchema
-} from "./chunk-JGUPNE36.js";
+} from "./chunk-N4CMLINP.js";
 
 // apps/cli/src/source.ts
 import { createHash } from "node:crypto";

package/dist/chunks/chunk-ZKJQWR2J.js

@@ -0,0 +1,37 @@
+import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
+
+// apps/cli/src/user-path.ts
+import path from "node:path";
+function expandHome(input, homeDirectory, pathApi) {
+  if (input === "~") {
+    return homeDirectory;
+  }
+  if (input.startsWith("~/") || input.startsWith("~\\")) {
+    return pathApi.join(homeDirectory, input.slice(2));
+  }
+  return input;
+}
+function windowsShellPath(input) {
+  const msys = /^\/([a-z])(?:\/(.*))?$/iu.exec(input);
+  if (msys !== null) {
+    return `${msys[1]?.toUpperCase()}:\\${(msys[2] ?? "").replaceAll("/", "\\")}`;
+  }
+  const mounted = /^\/(?:cygdrive|mnt)\/([a-z])(?:\/(.*))?$/iu.exec(input);
+  if (mounted !== null) {
+    return `${mounted[1]?.toUpperCase()}:\\${(mounted[2] ?? "").replaceAll("/", "\\")}`;
+  }
+  return input;
+}
+function resolveUserPath(options) {
+  const platform = options.platform ?? process.platform;
+  const pathApi = platform === "win32" ? path.win32 : path.posix;
+  const expanded = expandHome(options.input, options.homeDirectory, pathApi);
+  if (platform === "win32") {
+    return pathApi.resolve(options.currentDirectory, windowsShellPath(expanded));
+  }
+  return pathApi.resolve(options.currentDirectory, expanded);
+}
+
+export {
+  resolveUserPath
+};

package/dist/chunks/{knowledge-6LOGJETT.js → knowledge-PWFALFEC.js}

@@ -1,4 +1,7 @@
 import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
+import {
+  resolveUserPath
+} from "./chunk-ZKJQWR2J.js";
 import {
   CONTENT_KNOWLEDGE_CHUNKER_VERSION,
   CONTENT_KNOWLEDGE_EMBEDDING_DIMENSIONS,
@@ -24,7 +27,7 @@ import {
   readPrivateFile,
   writePrivateBuffer,
   writePrivateJson
-} from "./chunk-JGUPNE36.js";
+} from "./chunk-N4CMLINP.js";
 
 // apps/cli/src/knowledge.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
@@ -588,8 +591,8 @@ ${paragraph.text}`;
     sha256: sha2562(chunk.body)
   }));
 }
-async function prepareArticle(currentDirectory, inputPath) {
-  const absolutePath = path2.resolve(currentDirectory, inputPath);
+async function prepareArticle(currentDirectory, homeDirectory, inputPath) {
+  const absolutePath = resolveUserPath({ currentDirectory, homeDirectory, input: inputPath });
   const extension = path2.extname(absolutePath).toLowerCase();
   if (!SUPPORTED_EXTENSIONS.has(extension)) {
     throw new KnowledgeCliError(
@@ -640,8 +643,8 @@ async function prepareArticle(currentDirectory, inputPath) {
     title: extractTitle(content, sourceLabel)
   };
 }
-async function directoryArticles(currentDirectory, directoryInput) {
-  const root = path2.resolve(currentDirectory, directoryInput);
+async function directoryArticles(currentDirectory, homeDirectory, directoryInput) {
+  const root = resolveUserPath({ currentDirectory, homeDirectory, input: directoryInput });
   let metadata;
   try {
     metadata = await lstat(root);
@@ -1726,7 +1729,7 @@ var KnowledgeCli = class {
       for (const file of options.files) {
         let article;
         try {
-          article = await prepareArticle(this.#currentDirectory, file);
+          article = await prepareArticle(this.#currentDirectory, this.#homeDirectory, file);
         } catch (error) {
           const skippedItem = skippedArticle(error, file);
           if (skippedItem !== void 0) {
@@ -1782,7 +1785,7 @@ var KnowledgeCli = class {
   }
   async importDirectory(directory, lexicalOnly) {
     return this.importArticles({
-      files: await directoryArticles(this.#currentDirectory, directory),
+      files: await directoryArticles(this.#currentDirectory, this.#homeDirectory, directory),
       lexicalOnly
     });
   }

package/dist/chunks/{monitor-CYJPUX5V.js → monitor-CL5UXEO2.js}

@@ -2,7 +2,7 @@ import { createRequire as __dxcCreateRequire } from "node:module"; const require
 import {
   SourceCli,
   SourceCliError
-} from "./chunk-GCGIIKQJ.js";
+} from "./chunk-NAL5UOUZ.js";
 import {
   CONTENT_MONITOR_SCHEMA_VERSION,
   LocalStateError,
@@ -14,7 +14,7 @@ import {
   contentMonitorStatusResultSchema,
   ensurePrivateRegularFile,
   sourceFetchKindSchema
-} from "./chunk-JGUPNE36.js";
+} from "./chunk-N4CMLINP.js";
 
 // apps/cli/src/monitor.ts
 import { createHash, randomUUID as systemRandomUUID } from "node:crypto";