vue-harvest 0.0.1

package/dist/analyze-EN7LZ24H.js

@@ -0,0 +1,68 @@
+// src/commands/analyze.ts
+import { defineCommand } from "citty";
+import { resolve } from "pathe";
+import consola from "consola";
+var analyze_default = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Analyze a Vue project and extract reusable components"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to the Vue project root",
+      default: "."
+    },
+    threshold: {
+      type: "string",
+      description: "Extraction confidence threshold 0-100 (default: 70)"
+    },
+    output: {
+      type: "string",
+      description: "Output directory (default: .vue-harvest)",
+      alias: "o"
+    },
+    json: {
+      type: "boolean",
+      description: "Output JSON to stdout"
+    }
+  },
+  async run({ args }) {
+    const { analyze, writeOutput } = await import("./index.js");
+    const threshold = args.threshold ? parseInt(args.threshold, 10) / 100 : void 0;
+    const report = await analyze(resolve(args.path), {
+      extractionThreshold: threshold,
+      outDir: args.output
+    });
+    if (args.json) {
+      const output = {
+        summary: report.summary,
+        components: [...report.components.entries()].map(([name, c]) => ({
+          name,
+          tier: c.tier,
+          confidence: Math.round(c.extractionConfidence * 100),
+          loc: c.loc.total,
+          props: c.props.length,
+          issues: c.couplingIssues.length
+        }))
+      };
+      process.stdout.write(JSON.stringify(output, null, 2));
+      return;
+    }
+    await writeOutput(report);
+    consola.box(
+      [
+        `Vue Harvest Analysis`,
+        ``,
+        `Components: ${report.summary.analyzed}`,
+        `Auto-extracted: ${report.summary.autoExtracted}`,
+        `Needs review: ${report.summary.needsMCP}`,
+        ``,
+        Object.entries(report.summary.byTier).sort((a, b) => b[1] - a[1]).map(([tier, count]) => `  ${tier}: ${count}`).join("\n")
+      ].join("\n")
+    );
+  }
+});
+export {
+  analyze_default as default
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+// src/cli.ts
+import { defineCommand, runMain } from "citty";
+var main = defineCommand({
+  meta: {
+    name: "vue-harvest",
+    version: "0.0.1",
+    description: "Extract reusable component libraries and design tokens from Vue applications"
+  },
+  subCommands: {
+    analyze: () => import("./analyze-EN7LZ24H.js").then((m) => m.default),
+    list: () => import("./list-NVCU2SBD.js").then((m) => m.default),
+    inspect: () => import("./inspect-GYSHQGKR.js").then((m) => m.default),
+    extract: () => import("./extract-IXDSHKMT.js").then((m) => m.default),
+    tokens: () => import("./tokens-SE3ZP52M.js").then((m) => m.default),
+    init: () => import("./init-7D4WRW4O.js").then((m) => m.default)
+  }
+});
+runMain(main);

package/dist/extract-IXDSHKMT.js

@@ -0,0 +1,101 @@
+// src/commands/extract.ts
+import { defineCommand } from "citty";
+import { resolve } from "pathe";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "pathe";
+import consola from "consola";
+var extract_default = defineCommand({
+  meta: {
+    name: "extract",
+    description: "Extract a component and its dependencies into a standalone bundle"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Component name in PascalCase",
+      required: true
+    },
+    path: {
+      type: "string",
+      description: "Project root path",
+      default: "."
+    },
+    output: {
+      type: "string",
+      description: "Output directory",
+      alias: "o",
+      default: ".vue-harvest/components"
+    },
+    force: {
+      type: "boolean",
+      description: "Extract even if below confidence threshold"
+    }
+  },
+  async run({ args }) {
+    const { analyze, extractComponent, resolveConfig } = await import("./index.js");
+    const root = resolve(args.path);
+    const report = await analyze(root);
+    const comp = report.components.get(args.name);
+    if (!comp) {
+      const available = [...report.components.keys()].join(", ");
+      consola.error(`Component "${args.name}" not found. Available: ${available}`);
+      process.exit(1);
+    }
+    const pct = Math.round(comp.extractionConfidence * 100);
+    if (pct < 70 && !args.force) {
+      consola.warn(
+        `${args.name} confidence is ${pct}% (below 70% threshold). Use --force to extract anyway.`
+      );
+      process.exit(1);
+    }
+    const pkgPath = resolve(root, "package.json");
+    const pkg = existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf-8")) : {};
+    const projectDeps = {
+      ...pkg.dependencies || {},
+      ...pkg.devDependencies || {}
+    };
+    const config = resolveConfig(root, {
+      extractionThreshold: args.force ? 0 : 0.7
+    });
+    const result = extractComponent(
+      args.name,
+      report.components,
+      report.graph,
+      config,
+      projectDeps
+    );
+    if (!result.success) {
+      consola.error("Extraction failed:");
+      for (const issue of result.issues) {
+        consola.log(`  [${issue.severity}] ${issue.message}`);
+      }
+      process.exit(1);
+    }
+    const outDir = resolve(args.output, args.name);
+    mkdirSync(outDir, { recursive: true });
+    for (const [filePath, content] of Object.entries(result.files)) {
+      const fullPath = join(outDir, filePath);
+      const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(fullPath, content);
+    }
+    writeFileSync(
+      join(outDir, "manifest.json"),
+      JSON.stringify(result.manifest, null, 2)
+    );
+    consola.success(`Extracted ${args.name} to ${outDir}`);
+    consola.info(`  Files: ${Object.keys(result.files).length}`);
+    consola.info(
+      `  Peer deps: ${Object.keys(result.manifest.peerDependencies).join(", ")}`
+    );
+    if (result.issues.length > 0) {
+      consola.warn("Notes:");
+      for (const issue of result.issues) {
+        consola.log(`  [${issue.severity}] ${issue.message}`);
+      }
+    }
+  }
+});
+export {
+  extract_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,266 @@
+interface HarvestConfig {
+    root: string;
+    include: string[];
+    exclude: string[];
+    aliases: Record<string, string>;
+    extractionThreshold: number;
+    outDir: string;
+    registry: 'json' | 'typescript';
+}
+interface PropDefinition {
+    name: string;
+    type: string;
+    required: boolean;
+    default?: string;
+    validator?: string;
+    description?: string;
+}
+interface EmitDefinition {
+    name: string;
+    payload?: string;
+    description?: string;
+}
+interface SlotDefinition {
+    name: string;
+    bindings: Array<{
+        name: string;
+        type: string;
+    }>;
+    description?: string;
+}
+interface ExposeDefinition {
+    name: string;
+    type: string;
+    description?: string;
+}
+type ScriptVariant = 'setup-ts' | 'setup-js' | 'options-ts' | 'options-js' | 'composition-ts' | 'composition-js' | 'none';
+interface StyleBlock {
+    lang: 'css' | 'scss' | 'less' | 'postcss' | 'stylus';
+    scoped: boolean;
+    module: boolean | string;
+    source: string;
+    cssVarsUsed: string[];
+    cssVarsDefined: string[];
+    externalImports: string[];
+}
+type DependencyKind = 'internal-component' | 'internal-composable' | 'internal-util' | 'internal-store' | 'internal-type' | 'internal-asset' | 'internal-style' | 'external-package' | 'vue-core' | 'global-plugin' | 'provide-inject' | 'unknown';
+interface Dependency {
+    specifier: string;
+    resolvedPath: string | null;
+    kind: DependencyKind;
+    imports: string[];
+    typeOnly: boolean;
+    isPeer: boolean;
+    depth: number;
+}
+type CouplingIssueType = 'direct-store-access' | 'hardcoded-api' | 'router-dependency' | 'i18n-dependency' | 'global-inject' | 'env-variable' | 'unscoped-css' | 'deep-provide-chain' | 'implicit-global' | 'side-effect-import';
+interface CouplingIssue {
+    type: CouplingIssueType;
+    description: string;
+    line?: number;
+    column?: number;
+    severity: 'blocker' | 'warning' | 'info';
+    suggestedFix?: string;
+}
+type ReusabilityTier = 'primitive' | 'composite' | 'feature' | 'page-bound' | 'app-specific';
+interface AnalyzedComponent {
+    name: string;
+    filePath: string;
+    absolutePath: string;
+    fileSize: number;
+    props: PropDefinition[];
+    emits: EmitDefinition[];
+    slots: SlotDefinition[];
+    expose: ExposeDefinition[];
+    scriptVariant: ScriptVariant;
+    dependencies: Dependency[];
+    transitiveDeps: string[];
+    peerPackages: string[];
+    styles: StyleBlock[];
+    tier: ReusabilityTier;
+    extractionConfidence: number;
+    couplingIssues: CouplingIssue[];
+    rawSource: string;
+    templateSummary?: string;
+    loc: {
+        template: number;
+        script: number;
+        style: number;
+        total: number;
+    };
+    contentHash: string;
+}
+interface ComponentEdge {
+    source: string;
+    target: string;
+    type: 'imports' | 'slot-renders' | 'dynamic-component';
+}
+interface ComponentGraph {
+    nodes: Array<{
+        id: string;
+        filePath: string;
+        tier: ReusabilityTier;
+        confidence: number;
+    }>;
+    edges: ComponentEdge[];
+    roots: string[];
+    leaves: string[];
+    cycles: string[][];
+}
+interface ExtractionManifest {
+    component: string;
+    files: Array<{
+        from: string;
+        to: string;
+        needsTransform: boolean;
+        role: 'component' | 'composable' | 'util' | 'type' | 'style' | 'asset';
+    }>;
+    peerDependencies: Record<string, string>;
+    requiredGlobals: string[];
+    importRewrites: Record<string, string>;
+    requiredCssVars: string[];
+    notes: string[];
+}
+interface ExtractionResult {
+    success: boolean;
+    manifest: ExtractionManifest;
+    files: Record<string, string>;
+    issues: Array<{
+        severity: 'error' | 'warning' | 'info';
+        message: string;
+        file?: string;
+        suggestion?: string;
+    }>;
+}
+interface RegistryEntry {
+    name: string;
+    type: 'component' | 'composable' | 'util';
+    description?: string;
+    tier: ReusabilityTier;
+    files: string[];
+    dependencies: string[];
+    peerDependencies: string[];
+    registryDependencies: string[];
+    cssVars: string[];
+    meta: {
+        props: PropDefinition[];
+        emits: EmitDefinition[];
+        slots: SlotDefinition[];
+        loc: number;
+    };
+}
+interface HarvestRegistry {
+    $schema: string;
+    name: string;
+    version: string;
+    source: string;
+    generatedAt: string;
+    config: Partial<HarvestConfig>;
+    components: RegistryEntry[];
+    composables: RegistryEntry[];
+    utils: RegistryEntry[];
+    graph: ComponentGraph;
+    stats: {
+        totalComponents: number;
+        autoExtractable: number;
+        needsReview: number;
+        appSpecific: number;
+        totalFiles: number;
+    };
+}
+interface DesignToken {
+    name: string;
+    value: string;
+    type: DesignTokenType;
+    source: TokenSource;
+    usageCount: number;
+    /** Which components use this token */
+    usedBy: string[];
+}
+type DesignTokenType = 'color' | 'font-family' | 'font-size' | 'font-weight' | 'line-height' | 'letter-spacing' | 'spacing' | 'border-radius' | 'border-width' | 'shadow' | 'opacity' | 'z-index' | 'transition' | 'breakpoint';
+interface TokenSource {
+    file: string;
+    line?: number;
+    context: 'css-value' | 'css-variable' | 'tailwind-class' | 'inline-style' | 'js-constant';
+}
+interface DesignSystemReport {
+    tokens: DesignToken[];
+    /** Grouped by type for easy consumption */
+    byType: Record<DesignTokenType, DesignToken[]>;
+    /** Color palette (deduplicated, normalized) */
+    palette: Array<{
+        hex: string;
+        name?: string;
+        usageCount: number;
+    }>;
+    /** Typography scale */
+    typography: {
+        families: string[];
+        sizes: string[];
+        weights: string[];
+        lineHeights: string[];
+    };
+    /** Spacing scale (sorted, deduplicated) */
+    spacing: string[];
+    /** Border radii */
+    radii: string[];
+    /** Shadows */
+    shadows: string[];
+    /** Stats */
+    stats: {
+        totalTokens: number;
+        uniqueColors: number;
+        uniqueFontSizes: number;
+        uniqueSpacingValues: number;
+        componentsAnalyzed: number;
+        /** How many values are hardcoded vs tokenized */
+        tokenizationRate: number;
+    };
+}
+
+interface ProjectMeta {
+    framework: 'vite' | 'nuxt' | 'vue-cli' | 'unknown';
+    typescript: boolean;
+    packageManager: 'npm' | 'yarn' | 'pnpm' | 'unknown';
+    tailwind: boolean;
+}
+declare function resolveConfig(root: string, overrides?: Partial<HarvestConfig>): HarvestConfig;
+declare function resolveProjectMeta(root: string): ProjectMeta;
+
+declare function extractComponent(componentName: string, allComponents: Map<string, AnalyzedComponent>, graph: ComponentGraph, config: HarvestConfig, projectDeps: Record<string, string>): ExtractionResult;
+
+declare function analyzeSFC(filePath: string, absolutePath: string, projectRoot: string, aliases: Record<string, string>): Promise<AnalyzedComponent>;
+
+declare function buildComponentGraph(components: AnalyzedComponent[], projectRoot: string, aliases: Record<string, string>): ComponentGraph;
+
+declare function analyzeDesignSystem(config: HarvestConfig, analyzedComponents?: Map<string, {
+    name: string;
+    filePath: string;
+    styles: Array<{
+        source: string;
+    }>;
+}>): Promise<DesignSystemReport>;
+declare function generateTokenCSS(report: DesignSystemReport): string;
+declare function generateDesignSystemHTML(report: DesignSystemReport): string;
+
+interface AnalysisReport {
+    config: HarvestConfig;
+    components: Map<string, AnalyzedComponent>;
+    graph: ComponentGraph;
+    registry: HarvestRegistry;
+    extractions: Map<string, ExtractionResult>;
+    summary: {
+        totalFiles: number;
+        analyzed: number;
+        errors: number;
+        byTier: Record<string, number>;
+        autoExtracted: number;
+        needsMCP: number;
+    };
+}
+declare function analyze(rootPath: string, overrides?: Partial<HarvestConfig>): Promise<AnalysisReport>;
+declare function writeOutput(report: AnalysisReport): Promise<void>;
+declare function analyzeTokens(rootPath: string, overrides?: Partial<HarvestConfig>): Promise<DesignSystemReport>;
+declare function writeDesignSystemOutput(report: DesignSystemReport, outputDir: string): Promise<void>;
+
+export { type AnalysisReport, type AnalyzedComponent, type ComponentGraph, type CouplingIssue, type DesignSystemReport, type ExtractionResult, type HarvestConfig, type HarvestRegistry, analyze, analyzeDesignSystem, analyzeSFC, analyzeTokens, buildComponentGraph, extractComponent, generateDesignSystemHTML, generateTokenCSS, resolveConfig, resolveProjectMeta, writeDesignSystemOutput, writeOutput };