@gurulu/cli 0.1.0

package/dist/config.js

@@ -0,0 +1,329 @@
+"use strict";
+/**
+ * Phase 18.5 W2 — Multi-profile CLI config.
+ *
+ * Replaces the single-profile `~/.gurulu/config.json` used by earlier phases
+ * with a profile-aware store, while keeping backward compatibility for
+ * commands that still call `utils/config.ts` (they now read from the
+ * currently-active profile).
+ *
+ * Resolution order for a live session:
+ *   1. GURULU_SECRET_KEY  (env-var override — bypasses the file entirely)
+ *   2. --profile <name>   (CLI flag)
+ *   3. GURULU_PROFILE     (env)
+ *   4. default_profile    (from file)
+ *   5. 'personal'         (final fallback)
+ *
+ * Optional macOS keychain integration: if `keytar` is available at runtime,
+ * secrets can be stored there under service 'io.gurulu.cli' account
+ * `<profile>`. If unavailable, secrets fall back to the plaintext file.
+ * Keytar is a **soft runtime require** — never a hard dependency, because
+ * it's a native module and we don't want to force its install.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileNotFoundError = void 0;
+exports.configPath = configPath;
+exports.readKeychainSecret = readKeychainSecret;
+exports.writeKeychainSecret = writeKeychainSecret;
+exports.deleteKeychainSecret = deleteKeychainSecret;
+exports.isKeychainAvailable = isKeychainAvailable;
+exports.listProfiles = listProfiles;
+exports.getStoredProfile = getStoredProfile;
+exports.getDefaultProfileName = getDefaultProfileName;
+exports.setDefaultProfile = setDefaultProfile;
+exports.saveProfile = saveProfile;
+exports.deleteProfile = deleteProfile;
+exports.deleteAllProfiles = deleteAllProfiles;
+exports.loadActiveProfile = loadActiveProfile;
+exports.getActiveProfile = getActiveProfile;
+exports.defaultApiBase = defaultApiBase;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const DEFAULT_API_BASE = 'https://gurulu.io';
+const KEYCHAIN_SERVICE = 'io.gurulu.cli';
+function configHome() {
+    if (process.env.GURULU_CONFIG_HOME)
+        return process.env.GURULU_CONFIG_HOME;
+    return path.join(os.homedir(), '.gurulu');
+}
+function configPath() {
+    return path.join(configHome(), 'config.json');
+}
+function emptyFile() {
+    return { default_profile: 'personal', profiles: {} };
+}
+function readFileRaw() {
+    const p = configPath();
+    if (!fs.existsSync(p))
+        return emptyFile();
+    try {
+        const txt = fs.readFileSync(p, 'utf8');
+        const parsed = JSON.parse(txt);
+        if (parsed && typeof parsed === 'object' && parsed.profiles) {
+            return parsed;
+        }
+        // Migrate legacy `{ apiKey, email }` single-profile config.
+        if (parsed && typeof parsed === 'object' && parsed.apiKey) {
+            const migrated = {
+                default_profile: 'personal',
+                profiles: {
+                    personal: {
+                        email: parsed.email || '',
+                        secret_key: parsed.apiKey,
+                        api_base: DEFAULT_API_BASE,
+                    },
+                },
+            };
+            return migrated;
+        }
+        return emptyFile();
+    }
+    catch {
+        return emptyFile();
+    }
+}
+function writeFileRaw(cfg) {
+    const home = configHome();
+    if (!fs.existsSync(home)) {
+        fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+    }
+    else {
+        try {
+            fs.chmodSync(home, 0o700);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const p = configPath();
+    fs.writeFileSync(p, JSON.stringify(cfg, null, 2));
+    try {
+        fs.chmodSync(p, 0o600);
+    }
+    catch {
+        /* ignore on non-unix */
+    }
+}
+function warnBadPermissions() {
+    const p = configPath();
+    if (!fs.existsSync(p))
+        return;
+    try {
+        const stat = fs.statSync(p);
+        const mode = stat.mode & 0o777;
+        if (mode & 0o077) {
+            // Group/world readable — warn on stderr only.
+            process.stderr.write(`[warn] ${p} has insecure permissions (${mode.toString(8)}). Run: chmod 600 ${p}\n`);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+function tryRequireKeytar() {
+    if (process.env.GURULU_DISABLE_KEYCHAIN === '1')
+        return null;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        return require('keytar');
+    }
+    catch {
+        return null;
+    }
+}
+async function readKeychainSecret(profile) {
+    const kt = tryRequireKeytar();
+    if (!kt)
+        return null;
+    try {
+        return await kt.getPassword(KEYCHAIN_SERVICE, profile);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeKeychainSecret(profile, secret) {
+    const kt = tryRequireKeytar();
+    if (!kt)
+        return false;
+    try {
+        await kt.setPassword(KEYCHAIN_SERVICE, profile, secret);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function deleteKeychainSecret(profile) {
+    const kt = tryRequireKeytar();
+    if (!kt)
+        return;
+    try {
+        await kt.deletePassword(KEYCHAIN_SERVICE, profile);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function isKeychainAvailable() {
+    return tryRequireKeytar() !== null;
+}
+// --- public API --------------------------------------------------------------
+function listProfiles() {
+    const cfg = readFileRaw();
+    return Object.entries(cfg.profiles).map(([name, p]) => ({
+        name,
+        email: p.email,
+        api_base: p.api_base,
+        isDefault: name === cfg.default_profile,
+        keychain: !!p.keychain,
+    }));
+}
+function getStoredProfile(name) {
+    const cfg = readFileRaw();
+    return cfg.profiles[name] || null;
+}
+function getDefaultProfileName() {
+    const cfg = readFileRaw();
+    return cfg.default_profile || 'personal';
+}
+function setDefaultProfile(name) {
+    const cfg = readFileRaw();
+    if (!cfg.profiles[name]) {
+        throw new Error(`Profile '${name}' does not exist.`);
+    }
+    cfg.default_profile = name;
+    writeFileRaw(cfg);
+}
+async function saveProfile(name, profile, opts = {}) {
+    const cfg = readFileRaw();
+    const wantKeychain = !!opts.useKeychain && isKeychainAvailable();
+    let storedInKeychain = false;
+    if (wantKeychain) {
+        storedInKeychain = await writeKeychainSecret(name, profile.secret_key);
+    }
+    cfg.profiles[name] = storedInKeychain
+        ? { email: profile.email, api_base: profile.api_base, keychain: true }
+        : { email: profile.email, api_base: profile.api_base, secret_key: profile.secret_key };
+    if (!cfg.default_profile || !cfg.profiles[cfg.default_profile]) {
+        cfg.default_profile = name;
+    }
+    writeFileRaw(cfg);
+    return { storedInKeychain };
+}
+async function deleteProfile(name) {
+    const cfg = readFileRaw();
+    if (!cfg.profiles[name])
+        return false;
+    delete cfg.profiles[name];
+    if (cfg.default_profile === name) {
+        const remaining = Object.keys(cfg.profiles);
+        cfg.default_profile = remaining[0] || 'personal';
+    }
+    writeFileRaw(cfg);
+    await deleteKeychainSecret(name);
+    return true;
+}
+async function deleteAllProfiles() {
+    const cfg = readFileRaw();
+    const names = Object.keys(cfg.profiles);
+    for (const n of names)
+        await deleteKeychainSecret(n);
+    writeFileRaw({ default_profile: 'personal', profiles: {} });
+    return names;
+}
+/**
+ * Resolve the active profile given CLI flags. Throws if no usable profile.
+ * Accepts the `GURULU_SECRET_KEY` env var as an override for CI.
+ */
+async function loadActiveProfile(flags = {}) {
+    // 1. Environment override (bypasses file entirely — used by CI)
+    const envKey = process.env.GURULU_SECRET_KEY;
+    if (envKey) {
+        return {
+            name: flags.profile || process.env.GURULU_PROFILE || 'env',
+            email: process.env.GURULU_EMAIL || 'env@gurulu.local',
+            secret_key: envKey,
+            api_base: process.env.GURULU_API_BASE || DEFAULT_API_BASE,
+            source: 'env',
+        };
+    }
+    warnBadPermissions();
+    const cfg = readFileRaw();
+    const name = flags.profile || process.env.GURULU_PROFILE || cfg.default_profile || 'personal';
+    const stored = cfg.profiles[name];
+    if (!stored) {
+        throw new ProfileNotFoundError(name);
+    }
+    let secret = stored.secret_key || '';
+    let source = 'file';
+    if (stored.keychain) {
+        const kc = await readKeychainSecret(name);
+        if (kc) {
+            secret = kc;
+            source = 'keychain';
+        }
+        else if (!secret) {
+            throw new Error(`Profile '${name}' is marked as keychain-stored but the secret is missing. Run 'gurulu login --profile ${name}' again.`);
+        }
+    }
+    return {
+        name,
+        email: stored.email,
+        secret_key: secret,
+        api_base: stored.api_base || DEFAULT_API_BASE,
+        source,
+    };
+}
+async function getActiveProfile(flags = {}) {
+    try {
+        return await loadActiveProfile(flags);
+    }
+    catch {
+        return null;
+    }
+}
+class ProfileNotFoundError extends Error {
+    constructor(name) {
+        super(`Profile '${name}' not found. Run 'gurulu login' first.`);
+        this.name = 'ProfileNotFoundError';
+    }
+}
+exports.ProfileNotFoundError = ProfileNotFoundError;
+function defaultApiBase() {
+    return process.env.GURULU_API_BASE || DEFAULT_API_BASE;
+}

package/dist/frameworks/detect.d.ts

@@ -0,0 +1,8 @@
+export type Framework = 'nextjs-app' | 'nextjs-pages' | 'react-vite' | 'react-cra' | 'vue3' | 'nuxt3' | 'svelte' | 'sveltekit' | 'astro' | 'express' | 'nestjs' | 'html' | 'react-native' | 'ios-swift' | 'android-kotlin' | 'flutter' | 'unknown';
+export declare function detectFramework(projectDir: string): Framework;
+export declare function getSetupSnippet(framework: Framework, siteId: string, token: string): {
+    file: string;
+    code: string;
+    instruction: string;
+};
+export declare function getFrameworkDisplayName(fw: Framework): string;

package/dist/frameworks/detect.js

@@ -0,0 +1,362 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = detectFramework;
+exports.getSetupSnippet = getSetupSnippet;
+exports.getFrameworkDisplayName = getFrameworkDisplayName;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function detectFramework(projectDir) {
+    const pkgPath = path_1.default.join(projectDir, 'package.json');
+    const hasPkgJson = fs_1.default.existsSync(pkgPath);
+    // Mobile framework detection (non-package.json based)
+    if (fs_1.default.existsSync(path_1.default.join(projectDir, 'pubspec.yaml')))
+        return 'flutter';
+    const hasSwiftPkg = fs_1.default.existsSync(path_1.default.join(projectDir, 'Package.swift'));
+    const hasXcodeProj = fs_1.default.readdirSync(projectDir).some(f => f.endsWith('.xcodeproj'));
+    if (hasSwiftPkg || hasXcodeProj)
+        return 'ios-swift';
+    if (!hasPkgJson) {
+        // Android detection (no package.json means no RN false positive)
+        if (fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle.kts')) || fs_1.default.existsSync(path_1.default.join(projectDir, 'build.gradle'))) {
+            return 'android-kotlin';
+        }
+        return 'html';
+    }
+    const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    // React Native (must check before other React frameworks)
+    if (deps['react-native'])
+        return 'react-native';
+    if (deps['next']) {
+        // Check for app router
+        if (fs_1.default.existsSync(path_1.default.join(projectDir, 'src', 'app')) || fs_1.default.existsSync(path_1.default.join(projectDir, 'app'))) {
+            return 'nextjs-app';
+        }
+        return 'nextjs-pages';
+    }
+    if (deps['@nestjs/core'])
+        return 'nestjs';
+    if (deps['nuxt'])
+        return 'nuxt3';
+    if (deps['@sveltejs/kit'])
+        return 'sveltekit';
+    if (deps['svelte'])
+        return 'svelte';
+    if (deps['astro'])
+        return 'astro';
+    if (deps['vue'])
+        return 'vue3';
+    if (deps['@vitejs/plugin-react'])
+        return 'react-vite';
+    if (deps['react-scripts'])
+        return 'react-cra';
+    if (deps['express'])
+        return 'express';
+    return 'unknown';
+}
+function getSetupSnippet(framework, siteId, token) {
+    switch (framework) {
+        case 'nextjs-app':
+            return {
+                file: 'src/lib/gurulu.tsx',
+                code: `'use client';
+import { useEffect } from 'react';
+import { usePathname, useSearchParams } from 'next/navigation';
+
+export function GuruluProvider() {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+
+  useEffect(() => {
+    const script = document.createElement('script');
+    script.src = 'https://cdn.gurulu.io/t.js';
+    script.async = true;
+    script.dataset.siteId = '${siteId}';
+    script.dataset.token = '${token}';
+    document.head.appendChild(script);
+    return () => { document.head.removeChild(script); };
+  }, []);
+
+  useEffect(() => {
+    if (typeof window !== 'undefined' && (window as any).gurulu) {
+      (window as any).gurulu.track('pageview', {
+        page_url: pathname + (searchParams?.toString() ? '?' + searchParams.toString() : ''),
+      });
+    }
+  }, [pathname, searchParams]);
+
+  return null;
+}`,
+                instruction: 'Add <GuruluProvider /> inside <body> in your root layout.tsx',
+            };
+        case 'nextjs-pages':
+            return {
+                file: 'src/lib/gurulu.tsx',
+                code: `import Script from 'next/script';
+
+export function GuruluScript() {
+  return (
+    <Script
+      src="https://cdn.gurulu.io/t.js"
+      data-site-id="${siteId}"
+      data-token="${token}"
+      strategy="afterInteractive"
+    />
+  );
+}`,
+                instruction: 'Add <GuruluScript /> in your _app.tsx',
+            };
+        case 'react-vite':
+        case 'react-cra':
+            return {
+                file: 'src/gurulu.ts',
+                code: `// Gurulu.io Analytics
+export function initGurulu() {
+  if (typeof document === 'undefined') return;
+  const script = document.createElement('script');
+  script.src = 'https://cdn.gurulu.io/t.js';
+  script.async = true;
+  script.dataset.siteId = '${siteId}';
+  script.dataset.token = '${token}';
+  document.head.appendChild(script);
+}`,
+                instruction: 'Call initGurulu() in your main.tsx or index.tsx entry point',
+            };
+        case 'vue3':
+            return {
+                file: 'src/plugins/gurulu.ts',
+                code: `// Gurulu.io Analytics Plugin
+import type { App } from 'vue';
+
+export const guruluPlugin = {
+  install(app: App) {
+    if (typeof document === 'undefined') return;
+    const script = document.createElement('script');
+    script.src = 'https://cdn.gurulu.io/t.js';
+    script.async = true;
+    script.dataset.siteId = '${siteId}';
+    script.dataset.token = '${token}';
+    document.head.appendChild(script);
+  },
+};`,
+                instruction: 'Add app.use(guruluPlugin) in your main.ts',
+            };
+        case 'nuxt3':
+            return {
+                file: 'plugins/gurulu.client.ts',
+                code: `// Gurulu.io Analytics Plugin
+export default defineNuxtPlugin(() => {
+  if (typeof document === 'undefined') return;
+  const script = document.createElement('script');
+  script.src = 'https://cdn.gurulu.io/t.js';
+  script.async = true;
+  script.dataset.siteId = '${siteId}';
+  script.dataset.token = '${token}';
+  document.head.appendChild(script);
+});`,
+                instruction: 'Plugin auto-registered via plugins/ directory',
+            };
+        case 'svelte':
+            return {
+                file: 'src/lib/gurulu.ts',
+                code: `// Gurulu.io Analytics
+import { onMount } from 'svelte';
+
+export function initGurulu() {
+  onMount(() => {
+    const script = document.createElement('script');
+    script.src = 'https://cdn.gurulu.io/t.js';
+    script.async = true;
+    script.dataset.siteId = '${siteId}';
+    script.dataset.token = '${token}';
+    document.head.appendChild(script);
+  });
+}`,
+                instruction: 'Call initGurulu() in your root +layout.svelte or App.svelte',
+            };
+        case 'sveltekit':
+            return {
+                file: 'src/lib/gurulu.ts',
+                code: `// Gurulu.io Analytics
+import { browser } from '$app/environment';
+
+export function initGurulu() {
+  if (!browser) return;
+  const script = document.createElement('script');
+  script.src = 'https://cdn.gurulu.io/t.js';
+  script.async = true;
+  script.dataset.siteId = '${siteId}';
+  script.dataset.token = '${token}';
+  document.head.appendChild(script);
+}`,
+                instruction: 'Call initGurulu() in your root +layout.svelte onMount',
+            };
+        case 'astro':
+            return {
+                file: 'src/components/Gurulu.astro',
+                code: `---
+// Gurulu.io Analytics
+---
+<script src="https://cdn.gurulu.io/t.js" data-site-id="${siteId}" data-token="${token}" async></script>`,
+                instruction: 'Add <Gurulu /> in your Layout.astro <head>',
+            };
+        case 'express':
+            return {
+                file: 'src/gurulu.ts',
+                code: `// Gurulu.io Server Analytics
+import type { Request, Response, NextFunction } from 'express';
+
+const SITE_ID = '${siteId}';
+const TOKEN = '${token}';
+
+export function guruluMiddleware(req: Request, res: Response, next: NextFunction) {
+  // Track server-side pageview
+  fetch('https://ingest.gurulu.io/api/events', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + TOKEN },
+    body: JSON.stringify({
+      site_id: SITE_ID,
+      event: 'pageview',
+      url: req.originalUrl,
+      referrer: req.headers.referer || '',
+      user_agent: req.headers['user-agent'] || '',
+      ip: req.ip,
+      timestamp: new Date().toISOString(),
+    }),
+  }).catch(() => {});
+  next();
+}`,
+                instruction: 'Add app.use(guruluMiddleware) in your Express app',
+            };
+        case 'nestjs':
+            return {
+                file: 'src/gurulu.middleware.ts',
+                code: `// Gurulu.io Server Analytics Middleware
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+
+const SITE_ID = '${siteId}';
+const TOKEN = '${token}';
+
+@Injectable()
+export class GuruluMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    fetch('https://ingest.gurulu.io/api/events', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + TOKEN },
+      body: JSON.stringify({
+        site_id: SITE_ID,
+        event: 'pageview',
+        url: req.originalUrl,
+        referrer: req.headers.referer || '',
+        user_agent: req.headers['user-agent'] || '',
+        ip: req.ip,
+        timestamp: new Date().toISOString(),
+      }),
+    }).catch(() => {});
+    next();
+  }
+}`,
+                instruction: 'Apply GuruluMiddleware in your AppModule configure()',
+            };
+        case 'react-native':
+            return {
+                file: '',
+                code: `// npm install @gurulu/react-native
+import Gurulu from '@gurulu/react-native';
+
+Gurulu.initialize({
+  siteId: '${siteId}',
+  token: '${token}',
+  endpoint: 'https://ingest.gurulu.io/api/ingest/v1/collect',
+});`,
+                instruction: 'Run "npm install @gurulu/react-native" and add initialization to your App entry point',
+            };
+        case 'ios-swift':
+            return {
+                file: '',
+                code: `// Package.swift: add .package(url: "https://github.com/Preatan/gurulu-ios-sdk", from: "0.1.0")
+// AppDelegate.swift or @main App:
+import GuruluSDK
+
+GuruluSDK.shared.initialize(config: GuruluConfig(
+    siteId: "${siteId}",
+    token: "${token}",
+    endpoint: URL(string: "https://ingest.gurulu.io/api/ingest/v1/collect")!
+))`,
+                instruction: 'Add the SPM dependency and initialize in your AppDelegate or @main App struct',
+            };
+        case 'android-kotlin':
+            return {
+                file: '',
+                code: `// build.gradle.kts: implementation("com.github.Preatan:gurulu.io:android-sdk-0.1.0")
+// repositories: maven { url = uri("https://jitpack.io") }
+// Application.onCreate():
+import io.gurulu.sdk.GuruluSdk
+import io.gurulu.sdk.GuruluConfig
+
+GuruluSdk.initialize(GuruluConfig(
+    siteId = "${siteId}",
+    token = "${token}",
+    endpoint = "https://ingest.gurulu.io/api/ingest/v1/collect"
+))`,
+                instruction: 'Add JitPack repository and dependency, then initialize in your Application.onCreate()',
+            };
+        case 'flutter':
+            return {
+                file: '',
+                code: `// pubspec.yaml: gurulu_flutter: ^0.1.0
+import 'package:gurulu_flutter/gurulu_flutter.dart';
+
+await GuruluFlutter.initialize(config: {
+  'siteId': '${siteId}',
+  'token': '${token}',
+  'endpoint': 'https://ingest.gurulu.io/api/ingest/v1/collect',
+});`,
+                instruction: 'Add gurulu_flutter to pubspec.yaml and initialize in your main() function',
+            };
+        case 'html':
+            return {
+                file: '',
+                code: `<script src="https://cdn.gurulu.io/t.js" data-site-id="${siteId}" data-token="${token}" async></script>`,
+                instruction: 'Add this script tag before </head> in your HTML',
+            };
+        default:
+            return {
+                file: 'src/gurulu.ts',
+                code: `// Gurulu.io Analytics
+const script = document.createElement('script');
+script.src = 'https://cdn.gurulu.io/t.js';
+script.async = true;
+script.dataset.siteId = '${siteId}';
+script.dataset.token = '${token}';
+document.head.appendChild(script);`,
+                instruction: 'Import this file in your app entry point',
+            };
+    }
+}
+function getFrameworkDisplayName(fw) {
+    const names = {
+        'nextjs-app': 'Next.js (App Router)',
+        'nextjs-pages': 'Next.js (Pages Router)',
+        'react-vite': 'React (Vite)',
+        'react-cra': 'React (CRA)',
+        'vue3': 'Vue 3',
+        'nuxt3': 'Nuxt 3',
+        'svelte': 'Svelte',
+        'sveltekit': 'SvelteKit',
+        'astro': 'Astro',
+        'express': 'Express',
+        'nestjs': 'NestJS',
+        'html': 'HTML',
+        'react-native': 'React Native',
+        'ios-swift': 'iOS (Swift)',
+        'android-kotlin': 'Android (Kotlin)',
+        'flutter': 'Flutter',
+        'unknown': 'Unknown',
+    };
+    return names[fw];
+}

package/dist/index.d.ts

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