@deftai/directive-core 0.65.0 → 0.66.1

package/dist/xbrief-migrate/transforms.js

@@ -0,0 +1,182 @@
+import { LEGACY_ARTIFACT_DIR, LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, LEGACY_VBRIEF_VERSION, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, V08_CONTAINER_ITEM_TYPES, V08_ITEM_STATUS_AUTO, VBRIEF_REFERENCE_PREFIX, VBRIEF_VERSION, XBRIEF_REFERENCE_PREFIX, } from "./constants.js";
+export class TransformError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TransformError";
+    }
+}
+export class FeatureEmissionRejectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FeatureEmissionRejectedError";
+    }
+}
+export class SplitLayoutRejectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SplitLayoutRejectedError";
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Return the artifact's declared `*BRIEFInfo.version`, if present. */
+export function readDeclaredArtifactVersion(artifact) {
+    for (const key of [MIGRATED_INFO_ROOT_KEY, LEGACY_INFO_ROOT_KEY]) {
+        const block = artifact[key];
+        if (!isPlainObject(block)) {
+            continue;
+        }
+        const version = block.version;
+        if (typeof version === "string") {
+            return version;
+        }
+    }
+    return null;
+}
+/** Rewrite embedded path and reference tokens inside a string (idempotent). */
+export function rewriteEmbeddedTokens(value) {
+    if (/^https?:\/\//i.test(value)) {
+        return value;
+    }
+    let next = value;
+    if (next.includes(VBRIEF_REFERENCE_PREFIX)) {
+        next = next.replaceAll(VBRIEF_REFERENCE_PREFIX, XBRIEF_REFERENCE_PREFIX);
+    }
+    if (next.includes(LEGACY_ARTIFACT_SUFFIX)) {
+        next = next.replaceAll(LEGACY_ARTIFACT_SUFFIX, MIGRATED_ARTIFACT_SUFFIX);
+    }
+    if (next.includes(`${LEGACY_ARTIFACT_DIR}/`)) {
+        next = next.replaceAll(`${LEGACY_ARTIFACT_DIR}/`, `${MIGRATED_ARTIFACT_DIR}/`);
+    }
+    return next;
+}
+function deepRewriteValues(value) {
+    if (typeof value === "string") {
+        return rewriteEmbeddedTokens(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => deepRewriteValues(entry));
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [key, entry] of Object.entries(value)) {
+            out[key] = deepRewriteValues(entry);
+        }
+        return out;
+    }
+    return value;
+}
+function isAlreadyV08Artifact(artifact) {
+    if (!(MIGRATED_INFO_ROOT_KEY in artifact)) {
+        return false;
+    }
+    const info = artifact[MIGRATED_INFO_ROOT_KEY];
+    return isPlainObject(info) && info.version === VBRIEF_VERSION;
+}
+/**
+ * Convert a single v0.6 in-document artifact to v0.8 semantics.
+ * Idempotent: v0.8 artifacts are returned unchanged (deep-cloned).
+ * Transactional: on failure the original input object is not mutated.
+ */
+export function transformArtifactV06ToV08(input) {
+    const working = structuredClone(input);
+    if (isAlreadyV08Artifact(working)) {
+        return working;
+    }
+    if (!(LEGACY_INFO_ROOT_KEY in working)) {
+        throw new TransformError(`missing required legacy info block '${LEGACY_INFO_ROOT_KEY}' for v0.6 -> v0.8 transform`);
+    }
+    const legacyInfo = working[LEGACY_INFO_ROOT_KEY];
+    if (!isPlainObject(legacyInfo)) {
+        throw new TransformError(`'${LEGACY_INFO_ROOT_KEY}' must be an object`);
+    }
+    const declaredVersion = legacyInfo.version;
+    if (declaredVersion !== LEGACY_VBRIEF_VERSION) {
+        throw new TransformError(`expected ${LEGACY_INFO_ROOT_KEY}.version ${LEGACY_VBRIEF_VERSION}, got ${String(declaredVersion)}`);
+    }
+    delete working[LEGACY_INFO_ROOT_KEY];
+    working[MIGRATED_INFO_ROOT_KEY] = {
+        ...legacyInfo,
+        version: VBRIEF_VERSION,
+    };
+    const rewritten = deepRewriteValues(working);
+    return rewritten;
+}
+/**
+ * Apply `transformArtifactV06ToV08` inside a try/catch boundary.
+ * On error, returns the original artifact reference unchanged.
+ */
+export function transformArtifactV06ToV08Transactional(input) {
+    try {
+        const artifact = transformArtifactV06ToV08(input);
+        const changed = JSON.stringify(artifact) !== JSON.stringify(input);
+        return { ok: true, artifact, changed };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, artifact: input, error: message };
+    }
+}
+function walkForV08FeatureEmission(value, path, violations) {
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            walkForV08FeatureEmission(value[index], `${path}[${index}]`, violations);
+        }
+        return;
+    }
+    if (!isPlainObject(value)) {
+        return;
+    }
+    if (MIGRATED_INFO_ROOT_KEY in value) {
+        violations.push(`${path}: must not emit '${MIGRATED_INFO_ROOT_KEY}' into a v0.6 artifact`);
+    }
+    if (value.status === V08_ITEM_STATUS_AUTO) {
+        violations.push(`${path}.status: must not emit '${V08_ITEM_STATUS_AUTO}' into a v0.6 artifact`);
+    }
+    if (typeof value.type === "string" && V08_CONTAINER_ITEM_TYPES.has(value.type)) {
+        violations.push(`${path}.type: must not emit container type '${value.type}' into a v0.6 artifact`);
+    }
+    for (const [key, entry] of Object.entries(value)) {
+        walkForV08FeatureEmission(entry, `${path}.${key}`, violations);
+    }
+}
+/**
+ * Locked rule #1 (#2034): refuse v0.8-only constructs unless the artifact declares v0.8.
+ * Fail closed when the version block is missing or unreadable.
+ */
+export function assertFeatureEmissionAllowed(targetArtifact, emission) {
+    const declared = readDeclaredArtifactVersion(targetArtifact);
+    if (declared === VBRIEF_VERSION) {
+        return;
+    }
+    const violations = [];
+    walkForV08FeatureEmission(emission, "emission", violations);
+    if (violations.length === 0) {
+        return;
+    }
+    const context = declared === null
+        ? "artifact has no declared version"
+        : `artifact declares version ${declared}`;
+    throw new FeatureEmissionRejectedError(`${context}; ${violations.join("; ")}`);
+}
+/** Map a desired migrated-relative path to the legacy tree when required. */
+export function resolveLayoutAwareRelativePath(legacyLayout, relativePath) {
+    if (!legacyLayout) {
+        return relativePath;
+    }
+    return relativePath
+        .replaceAll(`${MIGRATED_ARTIFACT_DIR}/`, `${LEGACY_ARTIFACT_DIR}/`)
+        .replaceAll(MIGRATED_ARTIFACT_SUFFIX, LEGACY_ARTIFACT_SUFFIX);
+}
+/**
+ * Locked rule #2 (#2034): never target `xbrief/` when the project still uses `vbrief/`.
+ */
+export function assertLayoutAwareWritePath(projectRoot, relativePath, legacyLayout) {
+    const normalized = relativePath.replace(/\\/g, "/");
+    if (legacyLayout && normalized.includes(`${MIGRATED_ARTIFACT_DIR}/`)) {
+        throw new SplitLayoutRejectedError(`refusing to write into '${MIGRATED_ARTIFACT_DIR}/' while legacy '${LEGACY_ARTIFACT_DIR}/' layout is present at ${projectRoot}`);
+    }
+    return resolveLayoutAwareRelativePath(legacyLayout, normalized);
+}
+//# sourceMappingURL=transforms.js.map

package/dist/xbrief-migrate/version.d.ts

@@ -0,0 +1,8 @@
+/** Parse a semver prefix from a deft version marker or manifest tag. */
+export declare function parseSemverPrefix(version: string): [number, number, number] | null;
+/**
+ * True when `to` is a strict patch bump over `from` (same major/minor, higher patch).
+ * Non-semver inputs are treated as not patch-only (#2034 patch-inert rule).
+ */
+export declare function isPatchOnlyUpgrade(from: string | null, to: string): boolean;
+//# sourceMappingURL=version.d.ts.map

package/dist/xbrief-migrate/version.js

@@ -0,0 +1,25 @@
+/** Parse a semver prefix from a deft version marker or manifest tag. */
+export function parseSemverPrefix(version) {
+    const normalized = version.trim().replace(/^v/i, "");
+    const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/**
+ * True when `to` is a strict patch bump over `from` (same major/minor, higher patch).
+ * Non-semver inputs are treated as not patch-only (#2034 patch-inert rule).
+ */
+export function isPatchOnlyUpgrade(from, to) {
+    if (from === null) {
+        return false;
+    }
+    const a = parseSemverPrefix(from);
+    const b = parseSemverPrefix(to);
+    if (a === null || b === null) {
+        return false;
+    }
+    return a[0] === b[0] && a[1] === b[1] && b[2] > a[2];
+}
+//# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deftai/directive-core",
-  "version": "0.65.0",
+  "version": "0.66.1",
   "description": "TypeScript engine core for the Directive framework.",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,14 @@
       "types": "./dist/wip-cap/index.d.ts",
       "default": "./dist/wip-cap/index.js"
     },
+    "./xbrief-migrate": {
+      "types": "./dist/xbrief-migrate/index.d.ts",
+      "default": "./dist/xbrief-migrate/index.js"
+    },
+    "./category-b-namespace": {
+      "types": "./dist/category-b-namespace/index.d.ts",
+      "default": "./dist/category-b-namespace/index.js"
+    },
     "./scm": {
       "types": "./dist/scm/index.d.ts",
       "default": "./dist/scm/index.js"
@@ -229,8 +237,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@deftai/directive-content": "^0.65.0",
-    "@deftai/directive-types": "^0.65.0",
+    "@deftai/directive-content": "^0.66.1",
+    "@deftai/directive-types": "^0.66.1",
     "archiver": "^8.0.0"
   },
   "scripts": {