neutrinos-cli 2.0.0-beta.1 → 2.0.0-beta.10

package/.configs/auth.json

@@ -2,4 +2,4 @@
     "clientId": "your-client-id",
     "clientSecret": "your-client-secret",
     "redirectUri": "http://localhost:3000/callback"
-}
+}

package/.configs/preferences.json

@@ -2,4 +2,4 @@
     "theme": "light",
     "language": "en",
     "showNotifications": true
-}
+}

package/README.md

@@ -30,17 +30,19 @@ neutrinos start
 neutrinos <command> [options]
 ```
 
-| Command | Description |
-|---------|-------------|
-| `new <name>` | Create a new plugin workspace |
-| `generate\|g` | Generate a component, module, or attribute |
-| `build <type> [name]` | Build plugins (`plugins` or `docker`) |
-| `start` | Start the Vite dev server |
-| `serve` | Start the Express plugins server |
-| `publish [name]` | Bundle and publish a package |
-| `deprecate [name]` | Deprecate a published package |
-| `auth` | Login or check auth state |
-| `completion <shell>` | Output shell completion script (`bash` or `zsh`) |
+| Command               | Description                                                       |
+| --------------------- | ----------------------------------------------------------------- |
+| `new <name>`          | Create a new plugin workspace                                     |
+| `generate\|g`         | Generate a component, module, or attribute                        |
+| `build <type> [name]` | Build plugins (`plugins` or `docker`)                             |
+| `start`               | Start the Vite dev server                                         |
+| `serve`               | Start the Express plugins server                                  |
+| `publish [name]`      | Bundle and publish a package                                      |
+| `deprecate [name]`    | Deprecate a published package                                     |
+| `auth`                | Login or check auth state                                         |
+| `doctor`              | Check workspace health (`--fix` to auto-repair)                   |
+| `migrate`             | Migrate workspace to current CLI version (`--dry-run` to preview) |
+| `completion <shell>`  | Output shell completion script (`bash` or `zsh`)                  |
 
 ### `new <name>`
 
@@ -106,6 +108,45 @@ neutrinos deprecate [name] [-y] [--all]
 
 Marks a published package as deprecated. Prompts for confirmation unless `-y` is passed.
 
+### `doctor`
+
+```sh
+neutrinos doctor        # Run all health checks
+neutrinos doctor --fix  # Auto-fix what it can
+```
+
+Runs 14 workspace health checks and reports pass/warn/fail for each:
+
+- `node_modules` — Dependencies installed
+- `plugin.json` — Exists with required fields (`name`, `components.selectorPrefix`, `modules.idPrefix`)
+- `package.json` — Has `workspaces`, `type: "module"`, expected dependencies
+- `tsconfig.json` — Exists and is valid (verified via `tsc --showConfig`)
+- `plugins-server/` — Directory exists with `index.js`
+- `.storybook/` — Storybook config exists with `main.ts` and `preview.ts`
+- `vitest.config.ts` — Vitest config exists
+- Package `alpha` block — Each package has `alpha.component` or `alpha.module`
+- Component entry file — Component packages have a matching `<name>.ts` file
+- Node version — Meets `>=22` requirement
+- Auth state — Token file exists and is not expired
+- Lock file sync — Lock file is up to date with `package.json`
+- CLI update available — Checks npm registry for newer versions
+- Local CLI version — `devDependencies['neutrinos-cli']` matches running CLI
+
+`--fix` auto-repairs: missing `node_modules` (runs install), `plugin.json` defaults, `workspaces`/`type` in `package.json`, `plugins-server/` from template, `.storybook/` from template, `vitest.config.ts` from template, missing `alpha` blocks, stale lock files.
+
+### `migrate`
+
+```sh
+neutrinos migrate              # Migrate workspace to current CLI version
+neutrinos migrate --dry-run    # Preview changes without writing
+```
+
+Upgrades an existing workspace to match the current CLI version. Handles dependency updates, Storybook config scaffolding, file cleanup, and version pinning.
+
+The migration enforces git safety: it errors on dirty working trees, auto-inits git if absent, and commits changes on success. All steps are idempotent — safe to re-run after `git checkout .`.
+
+Version tracking uses `devDependencies['neutrinos-cli']` — no separate schema version field.
+
 ### `auth`
 
 ```sh

package/dist/{src/bin → bin}/cli.js

@@ -4,6 +4,29 @@ if (major < 22) {
     console.error('neutrinos requires Node.js 22+. Current: ' + process.version);
     process.exit(1);
 }
+// Delegate to workspace-local CLI binary if it exists.
+// Only `new` always runs from the global binary (no workspace context to delegate to).
+// Everything else delegates to local, matching Angular CLI's model.
+import { resolveLocalCli, readLocalCliVersion } from '../utils/local-cli.js';
+import { spawnCli } from '../utils/spawn-cli.js';
+import { compareVersions } from '../utils/migrations/version-compare.js';
+const GLOBAL_ONLY_COMMANDS = new Set(['new']);
+const command = process.argv[2] ?? '';
+if (!GLOBAL_ONLY_COMMANDS.has(command)) {
+    const localScript = resolveLocalCli(process.cwd(), realpathSync(fileURLToPath(import.meta.url)));
+    if (localScript) {
+        const globalVersion = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8')).version;
+        const localVersion = readLocalCliVersion(process.cwd());
+        if (localVersion && compareVersions(globalVersion, localVersion) > 0) {
+            process.stderr.write(`\nWarning: global neutrinos CLI v${globalVersion} is newer than local v${localVersion}.\n` +
+                `Run "neutrinos migrate" to update this workspace.\n\n`);
+        }
+        const code = await spawnCli(localScript, process.argv.slice(2), {
+            env: { NEUTRINOS_GLOBAL_VERSION: globalVersion },
+        });
+        process.exit(code);
+    }
+}
 import dotenv from 'dotenv';
 import { PACKAGE_ROOT } from '../utils/path-utils.js';
 dotenv.config({
@@ -26,15 +49,22 @@ import { generate } from '../commands/generate.js';
 import { createWorkspace } from '../commands/new-workspace.js';
 import { publish } from '../commands/publish.js';
 import { startPluginsServer } from '../commands/serve.js';
+import { runTests } from '../commands/test.js';
 import { completion } from '../commands/completion.js';
+import { doctor } from '../commands/doctor.js';
+import { migrate } from '../commands/migrate.js';
 import { getPackages } from '../utils/get-packages.js';
 import { validateWorkspace } from '../utils/check-valid-ws.js';
 import { done, failed, inprogress, log } from '../utils/logger.js';
-import { authConfigJson } from '../utils/path-utils.js';
-const { version: CLI_VERSION } = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf-8'));
+import { authConfigJson, getCliPackagePath } from '../utils/path-utils.js';
+const { version: CLI_VERSION } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
 export const createProgram = () => {
     const program = new Command();
-    program.version(CLI_VERSION, '-v, --version', 'Output the version number');
+    const globalVersion = env.NEUTRINOS_GLOBAL_VERSION;
+    const versionString = globalVersion
+        ? `${CLI_VERSION} (local)\n${globalVersion} (global)`
+        : `${CLI_VERSION} (global)`;
+    program.version(versionString, '-v, --version', 'Output the version number');
     program
         .command('new <name>')
         .description('Create a new project')
@@ -178,6 +208,14 @@ export const createProgram = () => {
         .action((options) => {
         servePlugin(cwd(), Number(options.port) || 6969);
     });
+    program
+        .command('test')
+        .alias('t')
+        .option('-w, --watch', 'Run in watch mode')
+        .description('run story-based tests')
+        .action((options) => {
+        runTests(cwd(), options);
+    });
     program
         .command('serve')
         .option('-p, --port <port>', 'Port number for serving the plugins', '3000')
@@ -192,6 +230,21 @@ export const createProgram = () => {
         .action((shell) => {
         completion(program, shell);
     });
+    program
+        .command('doctor')
+        .description('Check workspace health')
+        .option('--fix', 'Auto-fix issues where possible')
+        .action((options) => {
+        doctor(cwd(), options);
+    });
+    program
+        .command('migrate')
+        .description('Migrate workspace to a target CLI version')
+        .argument('[version]', 'Target version to migrate to')
+        .option('--dry-run', 'Preview changes without writing')
+        .action(async (version, options) => {
+        await migrate(cwd(), { ...options, version });
+    });
     program
         .command('__list-packages', { hidden: true })
         .description('List workspace package names (used by shell completion)')
@@ -209,7 +262,12 @@ export const createProgram = () => {
     });
     program.hook('preAction', async (_thisCmd, actionCmd) => {
         const cmd = actionCmd.name();
-        if (cmd === 'new' || cmd === 'login' || cmd === 'completion' || cmd === '__list-packages') {
+        if (cmd === 'new' ||
+            cmd === 'login' ||
+            cmd === 'completion' ||
+            cmd === '__list-packages' ||
+            cmd === 'doctor' ||
+            cmd === 'migrate') {
             return;
         }
         if (!validateWorkspace(cwd())) {

package/dist/{src/commands → commands}/attribute.js

@@ -65,9 +65,7 @@ const OPTIONS_QUERY = {
 const getAttributeMetadata = async (options) => {
     const attrMetadata = {
         ...options,
-        type: options.type && options.type in ATTR_TYPES
-            ? ATTR_TYPES[options.type]
-            : '',
+        type: options.type && options.type in ATTR_TYPES ? ATTR_TYPES[options.type] : '',
     };
     if (!attrMetadata.type) {
         const result = (await inquiry({
@@ -97,9 +95,11 @@ const getAttributeMetadata = async (options) => {
         const data = {
             uiType: UI_TYPES[uiType],
             label: attrMetadata.label ?? (await inquiry(LABEL_QUERY)).label,
-            placeholder: attrMetadata.placeholder ?? (await inquiry(PLACEHOLDER_QUERY)).placeholder,
+            placeholder: attrMetadata.placeholder ??
+                (await inquiry(PLACEHOLDER_QUERY)).placeholder,
             category: attrMetadata.category ?? (await inquiry(CATEGORY_QUERY)).category,
-            defaultValue: attrMetadata.defaultValue ?? (await inquiry(DEFAULT_VALUE_QUERY)).defaultValue,
+            defaultValue: attrMetadata.defaultValue ??
+                (await inquiry(DEFAULT_VALUE_QUERY)).defaultValue,
         };
         Object.assign(attrMetadata, data);
         const fieldMappings = FIELD_MAPPING_QUERY[attrMetadata.uiType];

package/dist/{src/commands → commands}/deprecate.js

@@ -12,7 +12,7 @@ const CONFIRM_INQUIRY = (packageName) => ({
     default: false,
 });
 export const deprecate = async (pkgName, wsPath, options) => {
-    const session = await getLoggedInUserSession();
+    const session = (await getLoggedInUserSession());
     const packages = await selectPackages(wsPath, options.all ?? false, pkgName);
     await Promise.all(packages.map(async (componentDirPath) => {
         try {

package/dist/commands/dev.js

@@ -0,0 +1,15 @@
+import { spawn } from 'node:child_process';
+export const servePlugin = async (wsPath, port) => {
+    const child = spawn('npx', ['storybook', 'dev', '-p', String(port)], {
+        cwd: wsPath,
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Storybook exited with code ${code}`));
+        });
+    });
+};

package/dist/commands/doctor.js

@@ -0,0 +1,69 @@
+import { bold, greenBright, red, yellowBright } from 'colorette';
+import { log as _log } from 'node:console';
+import { checks } from '../utils/doctor-checks/index.js';
+const SYMBOLS = {
+    pass: greenBright('✔'),
+    warn: yellowBright('⚠'),
+    fail: red('✖'),
+};
+const colorize = {
+    pass: greenBright,
+    warn: yellowBright,
+    fail: red,
+};
+function printResult(result) {
+    const sym = SYMBOLS[result.status];
+    const color = colorize[result.status];
+    _log(`  ${sym} ${color(`${result.name} — ${result.message}`)}`);
+}
+function printFixedResult(before, after) {
+    _log(`  ${red('✖')} → ${greenBright('✔')} ${greenBright(`${after.name} — Fixed: ${after.message}`)}`);
+}
+export function doctor(wsPath, opts) {
+    _log('\nWorkspace Health Check');
+    _log('──────────────────────\n');
+    let results = [];
+    for (const check of checks) {
+        const checkResults = check.run(wsPath);
+        results.push(...checkResults);
+    }
+    for (const r of results) {
+        printResult(r);
+    }
+    if (opts.fix) {
+        const fixableFailures = results.filter((r) => r.status === 'fail' && r.fixable);
+        if (fixableFailures.length > 0) {
+            _log('');
+            for (const check of checks) {
+                if (!check.fix)
+                    continue;
+                const checkResults = check.run(wsPath);
+                const hasFixableFailure = checkResults.some((r) => r.status === 'fail' && r.fixable);
+                if (!hasFixableFailure)
+                    continue;
+                check.fix(wsPath);
+                const afterResults = check.run(wsPath);
+                for (let i = 0; i < checkResults.length; i++) {
+                    const before = checkResults[i];
+                    const after = afterResults[i];
+                    if (before.status === 'fail' && after && after.status === 'pass') {
+                        printFixedResult(before, after);
+                        const idx = results.findIndex((r) => r.name === before.name && r.status === 'fail');
+                        if (idx !== -1) {
+                            results[idx] = after;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    const passed = results.filter((r) => r.status === 'pass').length;
+    const warned = results.filter((r) => r.status === 'warn').length;
+    const failed = results.filter((r) => r.status === 'fail').length;
+    _log('\n──────────────────────');
+    _log(bold(`Summary: ${greenBright(`${passed} passed`)}, ${yellowBright(`${warned} warnings`)}, ${red(`${failed} failed`)}`));
+    _log('');
+    if (failed > 0) {
+        process.exit(1);
+    }
+}

package/dist/commands/migrate.js

@@ -0,0 +1,120 @@
+// src/commands/migrate.ts
+import { exec as execCb } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { greenBright } from 'colorette';
+import { log as _log } from 'node:console';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { readLocalCliVersion } from '../utils/local-cli.js';
+import { compareVersions } from '../utils/migrations/version-compare.js';
+import { fetchRegistryVersions, versionExists } from '../utils/registry.js';
+import { spawnCli } from '../utils/spawn-cli.js';
+import { runMigration } from '../utils/migrate-runner.js';
+import { failed } from '../utils/logger.js';
+const exec = promisify(execCb);
+/**
+ * Migrate workspace to a target CLI version.
+ *
+ * - If NEUTRINOS_MIGRATE_SPAWNED is set, runs migrations directly (subprocess mode).
+ * - If a version argument is provided, temp-installs that version and spawns it.
+ * - If no version argument, prompts the user to select from available versions.
+ */
+export async function migrate(wsPath, opts) {
+    // Subprocess mode — spawned by a parent orchestrator, just run migrations
+    if (process.env.NEUTRINOS_MIGRATE_SPAWNED === 'true') {
+        runMigration(wsPath, { dryRun: opts.dryRun });
+        return;
+    }
+    // Resolve target version
+    const versions = await fetchRegistryVersions();
+    let target;
+    if (opts.version) {
+        if (!versionExists(opts.version, versions)) {
+            failed(`Version ${opts.version} not found on the npm registry.`);
+            process.exit(1);
+        }
+        target = opts.version;
+    }
+    else {
+        target = await promptForVersion(wsPath, versions);
+    }
+    // Validate: refuse downgrades
+    const wsVersion = readLocalCliVersion(wsPath);
+    if (wsVersion && compareVersions(target, wsVersion) < 0) {
+        failed(`Cannot downgrade from v${wsVersion} to v${target}`);
+        process.exit(1);
+    }
+    // Temp install and spawn
+    const tmpDir = mkdtempSync(join(tmpdir(), 'neutrinos-migrate-'));
+    let exitCode = 1;
+    try {
+        await installToTempDir(tmpDir, target);
+        const cliBin = join(tmpDir, 'node_modules', 'neutrinos-cli', 'dist', 'src', 'bin', 'cli.js');
+        if (!existsSync(cliBin)) {
+            failed(`Failed to locate CLI binary in fetched package. Expected: ${cliBin}`);
+            process.exit(1);
+        }
+        const args = ['migrate'];
+        if (opts.dryRun)
+            args.push('--dry-run');
+        exitCode = await spawnCli(cliBin, args, {
+            cwd: wsPath,
+            env: { NEUTRINOS_MIGRATE_SPAWNED: 'true' },
+        });
+    }
+    finally {
+        rmSync(tmpDir, { recursive: true, force: true });
+    }
+    process.exit(exitCode);
+}
+async function promptForVersion(wsPath, versions) {
+    const wsVersion = readLocalCliVersion(wsPath);
+    // Filter to versions newer than workspace
+    let available = wsVersion
+        ? versions.filter((v) => compareVersions(v, wsVersion) > 0)
+        : versions;
+    if (available.length === 0) {
+        _log(greenBright('\nAlready up to date.\n'));
+        process.exit(0);
+    }
+    // Sort descending (newest first)
+    available = available.sort((a, b) => compareVersions(b, a));
+    // Group: stable vs prerelease
+    const stable = available.filter((v) => !v.includes('-'));
+    const prerelease = available.filter((v) => v.includes('-'));
+    const choices = [];
+    if (stable.length > 0) {
+        choices.push(new inquirer.Separator('── Stable ──'));
+        for (const v of stable)
+            choices.push({ name: v, value: v });
+    }
+    if (prerelease.length > 0) {
+        choices.push(new inquirer.Separator('── Pre-release ──'));
+        for (const v of prerelease)
+            choices.push({ name: v, value: v });
+    }
+    const { version } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'version',
+            message: 'Select target version:',
+            choices,
+        },
+    ]);
+    return version;
+}
+async function installToTempDir(tmpDir, version) {
+    writeFileSync(join(tmpDir, 'package.json'), JSON.stringify({ dependencies: { 'neutrinos-cli': version } }));
+    const spinner = ora(`Fetching neutrinos-cli@${version}...`).start();
+    try {
+        await exec('npm install --ignore-scripts --no-package-lock', { cwd: tmpDir });
+        spinner.succeed(`Fetched neutrinos-cli@${version}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed to fetch neutrinos-cli@${version}`);
+        throw err;
+    }
+}

package/dist/{src/commands → commands}/new-workspace.js

@@ -4,7 +4,7 @@ import { cpSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path';
 import { exit } from 'node:process';
 import { done, failed, inprogress } from '../utils/logger.js';
-import { pluginJsonPath, pluginServerTemplatesPath, templatesPath } from '../utils/path-utils.js';
+import { getCliPackagePath, pluginJsonPath, pluginServerTemplatesPath, templatesPath } from '../utils/path-utils.js';
 import { prettify } from '../utils/prettify.js';
 export const createWorkspace = async (dir, name) => {
     process.on('SIGINT', () => {
@@ -74,31 +74,37 @@ const cleanUp = (dir) => {
     rmSync(dir, { recursive: true });
     done('Cleaned up workspace');
 };
+export const buildWorkspacePackageJson = (base, cliVersion) => ({
+    ...base,
+    scripts: {},
+    devDependencies: {
+        'neutrinos-cli': cliVersion,
+        lit: '^3.3.2',
+        typescript: '^6.0.2',
+        storybook: '^10.3.1',
+        '@storybook/web-components-vite': '^10.3.1',
+        '@storybook/addon-vitest': '^10.3.1',
+        vitest: '^4.0.0',
+        '@vitest/browser': '^4.0.0',
+        '@vitest/browser-playwright': '^4.0.0',
+    },
+    dependencies: {
+        express: '^5.2.1',
+        '@jatahworx/alpha-annotations-lib': '^1.0.12',
+    },
+    workspaces: ['packages/*'],
+    type: 'module',
+});
 const initializePackages = async (dir) => {
-    inprogress('Adding default npm scripts to workspace...');
-    const pkgJson = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
-    const scripts = {
-        build: 'neutrinos build',
-        start: 'neutrinos start',
-        serve: 'neutrinos serve',
-    };
-    pkgJson.devDependencies = {
-        lit: '^3.1.4',
-        typescript: '^5.2.2',
-    };
-    pkgJson.dependencies = {
-        express: '^4.19.2',
-        '@jatahworx/alpha-annotations-lib': '^1.0.9',
-    };
-    pkgJson.workspaces = ['packages/*'];
-    pkgJson.type = 'module';
-    Object.assign(pkgJson.scripts, {}, scripts);
+    inprogress('Installing default packages in workspace...');
+    const { version: cliVersion } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
+    const base = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+    const pkgJson = buildWorkspacePackageJson(base, cliVersion);
     writeFileSync(join(dir, 'package.json'), await prettify(pkgJson, 'json'));
     execSync('npm install', {
         cwd: dir,
     });
     done(`Installed default packages in workspace: ${bold(dir)}`);
-    done(`Added default npm scripts to workspace: ${bold(dir)}`);
 };
 const initializeStaticServer = (dir) => {
     cpSync(pluginServerTemplatesPath(), join(dir, 'plugins-server'), {

package/dist/{src/commands → commands}/publish.js

@@ -26,7 +26,7 @@ const IMAGES_FILE_PATH_QUERY = {
     message: 'Enter the path to images of the package :',
 };
 export const publish = async (name, wsPath, options) => {
-    const session = await getLoggedInUserSession();
+    const session = (await getLoggedInUserSession());
     const { packageName, componentDirPath } = await getPackageMetadata(wsPath, name);
     await handlePackagePublish(packageName, componentDirPath, wsPath, options, session);
     done('Published Successfully');

package/dist/commands/test.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { failed } from '../utils/logger.js';
+export const runTests = async (wsPath, options) => {
+    const vitestConfig = join(wsPath, 'vitest.config.ts');
+    if (!existsSync(vitestConfig)) {
+        failed('vitest.config.ts not found in workspace. Run "neutrinos doctor --fix" or create it manually.');
+        process.exit(1);
+    }
+    const args = ['vitest'];
+    if (!options.watch) {
+        args.push('--run');
+    }
+    const child = spawn('npx', args, {
+        cwd: wsPath,
+        stdio: 'inherit',
+    });
+    await new Promise((resolve, reject) => {
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Vitest exited with code ${code}`));
+        });
+    });
+};

package/dist/types/session.js

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

package/dist/types/workspace.js

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

package/dist/{src/utils → utils}/attribute-utils.js

@@ -42,9 +42,7 @@ const addEventTypeDecorator = (classDeclaration, attrMetadata) => {
     }
     renderFunction.addDecorator({
         name: 'AlphaAttribute',
-        arguments: [
-            (writer) => writeDecoratorArguments(writer, attrMetadata),
-        ],
+        arguments: [(writer) => writeDecoratorArguments(writer, attrMetadata)],
     });
 };
 const addPropertyDecorator = (classDeclaration, fieldMappings, attrMetadata) => {
@@ -68,9 +66,7 @@ const addPropertyDecorator = (classDeclaration, fieldMappings, attrMetadata) =>
     }
     property.addDecorator({
         name: 'AlphaAttribute',
-        arguments: [
-            (writer) => writeDecoratorArguments(writer, attrMetadata),
-        ],
+        arguments: [(writer) => writeDecoratorArguments(writer, attrMetadata)],
     });
 };
 const writeDecoratorArguments = (writer, attrMetadata) => {

package/dist/utils/doctor-checks/auth-state.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { authConfigJson } from '../path-utils.js';
+export const authStateCheck = {
+    name: 'Auth state',
+    run() {
+        const authPath = authConfigJson();
+        if (!existsSync(authPath)) {
+            return [
+                {
+                    name: 'Auth state',
+                    status: 'fail',
+                    message: `${authPath} not found. Run "neutrinos auth login"`,
+                    fixable: false,
+                },
+            ];
+        }
+        try {
+            const tokenSet = JSON.parse(readFileSync(authPath, 'utf-8'));
+            if (tokenSet.expires_at && tokenSet.expires_at < Date.now() / 1000) {
+                return [
+                    {
+                        name: 'Auth state',
+                        status: 'warn',
+                        message: 'Token expired. Run "neutrinos auth login"',
+                        fixable: false,
+                    },
+                ];
+            }
+        }
+        catch {
+            return [{ name: 'Auth state', status: 'warn', message: 'Could not parse auth.json', fixable: false }];
+        }
+        return [{ name: 'Auth state', status: 'pass', message: 'Token present and valid', fixable: false }];
+    },
+};

package/dist/utils/doctor-checks/cli-update-available.js

@@ -0,0 +1,58 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { getCliPackagePath } from '../path-utils.js';
+export const cliUpdateAvailableCheck = {
+    name: 'CLI update available',
+    run() {
+        const { version: current } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
+        const isBeta = current.includes('-beta');
+        const tag = isBeta ? 'beta' : 'latest';
+        try {
+            const output = execSync('npm view neutrinos-cli dist-tags --json', {
+                stdio: 'pipe',
+                encoding: 'utf-8',
+                timeout: 3000,
+            });
+            const tags = JSON.parse(output);
+            const latest = tags[tag];
+            if (!latest) {
+                return [
+                    {
+                        name: 'CLI update available',
+                        status: 'pass',
+                        message: `v${current} (could not determine ${tag} tag)`,
+                        fixable: false,
+                    },
+                ];
+            }
+            if (latest === current) {
+                return [
+                    {
+                        name: 'CLI update available',
+                        status: 'pass',
+                        message: `v${current} is the latest ${tag}`,
+                        fixable: false,
+                    },
+                ];
+            }
+            return [
+                {
+                    name: 'CLI update available',
+                    status: 'warn',
+                    message: `v${current} → v${latest} available. Run "npm i -g neutrinos-cli@${tag}"`,
+                    fixable: false,
+                },
+            ];
+        }
+        catch {
+            return [
+                {
+                    name: 'CLI update available',
+                    status: 'warn',
+                    message: `v${current} (could not reach npm registry)`,
+                    fixable: false,
+                },
+            ];
+        }
+    },
+};