@nitrostack/cli 1.0.12 → 1.0.14

package/dist/commands/upgrade.js

@@ -2,22 +2,61 @@ import chalk from 'chalk';
 import { execSync } from 'child_process';
 import path from 'path';
 import fs from 'fs-extra';
+import https from 'https';
 import { createHeader, createBox, createSuccessBox, createErrorBox, NitroSpinner, log, spacer, nextSteps, NITRO_BANNER_FULL, showFooter } from '../ui/branding.js';
 import { trackEvent, shutdownAnalytics } from '../analytics/posthog.js';
+import { cloneSkillsRepo } from '../skills/clone.js';
+import { discoverSkills } from '../skills/discover.js';
+import { installSkills } from '../skills/installer.js';
+import { AGENTS } from '../skills/detect-agents.js';
 /**
- * Get the latest version of a package from npm registry
+ * Fetch a package's latest published version from NPM using standard https module.
  */
-function getLatestVersion(packageName = '@nitrostack/core') {
-    try {
-        const result = execSync(`npm view ${packageName} version`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        return result;
-    }
-    catch {
-        throw new Error(`Failed to fetch latest version for ${packageName} from npm`);
-    }
+export function fetchLatestNpmVersion(packageName) {
+    return new Promise((resolve, reject) => {
+        const url = `https://registry.npmjs.org/${packageName}/latest`;
+        const req = https.get(url, {
+            headers: {
+                'Accept': 'application/json',
+                'User-Agent': 'nitrostack-cli-upgrade'
+            },
+            timeout: 5000
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Registry responded with HTTP ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            // Handle stream errors
+            res.on('error', (err) => {
+                reject(new Error(`Response stream error: ${err.message}`));
+            });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed.version) {
+                        resolve(parsed.version);
+                    }
+                    else {
+                        reject(new Error('Invalid response structure from NPM registry'));
+                    }
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse response: ${e.message}`));
+                }
+            });
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Request timed out'));
+        });
+    });
 }
 /**
  * Get the current installed version of @nitrostack/core from package.json
@@ -32,15 +71,19 @@ function getCoreVersion(packageJsonPath) {
         null;
 }
 /**
- * Parse version string to extract the actual version number
+ * Parse version string to extract the actual numeric version.
+ *
+ * Strips any leading range operator (^ ~ >= <= > <) and drops the pre-release
+ * suffix (e.g. `-beta.1`) so the dot-separated segments always parse to numbers
+ * instead of producing `NaN` in `compareVersions`.
  */
 function parseVersion(versionString) {
-    return versionString.replace(/^[\^~>=<]+/, '');
+    return versionString.replace(/^[\^~>=<]+/, '').split('-')[0];
 }
 /**
  * Compare two version strings
  */
-function compareVersions(v1, v2) {
+export function compareVersions(v1, v2) {
     const parts1 = parseVersion(v1).split('.').map(Number);
     const parts2 = parseVersion(v2).split('.').map(Number);
     for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
@@ -54,37 +97,58 @@ function compareVersions(v1, v2) {
     return 0;
 }
 /**
- * Update all @nitrostack/* versions in package.json
+ * Determine if a dependency refers to a local file or workspace link.
  */
-function updatePackageJson(packageJsonPath, newVersion, dryRun) {
+export function isLocalDependency(version) {
+    return version.startsWith('file:') ||
+        version.startsWith('link:') ||
+        version.startsWith('workspace:') ||
+        version.startsWith('.') ||
+        version.startsWith('/');
+}
+/**
+ * Update all @nitrostack/* versions in package.json using dynamic npm registry fetch
+ */
+async function updatePackageJson(packageJsonPath, dryRun) {
     if (!fs.existsSync(packageJsonPath)) {
         return [];
     }
     const packageJson = fs.readJSONSync(packageJsonPath);
     const results = [];
     let hasChanges = false;
-    const updateDeps = (deps) => {
+    const updateDeps = async (deps) => {
         if (!deps)
             return;
-        for (const pkg of Object.keys(deps)) {
+        const promises = Object.keys(deps).map(async (pkg) => {
             if (pkg.startsWith('@nitrostack/')) {
                 const currentVersion = deps[pkg];
-                if (compareVersions(currentVersion, newVersion) < 0) {
-                    results.push({
-                        location: path.basename(path.dirname(packageJsonPath)),
-                        packageName: pkg,
-                        previousVersion: currentVersion,
-                        newVersion: `^${newVersion}`,
-                        upgraded: true,
-                    });
-                    deps[pkg] = `^${newVersion}`;
-                    hasChanges = true;
+                // Skip local dependencies entirely
+                if (isLocalDependency(currentVersion)) {
+                    return;
+                }
+                try {
+                    const latestVersion = await fetchLatestNpmVersion(pkg);
+                    if (compareVersions(currentVersion, latestVersion) < 0) {
+                        results.push({
+                            location: path.basename(path.dirname(packageJsonPath)),
+                            packageName: pkg,
+                            previousVersion: currentVersion,
+                            newVersion: `^${latestVersion}`,
+                            upgraded: true,
+                        });
+                        deps[pkg] = `^${latestVersion}`;
+                        hasChanges = true;
+                    }
+                }
+                catch (error) {
+                    console.warn(`\n⚠️  Skipped upgrade check for ${pkg}: ${error.message}`);
                 }
             }
-        }
+        });
+        await Promise.all(promises);
     };
-    updateDeps(packageJson.dependencies);
-    updateDeps(packageJson.devDependencies);
+    await updateDeps(packageJson.dependencies);
+    await updateDeps(packageJson.devDependencies);
     if (hasChanges && !dryRun) {
         fs.writeJSONSync(packageJsonPath, packageJson, { spaces: 2 });
     }
@@ -123,51 +187,22 @@ export async function upgradeCommand(options) {
         console.log(createErrorBox('Not a NitroStack Project', '@nitrostack/core is not a dependency'));
         process.exit(1);
     }
-    // Fetch latest version
-    const spinner = new NitroSpinner('Checking for updates...').start();
-    let latestVersion;
-    try {
-        latestVersion = getLatestVersion('@nitrostack/core');
-        spinner.succeed(`Latest version: ${chalk.cyan(latestVersion)}`);
-    }
-    catch (error) {
-        spinner.fail('Failed to fetch latest version');
-        process.exit(1);
-    }
-    // Check if already on latest
-    const currentParsedVersion = parseVersion(coreVersion);
-    if (compareVersions(currentParsedVersion, latestVersion) >= 0) {
-        spacer();
-        console.log(createSuccessBox('Already Up to Date', [
-            `Current version: ${currentParsedVersion}`,
-            `Latest version:  ${latestVersion}`,
-        ]));
-        trackEvent('cli_upgrade_completed', {
-            packages_upgraded: 0,
-            from_version: currentParsedVersion,
-            to_version: latestVersion,
-            dry_run: !!options.dryRun,
-            already_current: true,
-        });
-        await shutdownAnalytics();
-        return;
-    }
-    const allResults = [];
     const dryRun = options.dryRun ?? false;
     if (dryRun) {
         spacer();
         log('Dry run mode - no changes will be made', 'warning');
     }
     spacer();
-    log('Upgrading dependencies...', 'info');
+    log('Checking for package updates...', 'info');
     spacer();
+    const allResults = [];
     // Upgrade root
-    const rootSpinner = new NitroSpinner('Updating root package.json...').start();
+    const rootSpinner = new NitroSpinner('Checking root package.json...').start();
     try {
-        const results = updatePackageJson(rootPackageJsonPath, latestVersion, dryRun);
+        const results = await updatePackageJson(rootPackageJsonPath, dryRun);
         if (results.length > 0) {
             allResults.push(...results);
-            rootSpinner.succeed(`Root: Updated ${results.length} @nitrostack packages`);
+            rootSpinner.succeed(`Root: Found ${results.length} package update(s)`);
             if (!dryRun) {
                 const installSpinner = new NitroSpinner('Installing dependencies...').start();
                 runNpmInstall(projectRoot);
@@ -175,7 +210,7 @@ export async function upgradeCommand(options) {
             }
         }
         else {
-            rootSpinner.info('Root: All @nitrostack packages are up to date');
+            rootSpinner.info('Root: All @nitrostack packages are up to date (or local references)');
         }
     }
     catch (error) {
@@ -184,12 +219,12 @@ export async function upgradeCommand(options) {
     }
     // Upgrade widgets if they exist
     if (fs.existsSync(widgetsPackageJsonPath)) {
-        const widgetsSpinner = new NitroSpinner('Updating widgets package.json...').start();
+        const widgetsSpinner = new NitroSpinner('Checking widgets package.json...').start();
         try {
-            const results = updatePackageJson(widgetsPackageJsonPath, latestVersion, dryRun);
+            const results = await updatePackageJson(widgetsPackageJsonPath, dryRun);
             if (results.length > 0) {
                 allResults.push(...results);
-                widgetsSpinner.succeed(`Widgets: Updated ${results.length} @nitrostack packages`);
+                widgetsSpinner.succeed(`Widgets: Found ${results.length} package update(s)`);
                 if (!dryRun) {
                     const installSpinner = new NitroSpinner('Installing widget dependencies...').start();
                     runNpmInstall(widgetsPath);
@@ -197,54 +232,123 @@ export async function upgradeCommand(options) {
                 }
             }
             else {
-                widgetsSpinner.info('Widgets: All @nitrostack packages are up to date');
+                widgetsSpinner.info('Widgets: All @nitrostack packages are up to date (or local references)');
             }
         }
         catch (error) {
             widgetsSpinner.fail('Failed to upgrade widgets');
+            console.error(error);
         }
     }
-    // Summary
-    spacer();
-    if (allResults.length === 0) {
-        log('No packages were upgraded', 'warning');
-    }
-    else {
-        // Unique packages upgraded
-        const uniquePackages = Array.from(new Set(allResults.map(r => r.packageName)));
-        const summaryItems = uniquePackages.map(pkg => {
-            const result = allResults.find(r => r.packageName === pkg);
-            return `${pkg}: ${parseVersion(result.previousVersion)} → ${parseVersion(result.newVersion)}`;
-        });
-        if (dryRun) {
-            spacer();
-            console.log(createBox([
-                chalk.yellow.bold('Dry run complete'),
-                '',
-                chalk.dim('No changes were made to your project.'),
-                chalk.dim('Run without --dry-run to apply the upgrade.'),
-            ], 'warning'));
+    // Upgrade skills
+    const rootPackageJson = fs.readJSONSync(rootPackageJsonPath);
+    const localSkillsVersion = rootPackageJson.nitrostack?.skillsVersion || '0.0.0';
+    let tempSkillsDir = null;
+    const skillsSpinner = new NitroSpinner('Checking agent skills...').start();
+    try {
+        tempSkillsDir = await cloneSkillsRepo();
+        const skillsPkgJsonPath = path.join(tempSkillsDir, 'package.json');
+        let remoteSkillsVersion = '1.0.0';
+        if (fs.existsSync(skillsPkgJsonPath)) {
+            const skillsPkgJson = fs.readJSONSync(skillsPkgJsonPath);
+            remoteSkillsVersion = skillsPkgJson.version || '1.0.0';
+        }
+        if (compareVersions(localSkillsVersion, remoteSkillsVersion) < 0) {
+            if (dryRun) {
+                allResults.push({
+                    location: 'skills',
+                    packageName: '@nitrostack/skills',
+                    previousVersion: localSkillsVersion,
+                    newVersion: remoteSkillsVersion,
+                    upgraded: false,
+                });
+                skillsSpinner.info(`Skills: Updates available (${localSkillsVersion} → ${remoteSkillsVersion})`);
+            }
+            else {
+                const skills = await discoverSkills(tempSkillsDir);
+                await installSkills(AGENTS, skills, true, 'project', projectRoot);
+                // Write new version to package.json
+                const updatedPackageJson = fs.readJSONSync(rootPackageJsonPath);
+                if (!updatedPackageJson.nitrostack) {
+                    updatedPackageJson.nitrostack = {};
+                }
+                updatedPackageJson.nitrostack.skillsVersion = remoteSkillsVersion;
+                fs.writeJSONSync(rootPackageJsonPath, updatedPackageJson, { spaces: 2 });
+                allResults.push({
+                    location: 'skills',
+                    packageName: '@nitrostack/skills',
+                    previousVersion: localSkillsVersion,
+                    newVersion: remoteSkillsVersion,
+                    upgraded: true,
+                });
+                skillsSpinner.succeed(`Skills: Upgraded from ${localSkillsVersion} to ${remoteSkillsVersion}`);
+            }
         }
         else {
-            console.log(createSuccessBox('Upgrade Complete', [
-                ...summaryItems,
-                '',
-                chalk.dim(`Total updates across all packages: ${allResults.length}`)
-            ]));
-            nextSteps([
-                'Review the changes in package.json',
-                'Restart your development server',
-                'Check docs.nitrostack.ai for migration guides',
-            ]);
+            skillsSpinner.info('Skills: All agent skills are up to date');
+        }
+    }
+    catch (error) {
+        skillsSpinner.fail('Failed to upgrade agent skills');
+        console.error(error);
+    }
+    finally {
+        if (tempSkillsDir) {
+            try {
+                fs.removeSync(tempSkillsDir);
+            }
+            catch {
+                // best effort
+            }
         }
-        showFooter();
+    }
+    // Summary
+    spacer();
+    if (allResults.length === 0) {
+        console.log(createSuccessBox('Already Up to Date', [
+            'All @nitrostack packages are already running their latest versions.',
+        ]));
         trackEvent('cli_upgrade_completed', {
-            packages_upgraded: allResults.length,
-            from_version: currentParsedVersion,
-            to_version: latestVersion,
+            packages_upgraded: 0,
             dry_run: dryRun,
-            already_current: false,
+            already_current: true,
         });
         await shutdownAnalytics();
+        return;
     }
+    // Unique packages upgraded
+    const uniquePackages = Array.from(new Set(allResults.map(r => r.packageName)));
+    const summaryItems = uniquePackages.map(pkg => {
+        const result = allResults.find(r => r.packageName === pkg);
+        return `${pkg}: ${parseVersion(result.previousVersion)} → ${parseVersion(result.newVersion)}`;
+    });
+    if (dryRun) {
+        spacer();
+        console.log(createBox([
+            chalk.yellow.bold('Dry Run - Proposed Upgrades:'),
+            ...summaryItems.map(item => `  • ${item}`),
+            '',
+            chalk.dim('No changes were made to your project.'),
+            chalk.dim('Run without --dry-run to apply the upgrade.'),
+        ], 'warning'));
+    }
+    else {
+        console.log(createSuccessBox('Upgrade Complete', [
+            ...summaryItems,
+            '',
+            chalk.dim(`Total updates across all packages: ${allResults.length}`)
+        ]));
+        nextSteps([
+            'Review the changes in package.json',
+            'Restart your development server',
+            'Check docs.nitrostack.ai for migration guides',
+        ]);
+    }
+    showFooter();
+    trackEvent('cli_upgrade_completed', {
+        packages_upgraded: allResults.length,
+        dry_run: dryRun,
+        already_current: false,
+    });
+    await shutdownAnalytics();
 }

package/dist/index.d.ts

@@ -8,4 +8,5 @@ export { startCommand } from './commands/start.js';
 export { generate } from './commands/generate.js';
 export { upgradeCommand } from './commands/upgrade.js';
 export { installCommand } from './commands/install.js';
+export { cursorCommand } from './commands/cursor.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,aAAa,YAgE5B;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,aAAa,YA6E5B;AAGD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -8,6 +8,7 @@ import { startCommand } from './commands/start.js';
 import { generate } from './commands/generate.js';
 import { upgradeCommand } from './commands/upgrade.js';
 import { installCommand } from './commands/install.js';
+import { cursorCommand } from './commands/cursor.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 export function createProgram() {
@@ -24,6 +25,7 @@ export function createProgram() {
         .option('--description <description>', 'Description of the project')
         .option('--author <author>', 'Author of the project')
         .option('--skip-install', 'Skip installing dependencies')
+        .option('--force', 'Overwrite existing skill files when adding agent skills')
         .action(initCommand);
     program
         .command('dev')
@@ -64,6 +66,17 @@ export function createProgram() {
         .option('--skip-widgets', 'Skip installing widget dependencies')
         .option('--production', 'Install production dependencies only')
         .action(installCommand);
+    program
+        .command('cursor')
+        .alias('c')
+        .description('Integrate this MCP server with Cursor')
+        .option('-g, --global', 'Install globally to ~/.cursor/mcp.json')
+        .option('-l, --local', 'Install locally to .cursor/mcp.json')
+        .option('-t, --type <type>', 'Connection type: "command", "legacy-sse", or "streamable-http" (alias: "sse" → legacy-sse)')
+        .option('-u, --url <url>', 'HTTP connection URL (for legacy-sse or streamable-http)')
+        .option('-p, --port <port>', 'Port for default HTTP URL (for legacy-sse or streamable-http)')
+        .option('--force', 'Force overwrite of existing configuration')
+        .action(cursorCommand);
     return program;
 }
 // Re-export commands for programmatic use
@@ -74,6 +87,7 @@ export { startCommand } from './commands/start.js';
 export { generate } from './commands/generate.js';
 export { upgradeCommand } from './commands/upgrade.js';
 export { installCommand } from './commands/install.js';
+export { cursorCommand } from './commands/cursor.js';
 // Run the CLI when this module is the entry point
 import { fileURLToPath } from 'url';
 import { realpathSync } from 'fs';

package/dist/skills/clone.d.ts

@@ -0,0 +1,28 @@
+export declare const SKILLS_REPO_URL = "https://github.com/nitrocloudofficial/skills.git";
+/**
+ * Thrown when the skills repository cannot be cloned (git missing, network
+ * error, repository not found, etc.).  The caller should catch this and
+ * display a user-friendly warning rather than crashing the entire init flow.
+ */
+export declare class SkillsCloneError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Clones the NitroStack skills repository into a unique temporary directory
+ * and returns the absolute path to that directory.
+ *
+ * The caller is responsible for cleaning up the directory when done:
+ * ```ts
+ * const tempDir = await cloneSkillsRepo();
+ * try {
+ *   // use tempDir …
+ * } finally {
+ *   await fs.remove(tempDir);
+ * }
+ * ```
+ *
+ * @throws {SkillsCloneError} when git is unavailable or the clone fails.
+ */
+export declare function cloneSkillsRepo(): Promise<string>;
+//# sourceMappingURL=clone.d.ts.map

package/dist/skills/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/skills/clone.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe,qDAAqD,CAAC;AAElF;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;aACI,KAAK,CAAC,EAAE,OAAO;gBAAhD,OAAO,EAAE,MAAM,EAAkB,KAAK,CAAC,EAAE,OAAO,YAAA;CAI7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,CAiCvD"}

package/dist/skills/clone.js

@@ -0,0 +1,60 @@
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+export const SKILLS_REPO_URL = 'https://github.com/nitrocloudofficial/skills.git';
+/**
+ * Thrown when the skills repository cannot be cloned (git missing, network
+ * error, repository not found, etc.).  The caller should catch this and
+ * display a user-friendly warning rather than crashing the entire init flow.
+ */
+export class SkillsCloneError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'SkillsCloneError';
+    }
+}
+/**
+ * Clones the NitroStack skills repository into a unique temporary directory
+ * and returns the absolute path to that directory.
+ *
+ * The caller is responsible for cleaning up the directory when done:
+ * ```ts
+ * const tempDir = await cloneSkillsRepo();
+ * try {
+ *   // use tempDir …
+ * } finally {
+ *   await fs.remove(tempDir);
+ * }
+ * ```
+ *
+ * @throws {SkillsCloneError} when git is unavailable or the clone fails.
+ */
+export async function cloneSkillsRepo() {
+    const uniqueId = crypto.randomBytes(6).toString('hex');
+    const tempDir = path.join(os.tmpdir(), `nitrostack-skills-${uniqueId}`);
+    try {
+        execSync(`git clone --depth 1 "${SKILLS_REPO_URL}" "${tempDir}"`, {
+            stdio: 'pipe',
+            timeout: 60_000,
+        });
+    }
+    catch (err) {
+        // Clean up any partial clone before throwing
+        try {
+            await fs.remove(tempDir);
+        }
+        catch {
+            // best-effort cleanup
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('git: command not found') || message.includes("'git' is not recognized")) {
+            throw new SkillsCloneError('Git is not installed or not in PATH. Install Git from https://git-scm.com and try again.', err);
+        }
+        throw new SkillsCloneError(`Failed to clone skills repository: ${message.split('\n')[0]}`, err);
+    }
+    return tempDir;
+}

package/dist/skills/detect-agents.d.ts

@@ -0,0 +1,8 @@
+import type { AgentDescriptor } from './types.js';
+export declare const AGENTS: AgentDescriptor[];
+/**
+ * Runs all agent detectors in parallel and returns only the agents that are
+ * detected on the current machine.
+ */
+export declare function detectAgents(): Promise<AgentDescriptor[]>;
+//# sourceMappingURL=detect-agents.d.ts.map

package/dist/skills/detect-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-agents.d.ts","sourceRoot":"","sources":["../../src/skills/detect-agents.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAkElD,eAAO,MAAM,MAAM,EAAE,eAAe,EAwDnC,CAAC;AAEF;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAa/D"}