@dcoder-x/plugin-shared 0.1.3 → 0.1.5

package/dist/upload/PackageBuilder.js

@@ -5,16 +5,236 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackageBuilder = void 0;
 const zlib_1 = __importDefault(require("zlib"));
+const path_1 = __importDefault(require("path"));
+const IdStrategy_1 = require("../injection/IdStrategy");
 class PackageBuilder {
+    constructor() {
+        this.version = '1.0.0';
+    }
     buildPackage(data) {
         return {
             ...data,
             generatedAt: new Date().toISOString(),
         };
     }
+    buildArtifacts(data) {
+        const generatedAt = new Date().toISOString();
+        const policy = this.buildPolicyDocument({
+            ...data,
+            generatedAt,
+        });
+        const selectorManifest = this.buildSelectorManifest({
+            buildId: data.buildId,
+            generatedAt,
+            selectors: policy.selectors,
+        });
+        return {
+            metadata: {
+                version: this.version,
+                buildId: data.buildId,
+                generatedAt,
+                bundler: data.bundler,
+            },
+            policy,
+            selectorManifest,
+        };
+    }
+    buildPolicyDocument(data) {
+        const projectRoot = this.inferProjectRoot(data.routes);
+        const normalizedRoutes = data.routes.map((r) => ({
+            ...r,
+            filePath: this.normalizePath(r.filePath, projectRoot),
+            layout: r.layout ? this.normalizePath(r.layout, projectRoot) : null,
+        }));
+        const policySelectors = this.toPolicySelectors(data.selectors, projectRoot);
+        return {
+            version: this.version,
+            buildId: data.buildId,
+            generatedAt: data.generatedAt,
+            bundler: data.bundler,
+            routes: normalizedRoutes,
+            selectors: policySelectors,
+            components: data.components ?? this.toPolicyComponents(data.selectors),
+            flows: this.toPolicyFlows(data.flows, normalizedRoutes, policySelectors),
+        };
+    }
+    buildSelectorManifest(data) {
+        // Deduplicate by clippyId — shared components used on multiple routes appear once
+        // with a routes[] array listing every route where they appear.
+        const byId = new Map();
+        for (const entry of data.selectors) {
+            if (byId.has(entry.clippyId)) {
+                const existing = byId.get(entry.clippyId);
+                if (!existing.routes.includes(entry.route)) {
+                    existing.routes.push(entry.route);
+                }
+            }
+            else {
+                byId.set(entry.clippyId, {
+                    id: entry.clippyId,
+                    selector: entry.selector,
+                    component: entry.component,
+                    tag: entry.tag,
+                    label: entry.label,
+                    routes: [entry.route],
+                });
+            }
+        }
+        return {
+            version: this.version,
+            buildId: data.buildId,
+            generatedAt: data.generatedAt,
+            selectors: Array.from(byId.values()),
+        };
+    }
     build(data) {
         const pkg = this.buildPackage(data);
         return zlib_1.default.gzipSync(JSON.stringify(pkg));
     }
+    buildArtifactsBuffer(artifacts) {
+        return zlib_1.default.gzipSync(JSON.stringify(artifacts));
+    }
+    inferProjectRoot(routes) {
+        const filePaths = routes.map((r) => r.filePath).filter(Boolean);
+        if (filePaths.length === 0)
+            return process.cwd();
+        // Find the longest common directory prefix across all route file paths
+        const parts = filePaths[0].replace(/\\/g, '/').split('/');
+        let commonParts = parts;
+        for (const fp of filePaths.slice(1)) {
+            const fpParts = fp.replace(/\\/g, '/').split('/');
+            const len = Math.min(commonParts.length, fpParts.length);
+            let i = 0;
+            while (i < len && commonParts[i] === fpParts[i])
+                i++;
+            commonParts = commonParts.slice(0, i);
+        }
+        return commonParts.join('/') || process.cwd();
+    }
+    normalizePath(filePath, projectRoot) {
+        try {
+            const rel = path_1.default.relative(projectRoot, filePath).replace(/\\/g, '/');
+            return rel.startsWith('..') ? filePath.replace(/\\/g, '/') : rel;
+        }
+        catch {
+            return filePath.replace(/\\/g, '/');
+        }
+    }
+    toPolicySelectors(selectors, projectRoot) {
+        return selectors
+            .filter((element) => !element.isNavigationLink)
+            .map((element, index) => {
+            const component = element.component || (0, IdStrategy_1.deriveComponentName)(element.filePath);
+            const preferred = element.selectors.find((candidate) => candidate.type === 'clippy_id') ||
+                element.selectors[0];
+            const stableLine = element.loc?.line ?? index;
+            const clippyId = preferred?.type === 'clippy_id'
+                ? this.extractClippyIdFromSelector(preferred.value) ||
+                    this.deriveStableId(component, element.tag, stableLine)
+                : this.deriveStableId(component, element.tag, stableLine);
+            const selector = preferred?.value ||
+                `[data-clippy-id='${clippyId}']`;
+            return {
+                clippyId,
+                selector,
+                tag: element.tag,
+                component,
+                label: element.label,
+                route: element.route,
+                filePath: projectRoot ? this.normalizePath(element.filePath, projectRoot) : element.filePath.replace(/\\/g, '/'),
+                attributes: Object.entries(element.staticProps).map(([name, value]) => ({ name, value })),
+                candidates: element.selectors,
+            };
+        });
+    }
+    toPolicyComponents(selectors) {
+        const byFile = new Map();
+        for (const element of selectors) {
+            if (element.isNavigationLink)
+                continue;
+            if (!byFile.has(element.filePath))
+                byFile.set(element.filePath, []);
+            byFile.get(element.filePath).push(element);
+        }
+        return Array.from(byFile.entries()).map(([filePath, items]) => {
+            // Prefer the component name captured during extraction over the filename
+            const componentName = items.find((i) => i.component)?.component ||
+                this.deriveComponentName(filePath);
+            const route = items[0]?.route || '/';
+            return {
+                name: componentName,
+                filePath,
+                route,
+                stateVariables: [],
+                interactions: [],
+            };
+        });
+    }
+    toPolicyFlows(flows, routes, selectors) {
+        return flows.map((flow, flowIndex) => {
+            const firstRoute = flow.steps[0] || '/';
+            const page = flow.page || routes.find((r) => r.path === firstRoute)?.path || firstRoute;
+            const steps = flow.steps.map((routePath, stepIndex) => {
+                // For transition steps (not the first), find the edge that leads to this route
+                // and try to match its trigger text to a specific selector
+                const incomingEdge = stepIndex > 0
+                    ? flow.edges.find((e) => e.to === routePath)
+                    : null;
+                let target;
+                if (incomingEdge?.trigger && incomingEdge.trigger !== 'link') {
+                    // Try to find the specific triggering element by label match
+                    const fromRoute = incomingEdge.from;
+                    const byLabel = selectors.find((s) => s.route === fromRoute &&
+                        s.label?.toLowerCase() === incomingEdge.trigger.toLowerCase());
+                    const byAttr = !byLabel
+                        ? selectors.find((s) => s.route === fromRoute &&
+                            s.attributes.some((a) => a.value.toLowerCase() === incomingEdge.trigger.toLowerCase()))
+                        : null;
+                    target = (byLabel || byAttr)?.selector;
+                }
+                // Fallback: first selector on the destination route
+                if (!target) {
+                    target =
+                        selectors.find((s) => s.route === routePath)?.selector ||
+                            `[data-clippy-route='${routePath}']`;
+                }
+                const isFirst = stepIndex === 0;
+                const isInteractionStep = flow.edges.some((e) => e.from === e.to && e.trigger?.startsWith('on'));
+                return {
+                    step: stepIndex + 1,
+                    action: isFirst
+                        ? isInteractionStep ? 'interact' : 'navigate'
+                        : 'transition',
+                    target,
+                };
+            });
+            const intentPatterns = flow.intentPatterns && flow.intentPatterns.length > 0
+                ? flow.intentPatterns
+                : [flow.name.toLowerCase()];
+            return {
+                flowId: flow.id || `flow_${flowIndex + 1}`,
+                page,
+                intentPatterns,
+                steps,
+            };
+        });
+    }
+    deriveComponentName(filePath) {
+        return (0, IdStrategy_1.deriveComponentName)(filePath);
+    }
+    deriveStableId(component, tag, line) {
+        return (0, IdStrategy_1.deriveClippyId)(component, tag, line);
+    }
+    extractClippyIdFromSelector(selector) {
+        const match = selector.match(/\[data-clippy-id=['\"]([^'\"]+)['\"]\]/);
+        return match?.[1] || null;
+    }
+    simpleHash(input) {
+        let hash = 0;
+        for (let i = 0; i < input.length; i++) {
+            hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+        }
+        return hash.toString(36);
+    }
 }
 exports.PackageBuilder = PackageBuilder;

package/dist/upload/PackageWriter.d.ts

@@ -1,7 +1,15 @@
-import type { KnowledgePackage } from '../types';
+import type { KnowledgePackage, PolicyArtifacts } from '../types';
 export declare class PackageWriter {
     write(outputDir: string, knowledgePackage: KnowledgePackage): {
         jsonPath: string;
         gzipPath: string;
     };
+    writeArtifacts(outputDir: string, artifacts: PolicyArtifacts, options?: {
+        gzip?: boolean;
+    }): {
+        policyPath: string;
+        selectorsPath: string;
+        policyGzipPath?: string;
+        selectorsGzipPath?: string;
+    };
 }

package/dist/upload/PackageWriter.js

@@ -18,5 +18,31 @@ class PackageWriter {
         fs_1.default.writeFileSync(gzipPath, zlib_1.default.gzipSync(content));
         return { jsonPath, gzipPath };
     }
+    writeArtifacts(outputDir, artifacts, options) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        const policyPath = path_1.default.join(outputDir, 'clippy-policy.json');
+        const selectorsPath = path_1.default.join(outputDir, 'clippy-selectors.json');
+        const policyContent = JSON.stringify(artifacts.policy, null, 2);
+        const selectorsContent = JSON.stringify(artifacts.selectorManifest, null, 2);
+        fs_1.default.writeFileSync(policyPath, policyContent, 'utf-8');
+        fs_1.default.writeFileSync(selectorsPath, selectorsContent, 'utf-8');
+        const shouldGzip = options?.gzip ?? true;
+        if (!shouldGzip) {
+            return {
+                policyPath,
+                selectorsPath,
+            };
+        }
+        const policyGzipPath = `${policyPath}.gz`;
+        const selectorsGzipPath = `${selectorsPath}.gz`;
+        fs_1.default.writeFileSync(policyGzipPath, zlib_1.default.gzipSync(policyContent));
+        fs_1.default.writeFileSync(selectorsGzipPath, zlib_1.default.gzipSync(selectorsContent));
+        return {
+            policyPath,
+            selectorsPath,
+            policyGzipPath,
+            selectorsGzipPath,
+        };
+    }
 }
 exports.PackageWriter = PackageWriter;

package/dist/upload/UploadStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { PolicyArtifacts } from '../types';
+export interface ArtifactRequest {
+    endpoint: string;
+    payload: Buffer;
+    extraHeaders?: Record<string, string>;
+}
+declare const POLICY_ENDPOINT = "https://api.clippy.dev/v1/policy";
+declare const SELECTORS_ENDPOINT = "https://api.clippy.dev/v1/selectors";
+declare const BUNDLE_ENDPOINT = "https://api.clippy.dev/v1/policy-artifacts";
+export declare function buildArtifactRequests(artifacts: PolicyArtifacts, mode: 'single' | 'split'): ArtifactRequest[];
+export { POLICY_ENDPOINT, SELECTORS_ENDPOINT, BUNDLE_ENDPOINT };

package/dist/upload/UploadStrategy.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUNDLE_ENDPOINT = exports.SELECTORS_ENDPOINT = exports.POLICY_ENDPOINT = void 0;
+exports.buildArtifactRequests = buildArtifactRequests;
+const zlib_1 = __importDefault(require("zlib"));
+const POLICY_ENDPOINT = 'https://api.clippy.dev/v1/policy';
+exports.POLICY_ENDPOINT = POLICY_ENDPOINT;
+const SELECTORS_ENDPOINT = 'https://api.clippy.dev/v1/selectors';
+exports.SELECTORS_ENDPOINT = SELECTORS_ENDPOINT;
+const BUNDLE_ENDPOINT = 'https://api.clippy.dev/v1/policy-artifacts';
+exports.BUNDLE_ENDPOINT = BUNDLE_ENDPOINT;
+function buildArtifactRequests(artifacts, mode) {
+    if (mode === 'split') {
+        const policyPayload = zlib_1.default.gzipSync(JSON.stringify(artifacts.policy));
+        const selectorsPayload = zlib_1.default.gzipSync(JSON.stringify(artifacts.selectorManifest));
+        return [
+            {
+                endpoint: POLICY_ENDPOINT,
+                payload: policyPayload,
+                extraHeaders: { 'X-Clippy-Artifact': 'policy' },
+            },
+            {
+                endpoint: SELECTORS_ENDPOINT,
+                payload: selectorsPayload,
+                extraHeaders: { 'X-Clippy-Artifact': 'selectors' },
+            },
+        ];
+    }
+    const bundle = zlib_1.default.gzipSync(JSON.stringify(artifacts));
+    return [
+        {
+            endpoint: BUNDLE_ENDPOINT,
+            payload: bundle,
+            extraHeaders: { 'X-Clippy-Artifact': 'bundle' },
+        },
+    ];
+}

package/dist/upload/Uploader.d.ts

@@ -1,10 +1,15 @@
-import type { ClippyPluginOptions } from '../types';
+import type { ClippyPluginOptions, PolicyArtifacts, UploadResult } from '../types';
 export declare class Uploader {
     private options;
     private endpoint;
+    private policyArtifactsEndpoint;
+    private policyEndpoint;
+    private selectorsEndpoint;
     private requestTimeoutMs;
     private maxAttempts;
     constructor(options: ClippyPluginOptions);
     upload(compressedPackage: Buffer): Promise<boolean>;
+    uploadArtifacts(artifacts: PolicyArtifacts): Promise<UploadResult>;
+    private uploadWithRetry;
     private uploadOnce;
 }

package/dist/upload/Uploader.js

@@ -5,10 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uploader = void 0;
 const https_1 = __importDefault(require("https"));
+const UploadStrategy_1 = require("./UploadStrategy");
 class Uploader {
     constructor(options) {
         this.options = options;
         this.endpoint = 'https://api.clippy.dev/v1/knowledge';
+        this.policyArtifactsEndpoint = 'https://api.clippy.dev/v1/policy-artifacts';
+        this.policyEndpoint = 'https://api.clippy.dev/v1/policy';
+        this.selectorsEndpoint = 'https://api.clippy.dev/v1/selectors';
         this.requestTimeoutMs = 10000;
         this.maxAttempts = 3;
     }
@@ -18,7 +22,7 @@ class Uploader {
         let lastError = null;
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
             try {
-                await this.uploadOnce(compressedPackage);
+                await this.uploadOnce(this.endpoint, compressedPackage);
                 return true;
             }
             catch (err) {
@@ -30,7 +34,47 @@ class Uploader {
         }
         throw lastError || new Error('Upload failed after retries');
     }
-    async uploadOnce(compressedPackage) {
+    async uploadArtifacts(artifacts) {
+        if (this.options.skipUpload) {
+            return {
+                skipped: true,
+                policyUploaded: false,
+                selectorsUploaded: false,
+                mode: this.options.artifactUploadMode || 'single',
+            };
+        }
+        const mode = this.options.artifactUploadMode || 'single';
+        const requests = (0, UploadStrategy_1.buildArtifactRequests)(artifacts, mode);
+        for (const req of requests) {
+            await this.uploadWithRetry(req.endpoint, req.payload, {
+                ...(req.extraHeaders || {}),
+                'X-Build-Id': artifacts.metadata.buildId,
+            });
+        }
+        return {
+            skipped: false,
+            policyUploaded: true,
+            selectorsUploaded: true,
+            mode,
+        };
+    }
+    async uploadWithRetry(endpoint, payload, extraHeaders) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                await this.uploadOnce(endpoint, payload, extraHeaders);
+                return;
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < this.maxAttempts) {
+                    await delay(250 * Math.pow(2, attempt - 1));
+                }
+            }
+        }
+        throw lastError || new Error('Upload failed after retries');
+    }
+    async uploadOnce(endpoint, compressedPackage, extraHeaders) {
         return new Promise((resolve, reject) => {
             let settled = false;
             const finalize = (fn) => {
@@ -39,7 +83,7 @@ class Uploader {
                 settled = true;
                 fn();
             };
-            const req = https_1.default.request(this.endpoint, {
+            const req = https_1.default.request(endpoint, {
                 method: 'POST',
                 headers: {
                     Authorization: `Bearer ${this.options.apiKey}`,
@@ -47,6 +91,7 @@ class Uploader {
                     'Content-Type': 'application/octet-stream',
                     'Content-Encoding': 'gzip',
                     'Content-Length': compressedPackage.length,
+                    ...extraHeaders,
                 },
             }, (res) => {
                 if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcoder-x/plugin-shared",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "private": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",