@emeryld/manager 1.1.0 → 1.3.0

package/README.md

@@ -39,6 +39,7 @@ Dev dependency built for Codex agents: scan a pnpm workspace, scaffold RRRoutes
 
 Each run also prompts for overrides, so you can tweak targets without editing the file.
 The override prompt now lists every limit at once; you can move with ↑/↓, type to replace the highlighted value, Backspace to erase characters, and press Enter when the values validate before confirming.
+You can also decide where the report lands: the manager will ask whether to stream the violations to the console or dump them into a temporary file that is opened in your editor (no repo files are modified).
 
 ## Format checker scan CLI
 - **Usage**: `pnpm manager-cli scan [flags]` scans the workspace without interactive prompts while honoring defaults in `.vscode/settings.json` under `manager.formatChecker`.
@@ -56,9 +57,16 @@ The override prompt now lists every limit at once; you can move with ↑/↓, ty
 | `--indentation-width <number>` | Number of spaces counted per tab when measuring indentation depth. |
 | `--export-only <true|false>` | When `true`, component/function counts only consider exported symbols. |
 | `--reporting-mode <group|file>` | Choose `group` (summary by violation type) or `file` (per-file entries). |
+| `--export-mode <console|editor>` | Choose `console` to print violations in the terminal or `editor` to write them to a temporary file and open it in your default editor. Defaults to `console`. |
 - **Purpose**: give Codex agents, CI pipelines, and automation deterministic scans that print the same violation summaries as the interactive action.
 - **Output**: prints `Format checker violations:` followed by grouped or per-file buckets (with severity, snippets, and location references); when no violations occur you get `Format checker found no violations.` and `Workspace meets the configured format limits.` Colors mirror the interactive report to keep results easy to scan.
 
+## Robot metadata
+
+The `robot metadata` action now starts with the same interactive settings screen as the format checker: pick which kinds of symbols to include, decide whether to limit the scan to exported declarations, and adjust the column width. Use ↑/↓ to move between rows, type new values (comma-separated lists for the kinds), and press Enter once the validation message disappears.
+
+Before the extraction runs you can also choose how to consume the results. The default `console` stream prints the JSON into your terminal, while `editor` writes the report to a temporary file (non-saved) and tries to open it in your editor via your configured `$EDITOR`, `code`, or the OS `open/xdg-open` helpers.
+
 ## Non-interactive release (Codex/CI)
 - **Syntax**: `pnpm manager-cli <pkg|all> --non-interactive [publish flags]`
 - **Requirements**: provide the selection (`<pkg>` or `all`) and one of `--bump <type>`, `--sync <version>`, or `--noop` (skip the version change but still tag/publish). Use `--non-interactive`, `--ci`, `--yes`, or `-y` interchangeably to answer every prompt in the affirmative.

package/dist/cli/interactive-settings.js

@@ -0,0 +1,191 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { colors } from '../utils/log.js';
+const DEFAULT_INSTRUCTIONS = [
+    'Use ↑/↓ to change rows, type to replace the highlighted value, Backspace to clear characters, and Enter to validate and confirm the selection.',
+    'Press Esc/Ctrl+C to abort, or hit Enter again after reviewing the summary to continue.',
+];
+export async function promptInteractiveSettings({ title, descriptors, initial, instructions, validate, }) {
+    const supportsInteractive = typeof input.setRawMode === 'function' && input.isTTY;
+    if (!supportsInteractive) {
+        throw new Error('Interactive mode is not available in this environment.');
+    }
+    return new Promise((resolve) => {
+        const wasRaw = input.isRaw;
+        if (!wasRaw) {
+            input.setRawMode(true);
+            input.resume();
+        }
+        output.write('\x1b[?25l');
+        const state = {
+            selectedIndex: 0,
+            editingIndex: null,
+            editBuffer: '',
+            justFocused: false,
+            errorMessage: '',
+            renderedLines: 0,
+        };
+        const settings = { ...initial };
+        const writableSettings = settings;
+        const cleanup = () => {
+            if (state.renderedLines > 0) {
+                output.write(`\x1b[${state.renderedLines}A`);
+                output.write('\x1b[0J');
+                state.renderedLines = 0;
+            }
+            output.write('\x1b[?25h');
+            if (!wasRaw) {
+                input.setRawMode(false);
+                input.pause();
+            }
+            input.off('data', onData);
+        };
+        const finalize = () => {
+            cleanup();
+            console.log();
+            resolve(settings);
+        };
+        const render = () => {
+            const lines = buildInteractiveLines(title, descriptors, settings, state, instructions ?? DEFAULT_INSTRUCTIONS);
+            if (state.renderedLines > 0) {
+                output.write(`\x1b[${state.renderedLines}A`);
+                output.write('\x1b[0J');
+            }
+            lines.forEach((line) => console.log(line));
+            state.renderedLines = lines.length;
+        };
+        const startEditing = () => {
+            state.editingIndex = state.selectedIndex;
+            state.editBuffer = '';
+            state.justFocused = true;
+            state.errorMessage = '';
+        };
+        const moveSelection = (delta) => {
+            state.selectedIndex =
+                (state.selectedIndex + delta + descriptors.length) % descriptors.length;
+            state.editingIndex = null;
+            state.editBuffer = '';
+            state.justFocused = false;
+            state.errorMessage = '';
+            render();
+        };
+        const commitEdit = () => {
+            if (state.editingIndex === null)
+                return;
+            const descriptor = descriptors[state.editingIndex];
+            const parsed = descriptor.parse(state.editBuffer);
+            if (parsed.error) {
+                state.errorMessage = parsed.error;
+                process.stdout.write('\x07');
+                render();
+                return;
+            }
+            if (parsed.value !== undefined) {
+                writableSettings[descriptor.key] = parsed.value;
+            }
+            state.editingIndex = null;
+            state.editBuffer = '';
+            state.justFocused = false;
+            state.errorMessage = '';
+            render();
+        };
+        const handlePrintable = (typedChar) => {
+            if (state.editingIndex !== state.selectedIndex) {
+                startEditing();
+            }
+            if (state.justFocused) {
+                state.editBuffer = typedChar;
+                state.justFocused = false;
+            }
+            else {
+                state.editBuffer += typedChar;
+            }
+            render();
+        };
+        const handleBackspace = () => {
+            if (state.editingIndex !== state.selectedIndex) {
+                startEditing();
+                state.justFocused = false;
+            }
+            if (state.editBuffer.length > 0) {
+                state.editBuffer = state.editBuffer.slice(0, -1);
+                render();
+                return;
+            }
+            process.stdout.write('\x07');
+        };
+        const onData = (buffer) => {
+            const ascii = buffer.length === 1 ? buffer[0] : undefined;
+            const isPrintable = ascii !== undefined && ascii >= 0x20 && ascii <= 0x7e;
+            const typedChar = isPrintable && ascii !== undefined ? String.fromCharCode(ascii) : '';
+            const isArrowUp = buffer.equals(Buffer.from([0x1b, 0x5b, 0x41]));
+            const isArrowDown = buffer.equals(Buffer.from([0x1b, 0x5b, 0x42]));
+            const isEnter = buffer.length === 1 && (buffer[0] === 0x0d || buffer[0] === 0x0a);
+            const isEscape = buffer.length === 1 && buffer[0] === 0x1b;
+            const isCtrlC = buffer.length === 1 && buffer[0] === 0x03;
+            const isBackspace = buffer.length === 1 && (buffer[0] === 0x7f || buffer[0] === 0x08);
+            if (isCtrlC || isEscape) {
+                cleanup();
+                process.exit(1);
+            }
+            if (isArrowUp) {
+                moveSelection(-1);
+                return;
+            }
+            if (isArrowDown) {
+                moveSelection(1);
+                return;
+            }
+            if (isEnter) {
+                if (state.editingIndex === state.selectedIndex) {
+                    commitEdit();
+                    return;
+                }
+                const validation = validate?.(settings);
+                if (validation) {
+                    state.errorMessage = validation;
+                    process.stdout.write('\x07');
+                    render();
+                    return;
+                }
+                finalize();
+                return;
+            }
+            if (isBackspace) {
+                handleBackspace();
+                return;
+            }
+            if (isPrintable && typedChar) {
+                handlePrintable(typedChar);
+                return;
+            }
+            process.stdout.write('\x07');
+        };
+        input.on('data', onData);
+        render();
+    });
+}
+function buildInteractiveLines(title, descriptors, settings, state, instructions) {
+    const heading = colors.bold(title);
+    const lines = [heading, ''];
+    descriptors.forEach((descriptor, index) => {
+        const isSelected = index === state.selectedIndex;
+        const pointer = isSelected ? colors.green('➤') : '  ';
+        const label = descriptor.unit
+            ? `${descriptor.label} (${descriptor.unit})`
+            : descriptor.label;
+        const isActive = state.editingIndex === index;
+        const baseValue = descriptor.format(settings[descriptor.key]);
+        const displayValue = isActive
+            ? colors.yellow(state.editBuffer.length > 0 ? state.editBuffer : baseValue)
+            : colors.magenta(baseValue);
+        const labelColor = isSelected ? colors.green : colors.cyan;
+        const line = `${pointer} ${labelColor(label)}: ${displayValue}`;
+        lines.push(line);
+    });
+    lines.push('');
+    instructions.forEach((instruction) => lines.push(colors.dim(instruction)));
+    if (state.errorMessage) {
+        lines.push(colors.red(`⚠ ${state.errorMessage}`));
+    }
+    return lines;
+}

package/dist/create-package/shared.js

@@ -135,9 +135,11 @@ export function vscodeSettings() {
         'editor.defaultFormatter': 'esbenp.prettier-vscode',
         'editor.formatOnSave': true,
         'editor.codeActionsOnSave': {
-            'source.fixAll.eslint': true,
+            'source.fixAll.eslint': 'always',
+            'source.organizeImports': true,
         },
         'eslint.useFlatConfig': true,
+        'eslint.format.enable': true,
         'eslint.validate': ['typescript', 'javascript'],
         'files.eol': '\n',
         'prettier.requireConfig': true,

package/dist/create-package/variants/client/client_vite_r.js

@@ -19,9 +19,13 @@ VITE_SOCKET_PATH=/socket.io
 function vitePackageJson(name, contractName, includePrepare) {
     const dependencies = {
         '@emeryld/rrroutes-client': '^2.5.3',
+        '@emotion/react': '^11.12.1',
+        '@emotion/styled': '^11.12.1',
+        '@mui/material': '^5.17.1',
         '@tanstack/react-query': '^5.90.12',
         react: '^18.3.1',
         'react-dom': '^18.3.1',
+        recharts: '^2.7.2',
         'socket.io-client': '^4.8.3',
         zod: '^4.2.1',
     };
@@ -72,21 +76,57 @@ ReactDOM.createRoot(document.getElementById('root')!).render(
 function appTsx() {
     return `import React from 'react'
 import { QueryClientProvider } from '@tanstack/react-query'
+import { ThemeProvider } from '@mui/material/styles'
+import CssBaseline from '@mui/material/CssBaseline'
+import Container from '@mui/material/Container'
 import { queryClient } from './lib/queryClient'
 import { AppSocketProvider } from './lib/socket'
 import { HealthPage } from './pages/HealthPage'
+import theme from './theme'
 
 export default function App() {
   return (
-    <QueryClientProvider client={queryClient}>
-      <AppSocketProvider>
-        <HealthPage />
-      </AppSocketProvider>
-    </QueryClientProvider>
+    <ThemeProvider theme={theme}>
+      <CssBaseline />
+      <QueryClientProvider client={queryClient}>
+        <AppSocketProvider>
+          <Container component="main" maxWidth="lg">
+            <HealthPage />
+          </Container>
+        </AppSocketProvider>
+      </QueryClientProvider>
+    </ThemeProvider>
   )
 }
 `;
 }
+function themeFile() {
+    return `import { createTheme } from '@mui/material/styles'
+
+const theme = createTheme({
+  palette: {
+    mode: 'light',
+    primary: { main: '#2563eb' },
+    secondary: { main: '#f97316' },
+    background: {
+      default: '#f5f7ff',
+      paper: '#ffffff',
+    },
+  },
+  typography: {
+    fontFamily: ['Inter', 'Segoe UI', 'system-ui', 'sans-serif'].join(', '),
+    button: {
+      textTransform: 'none',
+    },
+  },
+  shape: {
+    borderRadius: 12,
+  },
+})
+
+export default theme
+`;
+}
 const STYLES = `:root {
   font-family: 'Inter', system-ui, -apple-system, sans-serif;
   color: #0b1021;
@@ -168,6 +208,11 @@ textarea {
   min-height: 160px;
   white-space: pre-line;
 }
+
+.chart-card .chart-container {
+  height: 220px;
+  width: 100%;
+}
 `;
 function queryClient(contractImport) {
     if (contractImport) {
@@ -347,6 +392,14 @@ export function useSocketConnection() {
 }
 function healthPage(contractImport) {
     return `import React from 'react'
+import {
+  Bar,
+  BarChart,
+  ResponsiveContainer,
+  Tooltip,
+  XAxis,
+  YAxis,
+} from 'recharts'
 import { healthGet, healthPost, hasContract } from '../lib/queryClient'
 import { roomMeta, useSocketClient, useSocketConnection, socketReady } from '../lib/socket'
 
@@ -369,6 +422,18 @@ export function HealthPage() {
   const socket = useSocketClient()
   const { logs, push, clear } = useLogs()
 
+  const chartData = React.useMemo(
+    () => [
+      { name: 'Logs', value: logs.length },
+      { name: 'Socket ready', value: socketReady ? 1 : 0 },
+      {
+        name: 'HTTP errors',
+        value: Number(Boolean(httpGet.error || httpPost.error)),
+      },
+    ],
+    [logs.length, socketReady, httpGet.error, httpPost.error],
+  )
+
   useSocketConnection({
     event: 'health:connected',
     rooms: ['health'],
@@ -502,6 +567,20 @@ export function HealthPage() {
             {logs.length === 0 ? 'No messages yet' : logs.join('\\n')}
           </div>
         </div>
+
+        <div className="card chart-card">
+          <h2>Live state</h2>
+          <div className="chart-container">
+            <ResponsiveContainer width="100%" height="100%">
+              <BarChart data={chartData}>
+                <XAxis dataKey="name" />
+                <YAxis />
+                <Tooltip />
+                <Bar dataKey="value" fill="#2563eb" radius={[4, 4, 0, 0]} />
+              </BarChart>
+            </ResponsiveContainer>
+          </div>
+        </div>
       </div>
     </div>
   )
@@ -542,6 +621,7 @@ export async function scaffoldViteReactClient(ctx) {
         'vite.config.ts': viteConfig(),
         'src/main.tsx': MAIN_TSX,
         'src/App.tsx': appTsx(),
+        'src/theme.ts': themeFile(),
         'src/lib/queryClient.ts': queryClient(ctx.contractName),
         'src/lib/socket.tsx': socketProvider(ctx.contractName),
         'src/pages/HealthPage.tsx': healthPage(ctx.contractName),

package/dist/directory-picker.js

@@ -0,0 +1,158 @@
+import path from 'node:path';
+import { readdir, readFile } from 'node:fs/promises';
+import { IGNORED_DIRECTORIES } from './format-checker/scan/constants.js';
+import { normalizeScripts } from './helper-cli/scripts.js';
+import { promptForScript } from './helper-cli/prompts.js';
+import { rootDir } from './helper-cli/env.js';
+import { loadPackages } from './packages.js';
+const ROOT_ENTRY = {
+    label: 'Workspace root',
+    relativePath: '.',
+    description: 'Root directory',
+    color: 'brightBlue',
+};
+export async function promptDirectorySelection(options = {}) {
+    const candidates = await buildDirectoryCandidates(options.includeWorkspaceRoot ?? true);
+    const entries = normalizeScripts(candidates.map((candidate) => ({
+        name: candidate.label,
+        emoji: '📁',
+        color: candidate.color,
+        description: candidate.description ?? candidate.relativePath,
+        script: candidate.relativePath,
+    })));
+    const selection = await promptForScript(entries, options.title ?? 'Select a directory');
+    if (!selection)
+        return undefined;
+    const relativePath = selection.script ?? '.';
+    const absolutePath = path.resolve(rootDir, relativePath);
+    return { label: selection.displayName, relativePath, absolutePath };
+}
+export function describeDirectorySelection(selection) {
+    const normalized = selection.relativePath
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '');
+    if (!normalized || normalized === '.') {
+        return selection.label;
+    }
+    return `${selection.label} (${normalized})`;
+}
+async function buildDirectoryCandidates(includeRoot) {
+    const directories = await collectDirectories();
+    const packages = await loadPackageMetadata();
+    const packageMap = new Map(packages.map((pkg) => [pkg.relativeDir, pkg]));
+    const candidates = [];
+    const filtered = directories.filter((entry) => includeRoot || entry.relativePath !== '.');
+    for (const entry of filtered) {
+        const pkg = packageMap.get(entry.relativePath);
+        if (pkg) {
+            candidates.push({
+                label: pkg.name ?? pkg.dirName,
+                relativePath: entry.relativePath,
+                description: pkg.relativeDir,
+                color: pkg.color,
+            });
+            continue;
+        }
+        if (entry.relativePath === '.') {
+            candidates.push({
+                label: ROOT_ENTRY.label,
+                relativePath: ROOT_ENTRY.relativePath,
+                description: ROOT_ENTRY.description,
+                color: ROOT_ENTRY.color,
+            });
+            continue;
+        }
+        candidates.push({
+            label: path.basename(entry.relativePath) || ROOT_ENTRY.label,
+            relativePath: entry.relativePath,
+            description: entry.relativePath,
+        });
+    }
+    if (candidates.length === 0 && includeRoot) {
+        candidates.push(ROOT_ENTRY);
+    }
+    return candidates;
+}
+async function collectDirectories() {
+    const patterns = await collectIgnorePatterns();
+    const directories = [];
+    async function walk(current) {
+        const relativeRaw = path.relative(rootDir, current);
+        const relativePath = normalizeRelativePath(relativeRaw);
+        if (current !== rootDir && shouldIgnore(relativePath, patterns)) {
+            return;
+        }
+        directories.push({ absolutePath: current, relativePath });
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink())
+                continue;
+            await walk(path.join(current, entry.name));
+        }
+    }
+    await walk(rootDir);
+    directories.sort((a, b) => {
+        if (a.relativePath === '.')
+            return -1;
+        if (b.relativePath === '.')
+            return 1;
+        return a.relativePath.localeCompare(b.relativePath);
+    });
+    return directories;
+}
+async function collectIgnorePatterns() {
+    const patterns = new Set();
+    for (const entry of IGNORED_DIRECTORIES) {
+        patterns.add(normalizeRelativePath(entry));
+    }
+    try {
+        const contents = await readFile(path.join(rootDir, '.gitignore'), 'utf-8');
+        for (const rawLine of contents.split(/\r?\n/)) {
+            const trimmed = rawLine.trim();
+            if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!'))
+                continue;
+            patterns.add(normalizeRelativePath(trimmed));
+        }
+    }
+    catch {
+        // ignore failures (missing file)
+    }
+    return Array.from(patterns).filter(Boolean);
+}
+function normalizeRelativePath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\/+/, '');
+    const trimmed = normalized.replace(/\/+$/, '');
+    return trimmed || '.';
+}
+function shouldIgnore(relativePath, patterns) {
+    if (relativePath === '.')
+        return false;
+    const segments = relativePath.split('/');
+    for (const pattern of patterns) {
+        if (!pattern)
+            continue;
+        if (relativePath === pattern)
+            return true;
+        if (relativePath.startsWith(`${pattern}/`))
+            return true;
+        const patternSegments = pattern.split('/');
+        if (patternSegments.length === 1 && segments.includes(pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function loadPackageMetadata() {
+    try {
+        return await loadPackages();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/format-checker/cli/options.js

@@ -1,4 +1,5 @@
 import { colors } from '../../utils/log.js';
+import { EXPORT_MODES } from '../../utils/export.js';
 import { parseBooleanInput, parsePositiveInteger, parseReportingModeInput, } from './settings.js';
 export const SCAN_FLAG_DEFINITIONS = [
     {
@@ -64,11 +65,24 @@ export const SCAN_FLAG_DEFINITIONS = [
 ];
 export function parseScanCliArgs(argv) {
     const entries = [];
+    let exportMode = 'console';
     for (let i = 0; i < argv.length; i++) {
         const token = argv[i];
         if (token === '--help' || token === '-h') {
             const overrides = Object.fromEntries(entries);
-            return { overrides, help: true };
+            return { overrides, help: true, exportMode };
+        }
+        if (token === '--export-mode') {
+            const rawValue = argv[++i];
+            if (!rawValue) {
+                throw new Error('Flag "--export-mode" expects a value.');
+            }
+            const normalized = rawValue.toLowerCase();
+            if (!EXPORT_MODES.includes(normalized)) {
+                throw new Error(`Flag "--export-mode" expects one of ${EXPORT_MODES.join(', ')}.`);
+            }
+            exportMode = normalized;
+            continue;
         }
         const definition = SCAN_FLAG_DEFINITIONS.find((def) => def.flag === token);
         if (!definition) {
@@ -84,12 +98,14 @@ export function parseScanCliArgs(argv) {
         ]);
     }
     const overrides = Object.fromEntries(entries);
-    return { overrides, help: false };
+    return { overrides, help: false, exportMode };
 }
 export function printScanUsage() {
     console.log(colors.bold('Usage: pnpm manager-cli scan [flags]'));
     console.log(colors.dim('Run the format checker scan without interactive prompts. Defaults respect .vscode/settings.json (manager.formatChecker).'));
     console.log('');
+    console.log(`${colors.cyan('--export-mode <console|editor>')}\tWhere to print scan results. Defaults to console.`);
+    console.log('');
     SCAN_FLAG_DEFINITIONS.forEach((definition) => {
         console.log(`${colors.cyan(definition.flag)}\t${definition.description}`);
     });