@dcoder-x/plugin-shared 0.1.0

package/dist/extractors/ComponentExtractor.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleGraphSource, DiscoveredRoute, DiscoveredElement } from '../types';
+export declare class ComponentExtractor {
+    private source;
+    private routes;
+    constructor(source: ModuleGraphSource, routes: DiscoveredRoute[]);
+    extract(): Promise<DiscoveredElement[]>;
+    private getModuleFilesForRoute;
+    private walkWebpackGraph;
+    private walkRollupGraph;
+    private extractFromSource;
+    private readSource;
+}

package/dist/extractors/ComponentExtractor.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentExtractor = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+class ComponentExtractor {
+    constructor(source, routes) {
+        this.source = source;
+        this.routes = routes;
+    }
+    async extract() {
+        const elements = [];
+        for (const route of this.routes) {
+            const moduleFiles = this.getModuleFilesForRoute(route.filePath);
+            for (const filePath of moduleFiles) {
+                const source = this.readSource(filePath);
+                if (!source)
+                    continue;
+                elements.push(...this.extractFromSource(source, filePath, route.path));
+            }
+        }
+        return elements;
+    }
+    getModuleFilesForRoute(entryFilePath) {
+        if (this.source.type === 'webpack') {
+            return this.walkWebpackGraph(entryFilePath, this.source.compilation);
+        }
+        return this.walkRollupGraph(entryFilePath, this.source.moduleGraph);
+    }
+    walkWebpackGraph(entryFilePath, compilation) {
+        const visited = new Set();
+        const queue = [entryFilePath];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const mod = compilation.moduleGraph.getModuleByIdentifier(current);
+            if (!mod)
+                continue;
+            for (const dep of compilation.moduleGraph.getOutgoingDependencies(mod)) {
+                const depModule = compilation.moduleGraph.getResolvedModule(dep);
+                const depPath = normalizeModulePath(depModule?.resource || depModule?.userRequest);
+                if (depPath && !depPath.includes('node_modules')) {
+                    queue.push(depPath);
+                }
+            }
+        }
+        return Array.from(visited);
+    }
+    walkRollupGraph(entryFilePath, graph) {
+        const visited = new Set();
+        const queue = [entryFilePath];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const mod = graph.get(current);
+            if (!mod)
+                continue;
+            for (const importId of mod.importedIds) {
+                const importPath = normalizeModulePath(importId, current);
+                if (importPath && !importPath.includes('node_modules')) {
+                    queue.push(importPath);
+                }
+            }
+        }
+        return Array.from(visited);
+    }
+    extractFromSource(source, filePath, route) {
+        const elements = [];
+        let ast;
+        try {
+            ast = (0, parser_1.parse)(source, { sourceType: 'module', plugins: ['typescript', 'jsx'] });
+        }
+        catch {
+            return [];
+        }
+        (0, traverse_1.default)(ast, {
+            JSXOpeningElement(nodePath) {
+                const tagName = nodePath.node.name?.name;
+                if (!tagName)
+                    return;
+                const isInteractive = ['button', 'input', 'select', 'textarea', 'a', 'form'].includes(tagName) ||
+                    nodePath.node.attributes.some((attr) => attr.type === 'JSXAttribute' && attr.name?.name === 'onClick');
+                if (!isInteractive)
+                    return;
+                const staticProps = extractStaticProps(nodePath.node.attributes);
+                const nearbyText = extractNearbyText(nodePath);
+                elements.push({
+                    tag: tagName,
+                    filePath,
+                    route,
+                    staticProps,
+                    nearbyText,
+                    semanticRole: inferSemanticRole(tagName, staticProps, nearbyText),
+                    interactions: inferInteractions(tagName, staticProps),
+                });
+            },
+        });
+        return elements;
+    }
+    readSource(filePath) {
+        try {
+            return fs_1.default.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.ComponentExtractor = ComponentExtractor;
+function normalizeModulePath(rawPath, fromFile) {
+    if (!rawPath)
+        return null;
+    // Ignore virtual and plugin-internal module IDs.
+    if (rawPath.startsWith('\u0000') || rawPath.startsWith('virtual:'))
+        return null;
+    let cleaned = rawPath;
+    if (cleaned.startsWith('file://')) {
+        try {
+            cleaned = new URL(cleaned).pathname;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Strip query/hash fragments from bundler IDs.
+    cleaned = cleaned.split('?')[0].split('#')[0];
+    if (!cleaned)
+        return null;
+    // Resolve relative IDs against the importing file when available.
+    if (fromFile && cleaned.startsWith('.')) {
+        cleaned = path_1.default.resolve(path_1.default.dirname(fromFile), cleaned);
+    }
+    return path_1.default.normalize(cleaned);
+}
+function extractStaticProps(attributes) {
+    const props = {};
+    for (const attr of attributes) {
+        if (attr.type !== 'JSXAttribute')
+            continue;
+        const key = attr.name?.name;
+        if (!key)
+            continue;
+        if (attr.value?.type === 'StringLiteral') {
+            props[key] = attr.value.value;
+        }
+        if (attr.value?.type === 'JSXExpressionContainer' &&
+            attr.value.expression?.type === 'StringLiteral') {
+            props[key] = attr.value.expression.value;
+        }
+    }
+    return props;
+}
+function extractNearbyText(nodePath) {
+    const texts = [];
+    const parent = nodePath.parentPath?.node;
+    if (parent?.children) {
+        for (const child of parent.children) {
+            if (child.type === 'JSXText') {
+                const text = child.value.trim();
+                if (text)
+                    texts.push(text);
+            }
+        }
+    }
+    return texts;
+}
+function inferSemanticRole(tag, props, nearbyText) {
+    const label = props['aria-label'] || props['placeholder'] || nearbyText[0] || '';
+    return `${label} ${tag}`.trim().toLowerCase();
+}
+function inferInteractions(tag, props) {
+    if (tag === 'button')
+        return ['click'];
+    if (tag === 'a')
+        return ['click', 'navigate'];
+    if (tag === 'input')
+        return props['type'] === 'submit' ? ['click'] : ['type'];
+    if (tag === 'select')
+        return ['select'];
+    if (tag === 'textarea')
+        return ['type'];
+    if (tag === 'form')
+        return ['submit'];
+    return ['click'];
+}

package/dist/extractors/FlowInferrer.d.ts

@@ -0,0 +1,10 @@
+import type { DiscoveredRoute, DiscoveredElement, InferredFlow } from '../types';
+export declare class FlowInferrer {
+    private routes;
+    private elements;
+    constructor(routes: DiscoveredRoute[], elements: DiscoveredElement[]);
+    infer(): InferredFlow[];
+    private buildEdgeGraph;
+    private detectLinearFlows;
+    private buildChain;
+}

package/dist/extractors/FlowInferrer.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowInferrer = void 0;
+class FlowInferrer {
+    constructor(routes, elements) {
+        this.routes = routes;
+        this.elements = elements;
+    }
+    infer() {
+        const edges = this.buildEdgeGraph();
+        return this.detectLinearFlows(edges);
+    }
+    buildEdgeGraph() {
+        const edges = [];
+        const routePaths = new Set(this.routes.map((r) => r.path));
+        for (const el of this.elements) {
+            const href = el.staticProps['href'] || el.staticProps['to'];
+            if (el.tag === 'a' && href && routePaths.has(href)) {
+                edges.push({
+                    from: el.route,
+                    to: href,
+                    trigger: el.staticProps['aria-label'] || el.nearbyText[0] || 'link',
+                    confidence: 0.85,
+                });
+            }
+        }
+        return edges;
+    }
+    detectLinearFlows(edges) {
+        const adjacency = new Map();
+        for (const edge of edges) {
+            if (!adjacency.has(edge.from))
+                adjacency.set(edge.from, []);
+            adjacency.get(edge.from).push(edge);
+        }
+        const flows = [];
+        const visited = new Set();
+        for (const route of this.routes) {
+            if (visited.has(route.path))
+                continue;
+            const chain = this.buildChain(route.path, adjacency, new Set());
+            if (chain.length >= 2) {
+                flows.push({
+                    id: `flow_${flows.length + 1}`,
+                    name: chain
+                        .map((p) => p.split('/').filter(Boolean).pop() || 'home')
+                        .join(' -> '),
+                    steps: chain,
+                    edges: edges.filter((e) => {
+                        const s = new Set(chain);
+                        return s.has(e.from) && s.has(e.to);
+                    }),
+                });
+                chain.forEach((p) => visited.add(p));
+            }
+        }
+        return flows;
+    }
+    buildChain(start, adjacency, seen) {
+        if (seen.has(start))
+            return [];
+        seen.add(start);
+        const next = adjacency.get(start);
+        if (!next?.length)
+            return [start];
+        const best = [...next].sort((a, b) => b.confidence - a.confidence)[0];
+        return [start, ...this.buildChain(best.to, adjacency, seen)];
+    }
+}
+exports.FlowInferrer = FlowInferrer;

package/dist/extractors/RouteExtractor.d.ts

@@ -0,0 +1,14 @@
+import type { DiscoveredRoute } from '../types';
+export declare class RouteExtractor {
+    private dir;
+    constructor(dir: string);
+    extract(): Promise<DiscoveredRoute[]>;
+    private walkAppDir;
+    private walkPagesDir;
+    private walkTanStackDir;
+    private extractReactRouterRoutes;
+    private findFilesContaining;
+    private extractParams;
+    private findNearestLayout;
+    private deriveSemanticMeaning;
+}

package/dist/extractors/RouteExtractor.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteExtractor = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class RouteExtractor {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    async extract() {
+        const routes = [];
+        const appDir = path_1.default.join(this.dir, 'app');
+        const pagesDir = path_1.default.join(this.dir, 'pages');
+        const srcDir = path_1.default.join(this.dir, 'src');
+        if (fs_1.default.existsSync(appDir)) {
+            routes.push(...this.walkAppDir(appDir, ''));
+        }
+        if (fs_1.default.existsSync(pagesDir)) {
+            routes.push(...this.walkPagesDir(pagesDir));
+        }
+        const routesDir = path_1.default.join(this.dir, 'src', 'routes');
+        if (fs_1.default.existsSync(routesDir)) {
+            routes.push(...this.walkTanStackDir(routesDir));
+        }
+        if (routes.length === 0) {
+            const reactRouterRoutes = await this.extractReactRouterRoutes(srcDir);
+            routes.push(...reactRouterRoutes);
+        }
+        return routes;
+    }
+    walkAppDir(dir, routePrefix) {
+        const results = [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const isRouteGroup = entry.name.startsWith('(') && entry.name.endsWith(')');
+                const segment = isRouteGroup ? '' : `/${entry.name}`;
+                results.push(...this.walkAppDir(fullPath, routePrefix + segment));
+            }
+            if (entry.isFile() && /^page\.(tsx?|jsx?)$/.test(entry.name)) {
+                const routePath = routePrefix || '/';
+                results.push({
+                    path: routePath,
+                    filePath: fullPath,
+                    isDynamic: routePath.includes('['),
+                    params: this.extractParams(routePath),
+                    layout: this.findNearestLayout(dir),
+                    routerType: 'app',
+                    semantic: this.deriveSemanticMeaning(routePath),
+                });
+            }
+        }
+        return results;
+    }
+    walkPagesDir(dir) {
+        const results = [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'api') {
+                results.push(...this.walkPagesDir(fullPath));
+            }
+            if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+                const relativePath = path_1.default
+                    .relative(path_1.default.join(this.dir, 'pages'), fullPath)
+                    .replace(/\.(tsx?|jsx?)$/, '')
+                    .replace(/\\/g, '/');
+                // index.tsx maps to the parent segment path.
+                // examples:
+                // pages/index.tsx -> /
+                // pages/blog/index.tsx -> /blog
+                const routePath = relativePath === 'index'
+                    ? '/'
+                    : `/${relativePath.replace(/\/index$/, '')}`;
+                results.push({
+                    path: routePath,
+                    filePath: fullPath,
+                    isDynamic: routePath.includes('['),
+                    params: this.extractParams(routePath),
+                    layout: null,
+                    routerType: 'pages',
+                    semantic: this.deriveSemanticMeaning(routePath),
+                });
+            }
+        }
+        return results;
+    }
+    walkTanStackDir(dir) {
+        const results = [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+                const name = entry.name.replace(/\.(tsx?|jsx?)$/, '');
+                if (name === '__root' || name === 'index')
+                    continue;
+                const routePath = '/' + name.replace(/\./g, '/');
+                results.push({
+                    path: routePath,
+                    filePath: path_1.default.join(dir, entry.name),
+                    isDynamic: routePath.includes('$'),
+                    params: this.extractParams(routePath),
+                    layout: null,
+                    routerType: 'tanstack',
+                    semantic: this.deriveSemanticMeaning(routePath),
+                });
+            }
+        }
+        return results;
+    }
+    async extractReactRouterRoutes(srcDir) {
+        if (!fs_1.default.existsSync(srcDir))
+            return [];
+        const { parse } = await import('@babel/parser');
+        const traverse = (await import('@babel/traverse')).default;
+        const results = [];
+        const routerFiles = this.findFilesContaining(srcDir, /createBrowserRouter|<Route/);
+        for (const filePath of routerFiles) {
+            const source = fs_1.default.readFileSync(filePath, 'utf-8');
+            let ast;
+            try {
+                ast = parse(source, { sourceType: 'module', plugins: ['typescript', 'jsx'] });
+            }
+            catch {
+                continue;
+            }
+            traverse(ast, {
+                JSXOpeningElement(nodePath) {
+                    const name = nodePath.node.name?.name;
+                    if (name !== 'Route')
+                        return;
+                    const pathAttr = nodePath.node.attributes.find((a) => a.name?.name === 'path');
+                    const routePath = pathAttr?.value?.value;
+                    if (routePath) {
+                        results.push({
+                            path: routePath,
+                            filePath,
+                            isDynamic: routePath.includes(':'),
+                            params: (routePath.match(/:(\w+)/g) || []).map((p) => p.slice(1)),
+                            layout: null,
+                            routerType: 'react-router',
+                            semantic: this.deriveSemanticMeaning(routePath),
+                        });
+                    }
+                },
+            });
+        }
+        return results;
+    }
+    findFilesContaining(dir, pattern) {
+        const results = [];
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'node_modules') {
+                results.push(...this.findFilesContaining(fullPath, pattern));
+            }
+            if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+                const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                if (pattern.test(content))
+                    results.push(fullPath);
+            }
+        }
+        return results;
+    }
+    extractParams(routePath) {
+        const nextParams = (routePath.match(/\[([^\]]+)\]/g) || []).map((m) => m.replace(/[\[\]\.]/g, ''));
+        const rrParams = (routePath.match(/:(\w+)/g) || []).map((m) => m.slice(1));
+        return [...nextParams, ...rrParams];
+    }
+    findNearestLayout(dir) {
+        return (['layout.tsx', 'layout.ts', 'layout.jsx', 'layout.js']
+            .map((f) => path_1.default.join(dir, f))
+            .find((f) => fs_1.default.existsSync(f)) || null);
+    }
+    deriveSemanticMeaning(routePath) {
+        return routePath
+            .split('/')
+            .filter(Boolean)
+            .filter((s) => !s.startsWith('[') && !s.startsWith(':') && !s.startsWith('$'))
+            .reverse()
+            .join(' ');
+    }
+}
+exports.RouteExtractor = RouteExtractor;

package/dist/extractors/SelectorGenerator.d.ts

@@ -0,0 +1,5 @@
+import type { DiscoveredElement, ElementWithSelectors } from '../types';
+export declare class SelectorGenerator {
+    generate(elements: DiscoveredElement[]): ElementWithSelectors[];
+    private generateForElement;
+}

package/dist/extractors/SelectorGenerator.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectorGenerator = void 0;
+class SelectorGenerator {
+    generate(elements) {
+        return elements.map((el) => ({
+            ...el,
+            selectors: this.generateForElement(el),
+        }));
+    }
+    generateForElement(el) {
+        const candidates = [];
+        const p = el.staticProps;
+        if (p['data-testid']) {
+            candidates.push({
+                type: 'testid',
+                value: `[data-testid="${p['data-testid']}"]`,
+                confidence: 0.97,
+            });
+        }
+        if (p['aria-label']) {
+            candidates.push({
+                type: 'aria',
+                value: `${el.tag}[aria-label="${p['aria-label']}"]`,
+                confidence: 0.93,
+            });
+        }
+        if (p['role']) {
+            candidates.push({
+                type: 'aria',
+                value: `[role="${p['role']}"]`,
+                confidence: 0.88,
+            });
+        }
+        if (p['id'] && !isDynamicId(p['id'])) {
+            candidates.push({
+                type: 'id',
+                value: `#${p['id']}`,
+                confidence: 0.85,
+            });
+        }
+        if (el.tag === 'input' && p['name']) {
+            candidates.push({
+                type: 'semantic',
+                value: `input[name="${p['name']}"]`,
+                confidence: 0.8,
+            });
+        }
+        if (el.tag === 'button' && el.nearbyText[0]) {
+            candidates.push({
+                type: 'text',
+                value: `button:contains("${el.nearbyText[0]}")`,
+                confidence: 0.72,
+            });
+        }
+        return candidates.sort((a, b) => b.confidence - a.confidence);
+    }
+}
+exports.SelectorGenerator = SelectorGenerator;
+function isDynamicId(id) {
+    return /\d{3,}/.test(id) || id.includes('__') || id.startsWith(':');
+}

package/dist/extractors/SemanticAnalyser.d.ts

@@ -0,0 +1,4 @@
+export declare class SemanticAnalyser {
+    deriveRouteSemantic(routePath: string): string;
+    deriveElementSemantic(label: string, tag: string): string;
+}

package/dist/extractors/SemanticAnalyser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticAnalyser = void 0;
+class SemanticAnalyser {
+    deriveRouteSemantic(routePath) {
+        return routePath
+            .split('/')
+            .filter(Boolean)
+            .filter((s) => !s.startsWith('[') && !s.startsWith(':') && !s.startsWith('$'))
+            .reverse()
+            .join(' ');
+    }
+    deriveElementSemantic(label, tag) {
+        return `${label} ${tag}`.trim().toLowerCase();
+    }
+}
+exports.SemanticAnalyser = SemanticAnalyser;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export type { ClippyPluginOptions, ModuleGraphSource, RollupModuleInfo, DiscoveredRoute, DiscoveredElement, SelectorCandidate, ElementWithSelectors, FlowEdge, InferredFlow, KnowledgePackage, } from './types';

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+export interface ClippyPluginOptions {
+    apiKey: string;
+    projectId: string;
+    skipUpload?: boolean;
+    productionOnly?: boolean;
+    localOutputDir?: string;
+}
+export type ModuleGraphSource = {
+    type: 'webpack';
+    compilation: any;
+} | {
+    type: 'rollup';
+    moduleGraph: Map<string, RollupModuleInfo>;
+};
+export interface RollupModuleInfo {
+    id: string;
+    importedIds: readonly string[];
+}
+export interface DiscoveredRoute {
+    path: string;
+    filePath: string;
+    isDynamic: boolean;
+    params: string[];
+    layout: string | null;
+    routerType: 'app' | 'pages' | 'react-router' | 'tanstack';
+    semantic: string;
+}
+export interface DiscoveredElement {
+    tag: string;
+    filePath: string;
+    route: string;
+    staticProps: Record<string, string>;
+    nearbyText: string[];
+    semanticRole: string;
+    interactions: string[];
+}
+export interface SelectorCandidate {
+    type: 'testid' | 'aria' | 'id' | 'semantic' | 'text' | 'structural';
+    value: string;
+    confidence: number;
+}
+export interface ElementWithSelectors extends DiscoveredElement {
+    selectors: SelectorCandidate[];
+}
+export interface FlowEdge {
+    from: string;
+    to: string;
+    trigger: string;
+    confidence: number;
+}
+export interface InferredFlow {
+    id: string;
+    name: string;
+    steps: string[];
+    edges: FlowEdge[];
+}
+export interface KnowledgePackage {
+    buildId: string;
+    generatedAt: string;
+    bundler: 'webpack' | 'vite';
+    routes: DiscoveredRoute[];
+    components: DiscoveredElement[];
+    selectors: ElementWithSelectors[];
+    flows: InferredFlow[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/upload/PackageBuilder.d.ts

@@ -0,0 +1,5 @@
+import type { KnowledgePackage } from '../types';
+export declare class PackageBuilder {
+    buildPackage(data: Omit<KnowledgePackage, 'generatedAt'>): KnowledgePackage;
+    build(data: Omit<KnowledgePackage, 'generatedAt'>): Buffer;
+}

package/dist/upload/PackageBuilder.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBuilder = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+class PackageBuilder {
+    buildPackage(data) {
+        return {
+            ...data,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    build(data) {
+        const pkg = this.buildPackage(data);
+        return zlib_1.default.gzipSync(JSON.stringify(pkg));
+    }
+}
+exports.PackageBuilder = PackageBuilder;

package/dist/upload/PackageWriter.d.ts

@@ -0,0 +1,7 @@
+import type { KnowledgePackage } from '../types';
+export declare class PackageWriter {
+    write(outputDir: string, knowledgePackage: KnowledgePackage): {
+        jsonPath: string;
+        gzipPath: string;
+    };
+}

package/dist/upload/PackageWriter.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageWriter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const zlib_1 = __importDefault(require("zlib"));
+class PackageWriter {
+    write(outputDir, knowledgePackage) {
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        const baseName = `${knowledgePackage.bundler}-${knowledgePackage.buildId}`;
+        const jsonPath = path_1.default.join(outputDir, `${baseName}.json`);
+        const gzipPath = path_1.default.join(outputDir, `${baseName}.json.gz`);
+        const content = JSON.stringify(knowledgePackage, null, 2);
+        fs_1.default.writeFileSync(jsonPath, content, 'utf-8');
+        fs_1.default.writeFileSync(gzipPath, zlib_1.default.gzipSync(content));
+        return { jsonPath, gzipPath };
+    }
+}
+exports.PackageWriter = PackageWriter;

package/dist/upload/Uploader.d.ts

@@ -0,0 +1,10 @@
+import type { ClippyPluginOptions } from '../types';
+export declare class Uploader {
+    private options;
+    private endpoint;
+    private requestTimeoutMs;
+    private maxAttempts;
+    constructor(options: ClippyPluginOptions);
+    upload(compressedPackage: Buffer): Promise<boolean>;
+    private uploadOnce;
+}

package/dist/upload/Uploader.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uploader = void 0;
+const https_1 = __importDefault(require("https"));
+class Uploader {
+    constructor(options) {
+        this.options = options;
+        this.endpoint = 'https://api.clippy.dev/v1/knowledge';
+        this.requestTimeoutMs = 10000;
+        this.maxAttempts = 3;
+    }
+    async upload(compressedPackage) {
+        if (this.options.skipUpload)
+            return false;
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                await this.uploadOnce(compressedPackage);
+                return true;
+            }
+            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(compressedPackage) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finalize = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            };
+            const req = https_1.default.request(this.endpoint, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.options.apiKey}`,
+                    'X-Project-Id': this.options.projectId,
+                    'Content-Type': 'application/octet-stream',
+                    'Content-Encoding': 'gzip',
+                    'Content-Length': compressedPackage.length,
+                },
+            }, (res) => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    finalize(resolve);
+                }
+                else {
+                    finalize(() => reject(new Error(`Upload failed: ${res.statusCode}`)));
+                }
+            });
+            req.setTimeout(this.requestTimeoutMs, () => {
+                req.destroy(new Error('Upload timed out'));
+            });
+            req.on('error', (err) => finalize(() => reject(err)));
+            req.write(compressedPackage);
+            req.end();
+        });
+    }
+}
+exports.Uploader = Uploader;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@dcoder-x/plugin-shared",
+  "version": "0.1.0",
+  "private": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./extractors/RouteExtractor": "./dist/extractors/RouteExtractor.js",
+    "./extractors/ComponentExtractor": "./dist/extractors/ComponentExtractor.js",
+    "./extractors/SelectorGenerator": "./dist/extractors/SelectorGenerator.js",
+    "./extractors/FlowInferrer": "./dist/extractors/FlowInferrer.js",
+    "./extractors/SemanticAnalyser": "./dist/extractors/SemanticAnalyser.js",
+    "./upload/PackageBuilder": "./dist/upload/PackageBuilder.js",
+    "./upload/PackageWriter": "./dist/upload/PackageWriter.js",
+    "./upload/Uploader": "./dist/upload/Uploader.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}