@addmo/create-addmo-app 0.1.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 addmo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @addmo/create-addmo-app
+
+[中文](README-zh_CN.md) | English
+
+---
+
+Interactive scaffolder: generates a addmo-based extension project from options (template, package manager, entries, skills).
+
+- Commands: `create-addmo-app` or `pnpm create addmo-app` (and npm/yarn/bun equivalents)
+- Flow: (1) select framework (vanilla / vue / react / preact / svelte / solid), (2) language (TypeScript / JavaScript), (3) package manager (pnpm / npm / yarn / bun), (4) entries to include (multi-select), (5) whether to install addmo skills (yes/no). Output to cwd or a given directory. Generated project uses **addmo.config.ts** or **addmo.config.js** with minimal manifest (entry discovery; no built-in entry paths in manifest).
+
+## Templates
+
+Scaffold templates live at **repo root** in **`templates/`** (e.g. `template-vanilla-ts`, `template-react-ts`). The CLI downloads the chosen template from the GitHub repo tarball, so the repo must have `templates/` at root and committed. The npm package does not bundle templates; it fetches from GitHub at scaffold time.

package/dist/cli.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { execSync } from "node:child_process";
+import prompts from "prompts";
+import { blue, cyan, dim, gray, green, lightBlue, red, trueColor, yellow } from "kolorist";
+import minimist from "minimist";
+import { gunzipSync } from "node:zlib";
+import { detectPackageManager, getExecCommand, getInstallCommand, getRunCommand } from "@addmo/pkg-manager";
+const GITHUB_REPO = "gxy5202/addmo";
+const TEMPLATE_BASE = "templates";
+function getRepoRoot() {
+    const fromDist = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    return fromDist;
+}
+function tryLocalTemplates(templateName, destDir) {
+    const repoRoot = getRepoRoot();
+    const templatePath = join(repoRoot, TEMPLATE_BASE, templateName);
+    if (!existsSync(templatePath)) return false;
+    mkdirSync(destDir, {
+        recursive: true
+    });
+    cpSync(templatePath, destDir, {
+        recursive: true
+    });
+    return true;
+}
+function parseTarHeader(buf) {
+    if (buf.every((b)=>0 === b)) return null;
+    const rawName = buf.subarray(0, 100).toString("utf8").replace(/\0+$/, "");
+    const sizeStr = buf.subarray(124, 136).toString("utf8").replace(/\0+$/, "").trim();
+    const type = String.fromCharCode(buf[156]);
+    const prefix = buf.subarray(345, 500).toString("utf8").replace(/\0+$/, "");
+    return {
+        name: prefix ? `${prefix}/${rawName}` : rawName,
+        size: parseInt(sizeStr, 8) || 0,
+        type
+    };
+}
+function extractMatchingFiles(tarBuffer, templatePrefix, destDir) {
+    let offset = 0;
+    while(offset + 512 <= tarBuffer.length){
+        const header = parseTarHeader(tarBuffer.subarray(offset, offset + 512));
+        offset += 512;
+        if (!header) break;
+        const dataBlocks = 512 * Math.ceil(header.size / 512);
+        const idx = header.name.indexOf(templatePrefix);
+        if (-1 !== idx) {
+            const relativePath = header.name.substring(idx + templatePrefix.length).replace(/^\//, "");
+            if (relativePath) {
+                const destPath = join(destDir, relativePath);
+                const isDir = "5" === header.type || relativePath.endsWith("/");
+                if (isDir) mkdirSync(destPath, {
+                    recursive: true
+                });
+                else if ("0" === header.type || "\0" === header.type) {
+                    mkdirSync(dirname(destPath), {
+                        recursive: true
+                    });
+                    writeFileSync(destPath, tarBuffer.subarray(offset, offset + header.size));
+                }
+            }
+        }
+        offset += dataBlocks;
+    }
+}
+async function downloadTemplate(templateName, destDir, branch = "main") {
+    const url = `https://codeload.github.com/${GITHUB_REPO}/tar.gz/${branch}`;
+    const templatePrefix = `${TEMPLATE_BASE}/${templateName}/`;
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    const compressed = Buffer.from(await response.arrayBuffer());
+    const tarBuffer = gunzipSync(compressed);
+    mkdirSync(destDir, {
+        recursive: true
+    });
+    extractMatchingFiles(tarBuffer, templatePrefix, destDir);
+}
+const FRAMEWORKS = [
+    {
+        title: "Vanilla",
+        value: "vanilla"
+    },
+    {
+        title: "Vue",
+        value: "vue"
+    },
+    {
+        title: "React",
+        value: "react"
+    },
+    {
+        title: "Preact",
+        value: "preact"
+    },
+    {
+        title: "Svelte",
+        value: "svelte"
+    },
+    {
+        title: "Solid",
+        value: "solid"
+    }
+];
+function getTemplateName(framework, language) {
+    return `template-${framework}-${language}`;
+}
+const PACKAGE_MANAGER_CHOICES = [
+    {
+        title: "pnpm",
+        value: "pnpm"
+    },
+    {
+        title: "npm",
+        value: "npm"
+    },
+    {
+        title: "yarn",
+        value: "yarn"
+    },
+    {
+        title: "bun",
+        value: "bun"
+    }
+];
+const ENTRY_NAMES = [
+    "popup",
+    "options",
+    "background",
+    "content",
+    "devtools",
+    "sidepanel",
+    "sandbox",
+    "newtab",
+    "bookmarks",
+    "history",
+    "offscreen"
+];
+const ENTRY_APP_DIRS = ENTRY_NAMES;
+const ENTRY_CHOICES = [
+    {
+        title: "All (popup, options, background, content, …)",
+        value: "__all__"
+    },
+    ...ENTRY_NAMES.map((name)=>({
+            title: name,
+            value: name
+        }))
+];
+const APP_DIR = "app";
+function filterAppEntries(destDir, selectedEntries) {
+    const useAll = selectedEntries.includes("__all__");
+    if (useAll) return;
+    const keepSet = new Set(selectedEntries);
+    const appPath = join(destDir, APP_DIR);
+    if (!existsSync(appPath)) return;
+    const dirs = readdirSync(appPath, {
+        withFileTypes: true
+    }).filter((d)=>d.isDirectory()).map((d)=>d.name);
+    for (const dir of dirs){
+        const isEntryDir = ENTRY_APP_DIRS.includes(dir);
+        if (isEntryDir && !keepSet.has(dir)) rmSync(join(appPath, dir), {
+            recursive: true
+        });
+    }
+}
+function getExistingAppEntryDirs(destDir) {
+    const appPath = join(destDir, APP_DIR);
+    if (!existsSync(appPath)) return [];
+    return readdirSync(appPath, {
+        withFileTypes: true
+    }).filter((d)=>d.isDirectory()).map((d)=>d.name).filter((name)=>ENTRY_APP_DIRS.includes(name));
+}
+function getPluginBlock(framework) {
+    switch(framework){
+        case "react":
+            return {
+                import: "import { pluginReact } from \"@rsbuild/plugin-react\";",
+                usage: "plugins: [pluginReact()],"
+            };
+        case "preact":
+            return {
+                import: "import { pluginPreact } from \"@rsbuild/plugin-preact\";",
+                usage: "plugins: [pluginPreact()],"
+            };
+        case "vue":
+            return {
+                import: "import { pluginVue } from \"@rsbuild/plugin-vue\";",
+                usage: "plugins: [pluginVue()],"
+            };
+        case "svelte":
+            return {
+                import: "import { pluginSvelte } from \"@rsbuild/plugin-svelte\";",
+                usage: "plugins: [pluginSvelte()],"
+            };
+        case "solid":
+            return {
+                import: "import { pluginSolid } from \"@rsbuild/plugin-solid\";",
+                usage: "plugins: [pluginSolid()],"
+            };
+        default:
+            return {
+                import: "",
+                usage: ""
+            };
+    }
+}
+const MINIMAL_MANIFEST = '  name: "My Extension",\n  version: "1.0.0",\n  manifest_version: 3,\n  description: "Browser extension built with addmo",\n  permissions: ["storage", "activeTab"],';
+function generateAddmoConfig(framework, _language) {
+    const { import: pluginImport, usage: pluginUsage } = getPluginBlock(framework);
+    const parts = [
+        "import { defineConfig } from \"addmo\";",
+        pluginImport ? `\n${pluginImport}\n` : "",
+        "const manifest = {",
+        MINIMAL_MANIFEST,
+        "};",
+        "",
+        "export default defineConfig({",
+        "  manifest: { chromium: manifest, firefox: { ...manifest } },",
+        ...pluginUsage ? [
+            `  ${pluginUsage}`
+        ] : [],
+        "});"
+    ];
+    return parts.filter(Boolean).join("\n");
+}
+const DASH_H = " - - - - - - - - - - - - - - - - - - - - - - - - - ";
+const INNER_W = DASH_H.length;
+function printAddmoLogo(colorFn) {
+    const c = colorFn;
+    const top = "  " + c("┌" + DASH_H + "┐");
+    const empty = "  " + c("│") + " ".repeat(INNER_W) + c("│");
+    const text = "Addmo";
+    const pad = Math.max(0, Math.floor((INNER_W - text.length) / 2));
+    const textLine = "  " + c("│") + " ".repeat(pad) + c(text) + " ".repeat(INNER_W - pad - text.length) + c("│");
+    const bottom = "  " + c("└" + DASH_H + "┘");
+    const art = [
+        "",
+        top,
+        empty,
+        textLine,
+        empty,
+        bottom,
+        ""
+    ].join("\n");
+    console.log(art);
+}
+const cli_require = createRequire(import.meta.url);
+try {
+    const figures = cli_require("prompts/lib/util/figures");
+    figures.radioOn = "\u25CF";
+    figures.radioOff = "\u25CB";
+} catch  {}
+const SKILLS_REPO = "addmo-dev/skills";
+const orange = trueColor(230, 138, 46);
+function getFrameworkChoicesColored() {
+    const colors = {
+        vanilla: gray,
+        vue: green,
+        react: cyan,
+        preact: yellow,
+        svelte: red,
+        solid: lightBlue
+    };
+    return FRAMEWORKS.map((f)=>({
+            ...f,
+            title: colors[f.value](f.title)
+        }));
+}
+function getLanguageChoicesColored() {
+    return [
+        {
+            title: cyan("TypeScript"),
+            value: "ts"
+        },
+        {
+            title: yellow("JavaScript"),
+            value: "js"
+        }
+    ];
+}
+function getPackageManagerChoicesColored() {
+    const colors = {
+        pnpm: orange,
+        npm: red,
+        yarn: blue,
+        bun: green
+    };
+    return PACKAGE_MANAGER_CHOICES.map((c)=>({
+            ...c,
+            title: colors[c.value](c.title)
+        }));
+}
+function getVersion() {
+    try {
+        const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version ?? "0.0.0";
+    } catch  {
+        return "0.0.0";
+    }
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`
+  create-addmo-app v${version}
+
+  Create a new addmo extension project
+
+  Usage:
+    create-addmo-app [project-name] [options]
+
+  Options:
+    --framework <name>   Skip prompt: vanilla | vue | react | preact | svelte | solid
+    --language  <lang>   Skip prompt: js | ts
+    --help               Show this help message
+    --version            Show version number
+
+  Steps: 1) framework  2) language  3) package manager (pnpm|npm|yarn|bun)  4) entries  5) install skills
+`);
+}
+async function confirmOverwrite(dir) {
+    const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: `Directory "${dir}" already exists. Overwrite?`,
+        initial: false
+    });
+    return !!overwrite;
+}
+async function promptOptions() {
+    const res = await prompts([
+        {
+            type: "select",
+            name: "framework",
+            message: "Select a framework",
+            choices: getFrameworkChoicesColored()
+        },
+        {
+            type: "select",
+            name: "language",
+            message: "Select a language",
+            choices: getLanguageChoicesColored()
+        },
+        {
+            type: "select",
+            name: "packageManager",
+            message: "Select package manager",
+            choices: getPackageManagerChoicesColored()
+        },
+        {
+            type: "multiselect",
+            name: "entries",
+            message: "Select extension entries",
+            choices: ENTRY_CHOICES,
+            min: 1,
+            initial: 0,
+            hint: "Space to toggle, Enter to confirm (○ unselected, ● selected)"
+        }
+    ]);
+    if (!res.framework || !res.language || !res.packageManager || !res.entries?.length) return null;
+    return {
+        framework: res.framework,
+        language: res.language,
+        packageManager: res.packageManager,
+        entries: res.entries
+    };
+}
+function updatePackageName(destDir, projectName) {
+    const pkgPath = resolve(destDir, "package.json");
+    if (!existsSync(pkgPath)) return;
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    pkg.name = projectName.replace(/\s+/g, "-").toLowerCase();
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+}
+async function main() {
+    const argv = minimist(process.argv.slice(2));
+    if (argv.help || argv.h) return void printHelp();
+    if (argv.version || argv.v) return void console.log(getVersion());
+    const targetDir = argv._[0] ?? "my-extension";
+    const cliFramework = argv.framework;
+    const cliLanguage = argv.language;
+    printAddmoLogo(orange);
+    console.log(blue("\n  Create Addmo App\n"));
+    const root = resolve(process.cwd(), targetDir);
+    if (existsSync(root)) {
+        const confirmed = await confirmOverwrite(targetDir);
+        if (!confirmed) process.exit(0);
+    }
+    const options = cliFramework && cliLanguage ? {
+        framework: cliFramework,
+        language: cliLanguage,
+        packageManager: detectPackageManager(),
+        entries: [
+            "__all__"
+        ]
+    } : await promptOptions();
+    if (!options) process.exit(0);
+    const pm = options.packageManager;
+    const templateName = getTemplateName(options.framework, options.language);
+    console.log(yellow("\n  Downloading template...\n"));
+    try {
+        tryLocalTemplates(templateName, root) || await downloadTemplate(templateName, root);
+    } catch (err) {
+        console.error(red(`\n  Failed to download template: ${err.message}\n`));
+        process.exit(1);
+    }
+    const useAllEntries = options.entries.includes("__all__");
+    const existingDirs = getExistingAppEntryDirs(root);
+    const effectiveEntries = useAllEntries ? [
+        "__all__"
+    ] : options.entries.filter((e)=>"__all__" !== e && existingDirs.includes(e));
+    if (!useAllEntries && effectiveEntries.length > 0) filterAppEntries(root, effectiveEntries);
+    const configExt = "ts" === options.language ? "ts" : "js";
+    const configPath = resolve(root, `addmo.config.${configExt}`);
+    const configContent = generateAddmoConfig(options.framework, options.language);
+    writeFileSync(configPath, configContent, "utf-8");
+    updatePackageName(root, targetDir);
+    const installCmd = getInstallCommand(pm);
+    const devCmd = getRunCommand(pm, "dev");
+    const { installSkills } = await prompts({
+        type: "select",
+        name: "installSkills",
+        message: "Install addmo skills?",
+        choices: [
+            {
+                title: "Yes",
+                value: true
+            },
+            {
+                title: "No",
+                value: false
+            }
+        ],
+        initial: 0
+    });
+    if (true === installSkills) {
+        const execCmd = getExecCommand(pm);
+        const fullCmd = `${execCmd} skills add ${SKILLS_REPO}`;
+        console.log(yellow("\n  Running: " + fullCmd + "\n"));
+        try {
+            execSync(fullCmd, {
+                cwd: root,
+                stdio: "inherit"
+            });
+        } catch  {
+            console.log(dim("  (Skills install skipped or failed; you can run it later.)\n"));
+        }
+    }
+    console.log(green("\n  ✓ Project created successfully\n"));
+    console.log(dim("  Next steps:\n"));
+    console.log(`  cd ${targetDir}`);
+    console.log(`  ${installCmd}`);
+    console.log(`  ${devCmd}\n`);
+}
+main().catch((e)=>{
+    console.error(e);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@addmo/create-addmo-app",
+  "version": "0.1.1-beta.1",
+  "description": "Interactive scaffolder for addmo extension projects",
+  "type": "module",
+  "bin": {
+    "create-addmo-app": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "prompts": "^2.4.2",
+    "kolorist": "^1.8.0",
+    "minimist": "^1.2.8",
+    "@addmo/pkg-manager": "0.1.1-beta.1"
+  },
+  "devDependencies": {
+    "@rslib/core": "^0.20.0",
+    "@rstest/core": "^0.9.2",
+    "@rstest/coverage-istanbul": "^0.3.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "start": "node dist/cli.js",
+    "test": "rstest run",
+    "test:coverage": "rstest run --coverage"
+  }
+}