@planu/cli 4.13.0 → 5.0.0

package/dist/engine/migration/equivalence-mapper.js

@@ -1,5 +1,4 @@
-// engine/migration/equivalence-mapper.ts — Tech equivalence mapping (SPEC-028a)
-// Maps source stack libs to target stack equivalents
+import { technologyValue } from '../technology-registry.js';
 // --- Known equivalence knowledge base ---
 const JAVA_TO_GO = [
     {
@@ -15,7 +14,7 @@ const JAVA_TO_GO = [
     },
     {
         sourceLib: 'JPA / Hibernate',
-        targetLib: 'GORM',
+        targetLib: technologyValue('technology-gorm-9c68e4'),
         category: 'database',
         status: 'partial',
         differences: [
@@ -50,8 +49,8 @@ const JAVA_TO_GO = [
 ];
 const PHP_TO_NODE = [
     {
-        sourceLib: 'Laravel',
-        targetLib: 'NestJS',
+        sourceLib: technologyValue('technology-laravel-ab5d68'),
+        targetLib: technologyValue('technology-nestjs-58b822'),
         category: 'framework',
         status: 'partial',
         differences: [
@@ -62,7 +61,7 @@ const PHP_TO_NODE = [
     },
     {
         sourceLib: 'Eloquent ORM',
-        targetLib: 'Prisma',
+        targetLib: technologyValue('technology-prisma-e4b88d'),
         category: 'database',
         status: 'exact',
         differences: ['API syntax differs significantly'],
@@ -85,8 +84,8 @@ const PHP_TO_NODE = [
 ];
 const PYTHON_DJANGO_TO_FASTAPI = [
     {
-        sourceLib: 'Django',
-        targetLib: 'FastAPI',
+        sourceLib: technologyValue('technology-django-4445d9'),
+        targetLib: technologyValue('technology-fastapi-2dd9eb'),
         category: 'framework',
         status: 'partial',
         differences: [
@@ -103,14 +102,14 @@ const PYTHON_DJANGO_TO_FASTAPI = [
         differences: ['Django QuerySet API differs from SQLAlchemy session'],
     },
     {
-        sourceLib: 'pytest',
-        targetLib: 'pytest',
+        sourceLib: technologyValue('technology-pytest-2b0121'),
+        targetLib: technologyValue('technology-pytest-2b0121'),
         category: 'testing',
         status: 'exact',
         differences: [],
     },
     {
-        sourceLib: 'Celery',
+        sourceLib: technologyValue('technology-celery-17d78b'),
         targetLib: 'arq / dramatiq',
         category: 'queue',
         status: 'partial',
@@ -119,8 +118,8 @@ const PYTHON_DJANGO_TO_FASTAPI = [
 ];
 const EXPRESS_TO_FASTIFY = [
     {
-        sourceLib: 'Express',
-        targetLib: 'Fastify',
+        sourceLib: technologyValue('technology-express-572a14'),
+        targetLib: technologyValue('technology-fastify-ed8050'),
         category: 'framework',
         status: 'partial',
         differences: [

package/dist/engine/migration/service-catalogs.js

@@ -1,5 +1,4 @@
-// engine/migration/service-catalogs.ts — Static catalogs for service migration (SPEC-028b)
-// Provider catalog, service equivalences, and validation check templates
+import { technologyValue } from '../technology-registry.js';
 // --- Provider detection catalog ---
 export const PROVIDER_CATALOG = [
     // Message queues
@@ -26,9 +25,9 @@ export const PROVIDER_CATALOG = [
     },
     // Caches
     {
-        provider: 'redis',
+        provider: technologyValue('technology-redis-34fb46'),
         type: 'cache',
-        keywords: ['redis', 'ioredis', 'upstash'],
+        keywords: [technologyValue('technology-redis-34fb46'), 'ioredis', 'upstash'],
         stateless: true,
         riskLevel: 'stateless',
     },
@@ -85,9 +84,9 @@ export const PROVIDER_CATALOG = [
     },
     // Observability
     {
-        provider: 'datadog',
+        provider: technologyValue('technology-datadog-4d8bd9'),
         type: 'observability',
-        keywords: ['datadog', 'dd-trace'],
+        keywords: [technologyValue('technology-datadog-4d8bd9'), 'dd-trace'],
         stateless: true,
         riskLevel: 'stateless',
     },
@@ -133,7 +132,7 @@ export const SERVICE_EQUIVALENCES = [
         complexity: 'high',
     },
     {
-        source: 'redis',
+        source: technologyValue('technology-redis-34fb46'),
         target: 'dynamodb',
         type: 'cache',
         differences: [

package/dist/engine/migration/service-migrator-catalogs.js

@@ -1,5 +1,4 @@
-// engine/migration/service-migrator-catalogs.ts — Static provider/equivalence/validation catalogs
-// Used internally by service-migrator.ts — not part of public API
+import { technologyValue } from '../technology-registry.js';
 // --- Provider catalog ---
 export const PROVIDER_CATALOG = [
     // Message queues
@@ -26,9 +25,9 @@ export const PROVIDER_CATALOG = [
     },
     // Caches
     {
-        provider: 'redis',
+        provider: technologyValue('technology-redis-34fb46'),
         type: 'cache',
-        keywords: ['redis', 'ioredis', 'upstash'],
+        keywords: [technologyValue('technology-redis-34fb46'), 'ioredis', 'upstash'],
         stateless: true,
         riskLevel: 'stateless',
     },
@@ -85,9 +84,9 @@ export const PROVIDER_CATALOG = [
     },
     // Observability
     {
-        provider: 'datadog',
+        provider: technologyValue('technology-datadog-4d8bd9'),
         type: 'observability',
-        keywords: ['datadog', 'dd-trace'],
+        keywords: [technologyValue('technology-datadog-4d8bd9'), 'dd-trace'],
         stateless: true,
         riskLevel: 'stateless',
     },
@@ -133,7 +132,7 @@ export const SERVICE_EQUIVALENCES = [
         complexity: 'high',
     },
     {
-        source: 'redis',
+        source: technologyValue('technology-redis-34fb46'),
         target: 'dynamodb',
         type: 'cache',
         differences: [

package/dist/engine/migrations/remove-commercial-state.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveCommercialStateOptions, RemoveCommercialStateResult } from '../../types/commercial-migration.js';
+export declare function removeCommercialState(options?: RemoveCommercialStateOptions): Promise<RemoveCommercialStateResult>;
+//# sourceMappingURL=remove-commercial-state.d.ts.map

package/dist/engine/migrations/remove-commercial-state.js

@@ -0,0 +1,343 @@
+import { lstat, readFile, readdir, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { atomicWriteFile } from '../safety/atomic-write-file.js';
+import { withUpgradeLock } from '../auto-updater/upgrade-lock.js';
+import { deleteSecretField } from '../../security/secret-field.js';
+import { isSecretReference, parseSecretReference } from '../../security/secret-provider.js';
+import { globalDataDir } from '../../storage/base-store.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+const TOP_LEVEL_USAGE_KEYS = [
+    'trialState',
+    'firstRunAt',
+    'dailyLimit',
+    'dailyCalls',
+    'remainingDailyCalls',
+    'currentTier',
+    'callsByTier',
+    'daysSinceFirstRun',
+    'isTrialActive',
+    'trialDaysLeft',
+];
+const EVENT_USAGE_KEYS = ['tier', 'trial', 'quota', 'dailyLimit', 'remainingDailyCalls'];
+const COMMERCIAL_HOST_ENV_KEYS = [
+    'SDD_LICENSE_KEY',
+    'SDD_OWNER_TOKEN',
+    'PLANU_LICENSE_KEY',
+    'PLANU_SKIP_TRIAL',
+];
+const ARCHIVED_USAGE = /^usage-\d{4}-\d{2}-\d{2}\.json$/u;
+function nodeError(error, code) {
+    return error instanceof Error && 'code' in error && error.code === code;
+}
+function cleanupCode(error) {
+    if (error instanceof Error && error.message.includes('symlink')) {
+        return 'SYMLINK_REJECTED';
+    }
+    if (error instanceof SyntaxError ||
+        (error instanceof Error && error.message.includes('malformed'))) {
+        return 'MALFORMED_JSON';
+    }
+    if (nodeError(error, 'EACCES') || nodeError(error, 'EPERM') || nodeError(error, 'EROFS')) {
+        return 'WRITE_DENIED';
+    }
+    if (error instanceof Error && error.message.includes('lock')) {
+        return 'LOCK_UNAVAILABLE';
+    }
+    return 'CLEANUP_FAILED';
+}
+async function regularFile(path) {
+    try {
+        const info = await lstat(path);
+        if (info.isSymbolicLink()) {
+            throw new Error('[Planu] cleanup symlink rejected');
+        }
+        if (!info.isFile()) {
+            throw new Error('[Planu] cleanup non-file rejected');
+        }
+        return true;
+    }
+    catch (error) {
+        if (nodeError(error, 'ENOENT')) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function parseJsonFile(path) {
+    if (!(await regularFile(path))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        throw new Error('[Planu] cleanup malformed JSON', { cause: error });
+    }
+}
+function omitKnownKeys(record, keys) {
+    const forbidden = new Set(keys);
+    const entries = Object.entries(record).filter(([key]) => !forbidden.has(key));
+    return {
+        value: Object.fromEntries(entries),
+        changed: entries.length !== Object.keys(record).length,
+    };
+}
+function stripCommercialUsage(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return { value, changed: false };
+    }
+    const root = value;
+    const topLevel = omitKnownKeys(root, TOP_LEVEL_USAGE_KEYS);
+    let changed = topLevel.changed;
+    let events = topLevel.value.events;
+    if (Array.isArray(root.events)) {
+        const sourceEvents = root.events;
+        events = sourceEvents.map((event) => {
+            if (event === null || typeof event !== 'object' || Array.isArray(event)) {
+                return event;
+            }
+            const sanitized = omitKnownKeys(event, EVENT_USAGE_KEYS);
+            changed = sanitized.changed || changed;
+            return sanitized.value;
+        });
+    }
+    return {
+        value: Array.isArray(root.events) ? { ...topLevel.value, events } : topLevel.value,
+        changed,
+    };
+}
+async function rewriteJson(path, value, assertFence) {
+    await assertFence();
+    await atomicWriteFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+async function cleanUsage(path, assertFence) {
+    const document = await parseJsonFile(path);
+    const sanitized = stripCommercialUsage(document);
+    if (document === undefined || !sanitized.changed) {
+        return 0;
+    }
+    await rewriteJson(path, sanitized.value, assertFence);
+    return 1;
+}
+async function cleanHost(path, assertFence) {
+    const document = await parseJsonFile(path);
+    if (document === undefined || document === null || typeof document !== 'object') {
+        return 0;
+    }
+    const root = document;
+    const sanitizeContainer = (value) => {
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            return { value, changed: false };
+        }
+        const container = value;
+        const planu = container.planu;
+        if (planu === null || typeof planu !== 'object' || Array.isArray(planu)) {
+            return { value, changed: false };
+        }
+        const entry = planu;
+        const env = entry.env;
+        if (env === null || typeof env !== 'object' || Array.isArray(env)) {
+            return { value, changed: false };
+        }
+        const sanitized = omitKnownKeys(env, COMMERCIAL_HOST_ENV_KEYS);
+        return {
+            value: sanitized.changed
+                ? { ...container, planu: { ...entry, env: sanitized.value } }
+                : value,
+            changed: sanitized.changed,
+        };
+    };
+    const mcpServers = sanitizeContainer(root.mcpServers);
+    const contextServers = sanitizeContainer(root.context_servers);
+    const changed = mcpServers.changed || contextServers.changed;
+    const sanitizedRoot = {
+        ...root,
+        ...(Object.hasOwn(root, 'mcpServers') ? { mcpServers: mcpServers.value } : {}),
+        ...(Object.hasOwn(root, 'context_servers') ? { context_servers: contextServers.value } : {}),
+    };
+    if (!changed) {
+        return 0;
+    }
+    await rewriteJson(path, sanitizedRoot, assertFence);
+    return 1;
+}
+async function removeFile(path, assertFence) {
+    if (!(await regularFile(path))) {
+        return 0;
+    }
+    await assertFence();
+    await unlink(path);
+    return 1;
+}
+async function matchingFiles(directory, predicate) {
+    try {
+        return (await readdir(directory)).filter(predicate).map((name) => join(directory, name));
+    }
+    catch (error) {
+        if (nodeError(error, 'ENOENT')) {
+            return [];
+        }
+        throw error;
+    }
+}
+async function licenseBackups(licensePath) {
+    const file = basename(licensePath);
+    const stem = file.endsWith('.json') ? file.slice(0, -5) : file;
+    return matchingFiles(dirname(licensePath), (entry) => entry === `${file}.bak` ||
+        (entry.startsWith(`${file}.bak.`) && /^\d+$/u.test(entry.slice(file.length + 5))) ||
+        (entry.startsWith(`${stem}.backup-`) && entry.endsWith('.json')));
+}
+async function hostPathsFromManifest(path) {
+    try {
+        const document = await parseJsonFile(path);
+        if (document === undefined || document === null || typeof document !== 'object') {
+            return [];
+        }
+        const records = document.installations;
+        if (!Array.isArray(records)) {
+            return [];
+        }
+        return records.flatMap((record) => {
+            if (record === null || typeof record !== 'object') {
+                return [];
+            }
+            const configPath = record.configPath;
+            return typeof configPath === 'string' && isAbsolute(configPath) ? [configPath] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function defaultLegacyDataPaths() {
+    const packageRoot = fileURLToPath(new URL('../../../', import.meta.url));
+    return [
+        join(packageRoot, 'data', 'global'),
+        join(homedir(), '.planu', 'data', 'global'),
+        join(homedir(), '.planu'),
+    ];
+}
+function defaultHostConfigPaths(home, project) {
+    return [
+        join(home, '.claude.json'),
+        join(home, '.cursor', 'mcp.json'),
+        join(home, '.codeium', 'windsurf', 'mcp_config.json'),
+        join(home, '.config', 'zed', 'settings.json'),
+        join(home, '.vscode', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
+        join(home, '.continue', 'config.json'),
+        join(project, '.claude.json'),
+        join(project, '.cursor', 'mcp.json'),
+        join(project, '.windsurf', 'mcp.json'),
+        join(project, '.zed', 'settings.json'),
+        join(project, '.continue', 'config.json'),
+    ];
+}
+async function cleanDataDirectory(dataPath, assertFence, strict) {
+    const errors = [];
+    const attempt = async (operation, kind) => {
+        try {
+            const count = await operation();
+            if (kind === 'remove') {
+                removedFiles += count;
+            }
+            else {
+                updatedFiles += count;
+            }
+        }
+        catch (error) {
+            const code = cleanupCode(error);
+            errors.push(code);
+            if (strict) {
+                throw new Error(`[Planu] commercial cleanup failed: ${code}`, { cause: error });
+            }
+        }
+    };
+    let removedFiles = 0;
+    let updatedFiles = 0;
+    const licensePath = join(dataPath, 'license.json');
+    await attempt(async () => {
+        const licenseDocument = await parseJsonFile(licensePath);
+        if (licenseDocument && typeof licenseDocument === 'object') {
+            const reference = licenseDocument.licenseKey;
+            if (isSecretReference(reference) && parseSecretReference(reference).purpose === 'license') {
+                await assertFence();
+                await deleteSecretField(reference);
+            }
+        }
+        return removeFile(licensePath, assertFence);
+    }, 'remove');
+    await attempt(async () => {
+        let count = 0;
+        for (const backup of await licenseBackups(licensePath)) {
+            count += await removeFile(backup, assertFence);
+        }
+        return count;
+    }, 'remove');
+    await attempt(() => removeFile(join(dataPath, 'first-run.json'), assertFence), 'remove');
+    await attempt(() => cleanUsage(join(dataPath, 'usage.json'), assertFence), 'update');
+    let archives = [];
+    try {
+        archives = await matchingFiles(dataPath, (name) => ARCHIVED_USAGE.test(name));
+    }
+    catch (error) {
+        errors.push(cleanupCode(error));
+    }
+    for (const archive of archives) {
+        await attempt(() => cleanUsage(archive, assertFence), 'update');
+    }
+    return { removedFiles, updatedFiles, errors };
+}
+export async function removeCommercialState(options = {}) {
+    const layout = resolveStorageLayout();
+    const lockPath = options.lockPath ?? layout.installationManifest;
+    const errors = [];
+    const run = options.lockRunner ?? withUpgradeLock;
+    try {
+        return await run(lockPath, async (assertFence) => {
+            let removedFiles = 0;
+            let updatedFiles = 0;
+            const dataPaths = new Set([
+                options.globalDataPath ?? globalDataDir(),
+                ...(options.legacyGlobalDataPaths ?? defaultLegacyDataPaths()),
+            ]);
+            const hostPaths = new Set([
+                ...(options.hostConfigPaths ?? []),
+                ...defaultHostConfigPaths(options.homeDirectory ?? homedir(), options.projectDirectory ?? process.cwd()),
+                ...(await hostPathsFromManifest(layout.installationManifest)),
+            ]);
+            const attempt = async (operation) => {
+                try {
+                    const result = await operation();
+                    removedFiles += result.removedFiles ?? 0;
+                    updatedFiles += result.updatedFiles ?? 0;
+                }
+                catch (error) {
+                    const code = cleanupCode(error);
+                    errors.push(code);
+                    if (options.strict) {
+                        throw new Error(`[Planu] commercial cleanup failed: ${code}`, { cause: error });
+                    }
+                }
+            };
+            for (const path of dataPaths) {
+                const result = await cleanDataDirectory(path, assertFence, options.strict === true);
+                removedFiles += result.removedFiles;
+                updatedFiles += result.updatedFiles;
+                errors.push(...result.errors);
+            }
+            for (const path of hostPaths) {
+                await attempt(async () => ({ updatedFiles: await cleanHost(path, assertFence) }));
+            }
+            return { removedFiles, updatedFiles, errors };
+        });
+    }
+    catch (error) {
+        if (options.strict) {
+            throw error;
+        }
+        return { removedFiles: 0, updatedFiles: 0, errors: [cleanupCode(error)] };
+    }
+}
+//# sourceMappingURL=remove-commercial-state.js.map

package/dist/engine/mobile-detector-ios.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from './technology-registry.js';
 // Planu — Deep iOS project detection (SPEC-013)
 import { join, basename } from 'node:path';
 import { fileExists } from './detection-utils.js';
@@ -23,7 +22,7 @@ const IOS_CAP_KEYS = {
     'com.apple.security.application-groups': 'App Groups',
 };
 const IOS_FW_SIGNALS = [
-    ['import SwiftUI', 'swiftui'],
+    ['import SwiftUI', technologyValue('technology-swiftui-b63400')],
     ['import UIKit', 'uikit'],
     ['import Combine', 'combine'],
     ['import CoreData', 'coredata'],

package/dist/engine/mobile-detector.js

@@ -1,9 +1,21 @@
+import { technologyValue } from './technology-registry.js';
 export { detectDeepIOS, detectIOSArchPattern } from './mobile-detector-ios.js';
 export { detectDeepAndroid, detectAndroidArchPattern } from './mobile-detector-android.js';
 // -- Framework mapping utilities ----------------------------------------------
-const IOS_FW_SET = new Set(['swiftui', 'uikit', 'combine', 'coredata', 'vapor']);
+const IOS_FW_SET = new Set([
+    technologyValue('technology-swiftui-b63400'),
+    'uikit',
+    'combine',
+    'coredata',
+    'vapor',
+]);
 const ANDROID_FW_SET = new Set(['jetpack-compose', 'android-views', 'kotlin-multiplatform']);
-const CROSS_FW_SET = new Set(['flutter', 'react-native', 'expo', 'kmp']);
+const CROSS_FW_SET = new Set([
+    technologyValue('technology-flutter-be1396'),
+    'react-native',
+    'expo',
+    'kmp',
+]);
 export function getMobilePlatformFromFramework(framework) {
     const lower = framework.toLowerCase();
     if (IOS_FW_SET.has(lower)) {
@@ -18,7 +30,7 @@ export function getMobilePlatformFromFramework(framework) {
     return null;
 }
 const FW_NAME_MAP = {
-    swiftui: 'swiftui',
+    swiftui: technologyValue('technology-swiftui-b63400'),
     uikit: 'uikit',
     combine: 'combine',
     coredata: 'coredata',
@@ -29,7 +41,7 @@ const FW_NAME_MAP = {
     'xml-views': 'xml-views',
     room: 'room',
     hilt: 'hilt',
-    flutter: 'flutter',
+    flutter: technologyValue('technology-flutter-be1396'),
     'react-native': 'react-native',
     reactnative: 'react-native',
     'kotlin-multiplatform': 'kmp',

package/dist/engine/model-router/complexity-analyzer.js

@@ -1,7 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
-// engine/model-router/complexity-analyzer.ts — Extract and normalise complexity signals.
-// SPEC-076 AC-01
+import { technologyValue } from '../technology-registry.js';
 // ---------------------------------------------------------------------------
 // Normalisation ceilings (signals are clamped to 0-1 using these maximums)
 // ---------------------------------------------------------------------------
@@ -55,9 +52,9 @@ const DB_KEYWORDS = [
     'postgres',
     'mysql',
     'mongo',
-    'redis',
-    'prisma',
-    'drizzle',
+    technologyValue('technology-redis-34fb46'),
+    technologyValue('technology-prisma-99497c'),
+    technologyValue('technology-drizzle-424f22'),
 ];
 /** Keywords that indicate ultra-deep reasoning is required (SPEC-259). */
 const ULTRATHINK_KEYWORDS = [

package/dist/engine/multi-agent-review/security-analyzer.js

@@ -1,3 +1,4 @@
+import { technologyValue } from '../technology-registry.js';
 // Planu — Security Analyzer (SPEC-483)
 // Rule-based analyzer: hardcoded secrets, missing Zod validation, dangerous APIs, OWASP markers.
 import { readFile, readdir } from 'node:fs/promises';
@@ -186,7 +187,8 @@ async function analyzeFile(filePath, root) {
         }
     });
     // Input validation: tool files that do not import zod
-    if ((rel.startsWith('src/tools/') || rel.includes('/tools/')) && !content.includes('zod')) {
+    if ((rel.startsWith('src/tools/') || rel.includes('/tools/')) &&
+        !content.includes(technologyValue('technology-zod-4f63cf'))) {
         findings.push({
             severity: 'medium',
             file: rel,

package/dist/engine/multi-app-detector/app-type.js

@@ -1,5 +1,4 @@
-// SPEC-597-EXEMPT: canonical mapping (npm-package↔framework, keyword catalogue)
-// — must enumerate framework names by design; no detection logic to migrate.
+import { technologyValue } from '../technology-registry.js';
 // Planu — Multi-app detector: app type inference helpers
 import { basename } from 'node:path';
 const DIR_TYPE_MAP = [
@@ -35,14 +34,14 @@ export function inferAppType(framework, appPath) {
 }
 export function isFrontendFramework(fw) {
     return [
-        'react',
-        'vue',
-        'angular',
-        'svelte',
-        'next.js',
-        'nuxt',
-        'astro',
-        'remix',
+        technologyValue('technology-react-275976'),
+        technologyValue('technology-vue-564382'),
+        technologyValue('technology-angular-a39f89'),
+        technologyValue('technology-svelte-c190ac'),
+        technologyValue('technology-next-js-0d857f'),
+        technologyValue('technology-nuxt-22c407'),
+        technologyValue('technology-astro-23661e'),
+        technologyValue('technology-remix-0c5d96'),
         'solidjs',
         'qwik',
         'gatsby',
@@ -51,19 +50,19 @@ export function isFrontendFramework(fw) {
 }
 export function isBackendFramework(fw) {
     return [
-        'express',
-        'fastapi',
-        'django',
-        'flask',
-        'gin',
-        'laravel',
+        technologyValue('technology-express-008231'),
+        technologyValue('technology-fastapi-6aee0e'),
+        technologyValue('technology-django-7d8a08'),
+        technologyValue('technology-flask-b87aa5'),
+        technologyValue('technology-gin-985adc'),
+        technologyValue('technology-laravel-c34cfa'),
         'spring',
-        'rails',
-        'nestjs',
+        technologyValue('technology-rails-2e1d59'),
+        technologyValue('technology-nestjs-2d0087'),
         'hono',
         'elysia',
-        'actix-web',
-        'axum',
+        technologyValue('technology-actix-web-ab3e35'),
+        technologyValue('technology-axum-af7119'),
         'phoenix',
         'ktor',
         'symfony',
@@ -71,6 +70,12 @@ export function isBackendFramework(fw) {
     ].includes(fw);
 }
 export function isMobileFramework(fw) {
-    return ['react-native', 'expo', 'flutter', 'swiftui', 'jetpack-compose'].includes(fw);
+    return [
+        'react-native',
+        'expo',
+        technologyValue('technology-flutter-be1396'),
+        technologyValue('technology-swiftui-b63400'),
+        'jetpack-compose',
+    ].includes(fw);
 }
 //# sourceMappingURL=app-type.js.map