@weaver-wow/cli 1.0.0

package/README.md

@@ -0,0 +1,28 @@
+# Weaver CLI
+
+The developer toolchain for Weaver addons.
+
+## Installation
+
+```bash
+npm install -g @weaver/cli
+```
+
+## Getting Started
+
+Initialize a new Weaver project:
+
+```bash
+wvr init
+```
+
+## Commands
+
+- `wvr init`: Scaffolds a new Weaver project in the current directory.
+- `wvr build`: Compiles your TypeScript/JSX into a valid WoW addon.
+- `wvr dev`: Watches for changes and rebuilds automatically.
+- `wvr link`: Links your project to the WoW AddOns directory.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@weaver-wow/cli",
+  "version": "1.0.0",
+  "description": "Command line toolchain for building Weaver addons",
+  "type": "module",
+  "bin": {
+    "wvr": "src/cli/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "license": "MIT",
+  "author": "Mike Eling <mike.eling97@gmail.com>",
+  "dependencies": {
+    "@clack/prompts": "^1.0.0",
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1",
+    "zod": "^4.3.6",
+    "@weaver-wow/core": "^1.0.0",
+    "typescript-to-lua": "^1.33.2"
+  },
+  "scripts": {
+    "build": "echo 'Building weaver CLI...'"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli/builder.ts

@@ -0,0 +1,280 @@
+import { $ } from "bun";
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { WeaverConfig } from "../schema";
+import picocolors from "picocolors";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+const GENERATED_TSTL_CONFIG = ".tstl.build.json";
+
+/**
+ * Build the addon project.
+ * 
+ * The builder:
+ * 1. Reads the base tsconfig.tstl.json template
+ * 2. Generates a temporary build config with the correct entry point and include
+ * 3. Runs TSTL to compile TypeScript → Lua
+ * 4. Post-processes the Lua output (namespace wrapping)
+ * 5. Generates the .toc manifest
+ * 6. Scans for assets
+ */
+export async function buildProject(config: WeaverConfig | null, silent = false) {
+    if (!silent) console.log("Building...");
+
+    let pkg: any = {};
+    if (existsSync("package.json")) {
+        try {
+            pkg = JSON.parse(readFileSync("package.json", "utf-8"));
+        } catch {}
+    }
+
+    const addonName = config?.addonName || (pkg.name ? pkg.name.charAt(0).toUpperCase() + pkg.name.slice(1) : "MyAddon");
+    const interfaceVersion = config?.interface || "110000";
+    const author = pkg.author || "Unknown";
+    const version = pkg.version || "1.0.0";
+    const description = pkg.description || "Generated by Weaver";
+    // Pre-flight checks
+    if (!existsSync("tsconfig.json") && !existsSync("tsconfig.tstl.json")) {
+        throw new Error(`Missing ${picocolors.bold("tsconfig.json")}. \n  Run ${picocolors.cyan("wvr init")} to set up your project structure.`);
+    }
+
+    // Discovery of entry point if not specified
+    let entryPoint = config?.entry;
+    if (!entryPoint) {
+        const potentialEntries = ["src/App.tsx", "src/index.tsx", "src/App.ts", "src/index.ts"];
+        for (const pe of potentialEntries) {
+            if (existsSync(pe)) {
+                entryPoint = pe;
+                break;
+            }
+        }
+    }
+    
+    // Fallback to default if still not found
+    const finalEntryPoint = entryPoint || "src/App.tsx";
+
+    if (!existsSync(finalEntryPoint)) {
+        const others = ["src/App.tsx", "src/index.tsx", "src/App.ts", "src/index.ts"].filter(pe => pe !== finalEntryPoint && existsSync(pe));
+        let suggestion = "";
+        if (others.length > 0) {
+            suggestion = `\n  ${picocolors.yellow("Suggestion:")} Found ${picocolors.cyan(others[0])}. Did you mean to use that?`;
+        }
+        throw new Error(`Entry point not found: ${picocolors.red(finalEntryPoint)}${suggestion}\n  Check your ${picocolors.bold("weaver.config.ts")} or ensure the source file exists.`);
+    }
+
+    if (!existsSync("dist")) mkdirSync("dist");
+
+    // 1. Generate build-time TSTL config
+    const buildConfig = generateBuildConfig(finalEntryPoint);
+
+    try {
+        // 2. Run TSTL with the generated config
+        if (silent) {
+            await $`bun x tstl -p ${GENERATED_TSTL_CONFIG}`.quiet();
+        } else {
+            await $`bun x tstl -p ${GENERATED_TSTL_CONFIG}`;
+        }
+    } catch (e: any) {
+        let rawError = (e.stdout?.toString() || "") + (e.stderr?.toString() || "") + (e.message || "");
+        
+        // Parse TSTL/TS errors for pretty printing
+        const lines = rawError.split('\n');
+        const formattedErrors: string[] = [];
+        
+        for (const line of lines) {
+            // Match pattern: path/to/file.tsx(line,col): error TSXXXX: message
+            const match = line.match(/^(.+)\((\d+),(\d+)\): error (TS\d+): (.+)$/);
+            if (match) {
+                const [_, file, lineNum, colNum, code, msg] = match;
+                let processedMsg = msg;
+                
+                if (msg.includes("Cannot find module '@weaver-wow/core'")) {
+                    processedMsg += `\n     ${picocolors.yellow("Tip:")} Run ${picocolors.bold("bun install")} to link the Weaver runtime.`;
+                }
+
+                formattedErrors.push(
+                    `  ${picocolors.dim(file)}:${picocolors.cyan(lineNum)}:${picocolors.cyan(colNum)}\n` +
+                    `  ${picocolors.red("✖")} ${picocolors.white(processedMsg)} ${picocolors.dim(`[${code}]`)}`
+                );
+            } else if (line.includes("error TSTL")) {
+                let msg = line.trim();
+                let tip = "";
+                if (msg.includes("'@weaver-wow/core'")) {
+                    tip = `\n     ${picocolors.yellow("Tip:")} Run ${picocolors.bold("bun install")} or ensure Weaver is in your node_modules.`;
+                }
+                formattedErrors.push(`  ${picocolors.red("✖")} ${picocolors.white(msg)}${tip}`);
+            }
+        }
+        
+        if (formattedErrors.length > 0) {
+            throw new Error(`Compilation failed:\n\n${formattedErrors.join('\n\n')}`);
+        }
+        
+        throw new Error(`Compilation failed with unknown error:\n${rawError}`);
+    } finally {
+        // Always clean up the temporary config
+        // cleanupBuildConfig();
+    }
+
+    // 3. Post-Process — wrap in addon namespace
+    const bundlePath = "./dist/App.lua"; 
+    let luaContent = "";
+    
+    if (existsSync(bundlePath)) {
+        luaContent = readFileSync(bundlePath, "utf-8");
+    } else {
+         throw new Error(`Could not find generated Lua file (${bundlePath})`);
+    }
+
+    const wrappedLua = `
+local addonName, ns = ...
+-- [WEAVER RUNTIME STUB]
+${luaContent}
+    `.trim();
+
+    writeFileSync("./dist/Core.lua", wrappedLua);
+
+    // Remove intermediate bundle (Core.lua is the final artifact)
+    try { unlinkSync(bundlePath); } catch {}
+
+    // 4. Generate TOC
+    const tocContent = `## Interface: ${interfaceVersion}
+## Title: ${addonName}
+## Notes: ${description}
+## Author: ${author}
+## Version: ${version}
+
+Core.lua
+`;
+    writeFileSync(`./dist/${addonName}.toc`, tocContent);
+
+    // 5. Assets
+    let assetCount = 0;
+    if (existsSync("assets")) {
+         const files = readdirSync("assets");
+         for (const file of files) {
+             if (file.endsWith(".png")) {
+                 assetCount++;
+             }
+         }
+    }
+
+    return { addonName, assetCount };
+}
+
+/**
+ * Generate a temporary TSTL config that extends the base template
+ * with the correct entry point and include paths.
+ */
+function generateBuildConfig(entryPoint: string): string {
+    console.log("BUILDER UPDATED V2");
+    // Read the base template
+    const baseConfigPath = existsSync("tsconfig.tstl.json") ? "tsconfig.tstl.json" : "tsconfig.json";
+    const baseConfig = JSON.parse(readFileSync(baseConfigPath, "utf-8"));
+
+    // Determine the entry's directory for include patterns
+    const entryDir = dirname(entryPoint);
+
+    // Extend include with the entry point
+    const include = [
+        ...(baseConfig.include || []),
+        entryPoint,
+    ];
+
+    // Build the final config
+    // Heuristic:
+    // 1. If CWD has package.json with "weaver" dependency, use node_modules (Consumer Project)
+    // 2. Else if we are in the monorepo structure, use relative source paths (Monorepo specific)
+    
+    let isConsumerProject = false;
+    console.log("CWD:", process.cwd());
+    if (existsSync("package.json")) {
+        try {
+            const pkgC = readFileSync("package.json", "utf-8");
+            const pkg = JSON.parse(pkgC);
+            console.log("Found package.json with deps:", Object.keys(pkg.dependencies || {}));
+            if ((pkg.dependencies && pkg.dependencies["@weaver-wow/core"]) || (pkg.devDependencies && pkg.devDependencies["@weaver-wow/core"])) {
+                isConsumerProject = true;
+            }
+        } catch (e) { console.log("Error reading pkg", e); }
+    }
+    console.log("isConsumerProject:", isConsumerProject);
+
+    let weaverPath: string;
+    let jsxRuntimePath: string;
+    let includePaths: string[] = [];
+    
+    // Check if we are running from source (monorepo) or installed package
+    const absoluteRootDir = join(dirname(import.meta.url.replace("file:///", "")), "..", "..", "..", "..");
+
+    if (isConsumerProject) {
+         // We are in a consumer project, resolve from node_modules
+        // The project's node_modules should have weaver installed
+        weaverPath = "node_modules/@weaver-wow/core/src/index.ts";
+        jsxRuntimePath = "node_modules/@weaver-wow/core/src/types/react-jsx-runtime.d.ts";
+        includePaths = [
+            "node_modules/@weaver-wow/core/src/**/*.ts",
+            "node_modules/@weaver-wow/core/src/**/*.tsx"
+        ];
+    } else if (existsSync(join(absoluteRootDir, "packages", "weaver"))) {
+        // We are in the monorepo (e.g. running sandbox tests)
+        const rootDir = relative(process.cwd(), absoluteRootDir) || ".";
+        weaverPath = join(rootDir, "packages/weaver/src/index.ts");
+        jsxRuntimePath = join(rootDir, "packages/weaver/src/types/react-jsx-runtime.d.ts");
+        includePaths = [
+            join(rootDir, "packages/weaver/src/**/*.ts"),
+            join(rootDir, "packages/weaver/src/**/*.tsx"),
+        ];
+    } else {
+         // Fallback: linked but not detecting monorepo (should be covered by isConsumerProject if linked correctly)
+         // or strange install location. Default to node_modules
+        weaverPath = "node_modules/@weaver-wow/core/src/index.ts";
+        jsxRuntimePath = "node_modules/@weaver-wow/core/src/types/react-jsx-runtime.d.ts";
+        includePaths = [
+            "node_modules/@weaver-wow/core/src/**/*.ts",
+            "node_modules/@weaver-wow/core/src/**/*.tsx"
+        ];
+    }
+
+    const buildConfig = {
+        ...baseConfig,
+        compilerOptions: {
+            ...baseConfig.compilerOptions,
+            preserveSymlinks: true,
+            paths: {
+                ...(baseConfig.compilerOptions?.paths || {}),
+                "@weaver-wow/core": [weaverPath],
+                "react/jsx-runtime": [jsxRuntimePath]
+            }
+        },
+        tstl: {
+            ...baseConfig.tstl,
+            luaBundleEntry: entryPoint,
+        },
+        include: [
+            ...include,
+            ...includePaths
+        ],
+    };
+
+    // Write the temporary config
+    if (process.env.DEBUG) console.log("Generated config:", JSON.stringify(buildConfig, null, 2));
+    writeFileSync(GENERATED_TSTL_CONFIG, JSON.stringify(buildConfig, null, 2));
+
+    return GENERATED_TSTL_CONFIG;
+}
+
+/**
+ * Clean up the temporary build config file.
+ */
+function cleanupBuildConfig(): void {
+    try {
+        if (existsSync(GENERATED_TSTL_CONFIG)) {
+            unlinkSync(GENERATED_TSTL_CONFIG);
+        }
+    } catch {
+        // Non-critical — don't block build on cleanup failure
+    }
+}

package/src/cli/commands/build.ts

@@ -0,0 +1,34 @@
+
+import { intro, outro, spinner } from "@clack/prompts";
+import picocolors from "picocolors";
+import { loadConfig } from "../utils/config";
+import { buildProject } from "../builder";
+
+export async function buildCommand() {
+    intro(picocolors.bgBlue(" 🧵 Weaver Build "));
+
+    const s = spinner();
+    s.start("Reading configuration...");
+
+    const config = await loadConfig();
+
+    s.message(`Building configured project...`);
+
+    try {
+        const result = await buildProject(config, true);
+        s.stop(picocolors.green("Build complete!"));
+        outro(`Built ${picocolors.cyan(result.addonName)} successfully to ${picocolors.bold("dist/")}`);
+    } catch (e: any) {
+        s.stop(picocolors.red("Build failed"));
+        
+        console.log("");
+        const message = e.message || String(e);
+        message.split('\n').forEach(line => {
+            console.log(`  ${line}`);
+        });
+        console.log("");
+
+        outro(picocolors.red("Build failed. Fix the issues above and try again."));
+        process.exit(1);
+    }
+}

package/src/cli/commands/dev.ts

@@ -0,0 +1,92 @@
+
+import { watch } from "node:fs";
+import { intro, outro, spinner } from "@clack/prompts";
+import picocolors from "picocolors";
+import { loadConfig } from "../utils/config";
+import { buildProject } from "../builder";
+import { join } from "node:path";
+
+export async function devCommand() {
+    intro(picocolors.bgBlue(" 🧵 Weaver Dev "));
+
+    const s = spinner();
+    s.start("Starting development server...");
+
+    const config = await loadConfig();
+
+    // Initial build
+    try {
+        await buildProject(config, true);
+        s.stop(picocolors.green("Initial build complete!"));
+    } catch (e) {
+        s.stop(picocolors.red("Initial build failed"));
+        console.error(e);
+        // Continue watching even if build fails? Yes, to fix errors.
+    }
+
+    console.log(picocolors.cyan(`Watching for changes in ${picocolors.bold("src/")}...`));
+
+    let isBuilding = false;
+
+    // Recursive watch on src/
+    // Debounce simply by ignoring triggers while building?
+    watch("src", { recursive: true }, async (event, filename) => {
+        if (filename && (filename.endsWith(".ts") || filename.endsWith(".tsx"))) {
+            if (isBuilding) return;
+            isBuilding = true;
+            
+            console.log(picocolors.dim(`File changed: ${filename}`));
+            const rebuildSpinner = spinner();
+            rebuildSpinner.start("Rebuilding...");
+            
+            try {
+                // Determine if we need full build or partial?
+                // For MVP, full build via buildProject.
+                const start = performance.now();
+                await buildProject(config, true);
+                const end = performance.now();
+                rebuildSpinner.stop(picocolors.green(`Rebuilt in ${(end - start).toFixed(0)}ms`));
+            } catch (e) {
+                rebuildSpinner.stop(picocolors.red("Rebuild failed"));
+                if (e instanceof Error) console.error(e.message);
+            } finally {
+                isBuilding = false;
+            }
+        }
+    });
+
+    // Also watch sandbox if present?
+    // Since we moved sandbox to root, we should watch it too if configured.
+    // However, sandbox usually lives outside src in this setup.
+    // Let's watch 'sandbox' too if it exists.
+    // Or watch root/sandbox.
+
+    // Using fs.watch implies we need a process keep-alive?
+    // Node.js keeps process alive as long as watcher is active.
+    
+    // Watch sandbox
+    try {
+        watch("sandbox", { recursive: true }, async (event, filename) => {
+             if (filename && (filename.endsWith(".ts") || filename.endsWith(".tsx"))) {
+                if (isBuilding) return;
+                isBuilding = true;
+                console.log(picocolors.dim(`Sandbox file changed: ${filename}`));
+                const rb = spinner();
+                rb.start("Rebuilding...");
+                try {
+                    const start = performance.now();
+                    await buildProject(config, true);
+                    const end = performance.now();
+                    rb.stop(picocolors.green(`Rebuilt (sandbox) in ${(end - start).toFixed(0)}ms`));
+                } catch (e) {
+                     rb.stop(picocolors.red("Rebuild failed"));
+                     if (e instanceof Error) console.error(e.message);
+                } finally {
+                    isBuilding = false;
+                }
+             }
+        });
+    } catch {
+        // sandbox might not exist or verify failed
+    }
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,228 @@
+
+import { intro, outro, text, select, confirm, spinner } from "@clack/prompts";
+import { findWoWPath } from "../utils/wow-path";
+import { writeFileSync, existsSync, mkdirSync } from "node:fs";
+import picocolors from "picocolors";
+
+export async function initCommand(options: any) {
+    intro(picocolors.bgBlue(" 🧵 Weaver Init "));
+    
+    // 1. Metadata Discovery
+    let defaultName = "MyAddon";
+    let defaultAuthor = "Me";
+    
+    if (existsSync("package.json")) {
+        try {
+            const pkg = JSON.parse(await Bun.file("package.json").text());
+            if (pkg.name) defaultName = pkg.name;
+            if (pkg.author) defaultAuthor = pkg.author;
+        } catch {}
+    }
+
+    let wowPath = "";
+    let addonName = defaultName;
+    let flavor = "_retail_";
+
+    if (options.yes) {
+        // NON-INTERACTIVE MODE
+        wowPath = (await findWoWPath()) || "C:\\Program Files (x86)\\World of Warcraft";
+    } else {
+        // INTERACTIVE MODE
+        // 2. WoW Path Discovery
+        const path = await findWoWPath();
+        wowPath = path || "";
+
+        if (path) {
+            const confirmPath = await confirm({
+                message: `Found WoW at ${picocolors.cyan(path)}. Use this?`,
+                initialValue: true
+            });
+            
+            if (!confirmPath) {
+                const manualPath = await text({
+                    message: "Enter the path to your World of Warcraft installation:",
+                    placeholder: "C:\\Program Files (x86)\\World of Warcraft",
+                    validate(value) {
+                        if (value.length === 0) return "Path is required";
+                    }
+                });
+                if (typeof manualPath === 'symbol') { process.exit(0); }
+                wowPath = manualPath;
+            }
+        } else {
+            const manualPath = await text({
+                message: "Could not auto-detect WoW. Enter the path manually:",
+                placeholder: "C:\\Program Files (x86)\\World of Warcraft",
+                validate(value) {
+                    if (value.length === 0) return "Path is required";
+                }
+            });
+            if (typeof manualPath === 'symbol') { process.exit(0); }
+            wowPath = manualPath;
+        }
+
+        // 3. Project Configuration
+        const addonNameInput = await text({
+            message: "Addon Name (used for folder name and TOC):",
+            placeholder: defaultName,
+            validate(value) { 
+                if (value && !/^[a-zA-Z0-9]+$/.test(value)) return "Only alphanumeric characters allowed"; 
+            }
+        });
+        if (typeof addonNameInput === 'symbol') { process.exit(0); }
+        addonName = (addonNameInput || defaultName) as string;
+
+        const flavorInput = await select({
+            message: "Target Game Version:",
+            options: [
+                { value: "_retail_", label: "Retail (The War Within)" },
+                { value: "_classic_", label: "Cataclysm Classic" },
+                { value: "_classic_era_", label: "Classic Era / Hardcore" },
+            ],
+        }) as string;
+        if (typeof flavorInput === 'symbol') { process.exit(0); }
+        flavor = flavorInput;
+    }
+
+    // Map flavor to default interface version
+    const interfaceMap: Record<string, string> = {
+        "_retail_": "110007",
+        "_classic_": "40400",
+        "_classic_era_": "11503",
+    };
+    const interfaceVersion = interfaceMap[flavor] || "110000";
+
+    const s = spinner();
+    s.start("Scaffolding your Weaver project...");
+
+    // 4. File Generation
+
+    // weaver.config.ts
+    const configContent = `
+import type { WeaverConfig } from "@weaver-wow/core";
+
+const config: WeaverConfig = {
+    addonName: "${addonName}",
+    flavor: "${flavor}",
+    interface: "${interfaceVersion}",
+    wowPath: String.raw\`${wowPath}\`,
+};
+
+export default config;
+`.trim();
+    writeFileSync("weaver.config.ts", configContent);
+
+    // tsconfig.json (Standard TSTL + Weaver setup)
+    const tsconfigContent = `
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext"],
+    "moduleResolution": "Node",
+    "types": [],
+    "jsx": "react",
+    "jsxFactory": "createElement",
+    "strict": false,
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "baseUrl": ".",
+    "paths": {
+      "react/jsx-runtime": ["node_modules/@weaver-wow/core/src/types/react-jsx-runtime.d.ts"]
+    }
+  },
+  "tstl": {
+    "luaTarget": "5.1",
+    "luaBundle": "dist/App.lua",
+    "noHeader": true
+  },
+  "include": ["src/**/*.tsx", "src/**/*.ts", "src/**/*.d.ts"]
+}
+`.trim();
+    if (!existsSync("tsconfig.json")) {
+        writeFileSync("tsconfig.json", tsconfigContent);
+    }
+
+    // src/App.tsx (Starter code)
+    if (!existsSync("src")) {
+        mkdirSync("src");
+    }
+    
+    if (!existsSync("src/App.tsx") && !existsSync("src/index.tsx")) {
+        const appContent = `
+import { 
+    useState, 
+    useEffect, 
+    Frame, 
+    Texture, 
+    Button, 
+    mount,
+    createElement
+} from '@weaver-wow/core';
+
+const ${addonName} = () => {
+    const [clicks, setClicks] = useState("clickCount", 0);
+
+    useEffect(() => {
+        print("${addonName} initialized!");
+    }, []);
+
+    return (
+        <Frame name="${addonName}Frame" size={[220, 100]} setPoint={["CENTER", 0, 0]}>
+            <Texture setAllPoints={true} color={[0, 0, 0, 0.6]} />
+            <Button 
+                text={\`Clicks: \${clicks}\`} 
+                onClick={() => setClicks(clicks + 1)} 
+            />
+        </Frame>
+    );
+};
+
+mount("${addonName}", () => ${addonName}());
+`.trim();
+        writeFileSync("src/App.tsx", appContent);
+    }
+
+    // package.json (if missing)
+    if (!existsSync("package.json")) {
+        const packageContent = {
+            name: addonName.toLowerCase(),
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: {
+                "build": "bun x wvr build",
+                "dev": "bun x wvr dev",
+                "link": "bun x wvr link"
+            },
+            dependencies: {
+                "@weaver-wow/core": "^1.0.0"
+            },
+            devDependencies: {
+                "typescript-to-lua": "latest"
+            }
+        };
+        writeFileSync("package.json", JSON.stringify(packageContent, null, 2));
+    }
+
+    // .gitignore
+    const gitignoreContent = `
+node_modules/
+dist/
+.tstl.build.json
+*.log
+`.trim();
+    if (!existsSync(".gitignore")) {
+        writeFileSync(".gitignore", gitignoreContent);
+    }
+
+    s.stop("Project initialized successfully!");
+    
+    outro(`
+    ${picocolors.green("Project layout created:")}
+    - ${picocolors.cyan("src/App.tsx")}        (Addon source)
+    - ${picocolors.cyan("weaver.config.ts")}  (Addon metadata)
+    - ${picocolors.cyan("tsconfig.json")}     (Compiler settings)
+
+    Run ${picocolors.bold("bun install")} and then ${picocolors.bold("bun run dev")} to start coding!
+    `);
+}

package/src/cli/commands/link.ts

@@ -0,0 +1,126 @@
+
+import { symlinkSync, existsSync, rmSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { intro, outro, spinner, confirm, text } from "@clack/prompts";
+import picocolors from "picocolors";
+import { loadConfig } from "../utils/config";
+import { findWoWPath } from "../utils/wow-path";
+
+export async function linkCommand() {
+    intro(picocolors.bgBlue(" 🧵 Weaver Link "));
+
+    const s = spinner();
+    s.start("Reading configuration...");
+
+    let config = await loadConfig();
+    
+    // Determine Addon Name
+    let addonName = config?.addonName;
+    if (!addonName && existsSync("package.json")) {
+        try {
+            const pkg = JSON.parse(await Bun.file("package.json").text());
+            addonName = pkg.name ? pkg.name.charAt(0).toUpperCase() + pkg.name.slice(1) : "MyAddon";
+        } catch {}
+    }
+    addonName = addonName || "MyAddon";
+
+    // Determine WoW Path
+    let wowPath = config?.wowPath;
+    if (!wowPath) {
+        s.stop("Searching for WoW installation...");
+        wowPath = await findWoWPath();
+        
+        if (!wowPath) {
+             const manualPath = await text({
+                message: "Could not auto-detect WoW. Enter path manually:",
+                placeholder: "C:\\Program Files (x86)\\World of Warcraft"
+            });
+            if (typeof manualPath === 'symbol') process.exit(0);
+            wowPath = manualPath as string;
+        } else {
+            const useFound = await confirm({
+                message: `Found WoW at ${picocolors.cyan(wowPath)}. Use this?`,
+                initialValue: true
+            });
+            if (!useFound) {
+                 const manualPath = await text({
+                    message: "Enter path manually:",
+                    placeholder: "C:\\Program Files (x86)\\World of Warcraft"
+                });
+                if (typeof manualPath === 'symbol') process.exit(0);
+                wowPath = manualPath as string;
+            }
+        }
+    }
+
+    if (!wowPath) {
+        console.error(picocolors.red("WoW path is required."));
+        process.exit(1);
+    }
+
+    // Determine target directory (Interface/AddOns)
+    // Default to retail for now, or use config.flavor
+    const flavor = config?.flavor || "_retail_";
+    const addonsDir = join(wowPath, flavor, "Interface", "AddOns");
+    
+    if (!existsSync(addonsDir)) {
+        console.error(picocolors.red(`Could not find AddOns directory at: ${addonsDir}`));
+        console.log(picocolors.yellow(`(Make sure you have run the game at least once to create folders)`));
+        process.exit(1);
+    }
+
+    const targetLinkPath = join(addonsDir, addonName);
+    const sourceDistPath = resolve("dist"); // Absolute path to dist
+
+    if (!existsSync(sourceDistPath)) {
+        console.error(picocolors.red("dist/ folder does not exist. Run 'bun wvr build' first."));
+        process.exit(1);
+    }
+
+    s.start(`Linking ${picocolors.cyan(addonName)} to WoW...`);
+
+    // Check if link already exists
+    if (existsSync(targetLinkPath)) {
+        const stats = statSync(targetLinkPath);
+        if (stats.isSymbolicLink()) {
+            s.stop("Link already exists.");
+            // Maybe check where it points?
+            outro("Addon is already linked.");
+            return;
+        } else {
+            // It's a real folder?
+            s.stop("Target exists as a real folder.");
+            const overwrite = await confirm({
+                message: `Folder ${targetLinkPath} already exists (not a link). Delete and link?`,
+                initialValue: false
+            });
+            if (!overwrite) {
+                outro("Aborted.");
+                return;
+            }
+            s.start("Removing existing folder...");
+            try {
+                rmSync(targetLinkPath, { recursive: true, force: true }); // Dangerous?
+            } catch (e) {
+                s.stop(picocolors.red("Failed to remove existing folder."));
+                 console.error(e);
+                 process.exit(1);
+            }
+        }
+    }
+
+    // Create Symlink
+    try {
+        // Use "junction" for Windows directory links without admin
+        const type = process.platform === "win32" ? "junction" : "dir";
+        symlinkSync(sourceDistPath, targetLinkPath, type);
+    } catch (e) {
+        s.stop(picocolors.red("Failed to create symlink"));
+        console.error("Error details:", e);
+        console.log(picocolors.yellow("Try running as Administrator if on Windows."));
+        process.exit(1);
+    }
+
+    s.stop(picocolors.green("Linked successfully!"));
+    outro(`Dev changes in ${picocolors.bold("dist/")} will now reflect in WoW immediately.`);
+}

package/src/cli/index.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { initCommand } from "./commands/init";
+import { buildCommand } from "./commands/build";
+import { devCommand } from "./commands/dev";
+import { linkCommand } from "./commands/link";
+
+const program = new Command();
+
+program
+    .name("wvr")
+    .description("Weaver Addon Toolchain")
+    .version("1.0.0");
+
+program.command("init")
+    .description("Initialize a new Weaver project")
+    .option("-y, --yes", "Skip prompts and use defaults")
+    .action((options) => initCommand(options));
+
+program.command("build")
+    .description("Build the addon for production")
+    .action(() => buildCommand());
+
+program.command("dev")
+    .description("Start development server (watch mode)")
+    .action(() => devCommand());
+
+program.command("link")
+    .description("Symlink dist folder to WoW AddOns")
+    .action(() => linkCommand());
+
+program.parse(process.argv);

package/src/cli/utils/config.ts

@@ -0,0 +1,16 @@
+
+import { existsSync } from "node:fs";
+import { WeaverConfig } from "../../schema";
+
+export async function loadConfig(): Promise<WeaverConfig | null> {
+    if (existsSync("weaver.config.ts")) {
+        try {
+             const configPath = Bun.pathToFileURL("weaver.config.ts").href;
+             const configModule = await import(configPath);
+             return configModule.default;
+        } catch (e) {
+            console.warn("Failed to load weaver.config.ts:", e);
+        }
+    }
+    return null;
+}

package/src/cli/utils/wow-path.ts

@@ -0,0 +1,44 @@
+
+import { $ } from "bun";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+export async function findWoWPath(): Promise<string | null> {
+    // 1. Try Registry (Windows only)
+    if (process.platform === "win32") {
+        try {
+            const result = await $`reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Blizzard Entertainment\\World of Warcraft" /v InstallPath`.text();
+            // Output looks like: "    InstallPath    REG_SZ    C:\Program Files (x86)\World of Warcraft\"
+            const match = result.match(/REG_SZ\s+(.*)/);
+            if (match && match[1]) {
+                const path = match[1].trim();
+                if (existsSync(path)) return path;
+            }
+        } catch (e) {
+            // Registry key not found or error accessing reg command
+        }
+    }
+
+    // 2. Common Path Scan
+    const commonPaths = [
+        "C:\\Games\\World of Warcraft",
+        "D:\\Games\\World of Warcraft",
+        "E:\\Games\\World of Warcraft",
+        "C:\\Program Files (x86)\\World of Warcraft",
+        "C:\\Program Files\\World of Warcraft"
+    ];
+
+    for (const path of commonPaths) {
+        if (existsSync(path)) return path;
+    }
+
+    return null;
+}
+
+export function validateWoWPath(path: string): boolean {
+    const retail = join(path, "_retail_");
+    const classic = join(path, "_classic_");
+    const classicEra = join(path, "_classic_era_");
+    
+    return existsSync(retail) || existsSync(classic) || existsSync(classicEra);
+}

package/src/schema.ts

@@ -0,0 +1,18 @@
+
+import { z } from "zod";
+import type { WeaverConfig as IWeaverConfig } from "../../weaver/src/types/config";
+
+export const WeaverConfigSchema = z.object({
+    addonName: z.string(),
+    flavor: z.enum(["_retail_", "_classic_", "_classic_era_"]),
+    interface: z.string(),
+    outDir: z.string().optional().default("Interface/AddOns"),
+    entry: z.string().optional().default("src/App.tsx"),
+    wowPath: z.string().optional().nullable(),
+});
+
+export type WeaverConfig = z.infer<typeof WeaverConfigSchema>;
+
+// Verify it matches the interface
+type Verification = WeaverConfig extends IWeaverConfig ? (IWeaverConfig extends WeaverConfig ? true : false) : false;
+const _v: Verification = true;