@emeryld/manager 1.2.0 → 1.3.0

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/prompts.js

@@ -1,6 +1,6 @@
 import { colors } from '../../utils/log.js';
 import { stdin as input } from 'node:process';
-import { askLine } from '../../prompts.js';
+import { askLine, promptSingleKey } from '../../prompts.js';
 import { formatValue, parseInteractiveValue, SETTING_DESCRIPTORS, validateLimits, } from './settings.js';
 import { promptInteractiveSettings, } from '../../cli/interactive-settings.js';
 const READY_PROMPT = colors.dim('Limits retained. Use the navigation above to adjust and confirm again.');
@@ -20,14 +20,16 @@ export async function promptLimits(defaults) {
 }
 async function confirmExecution() {
     const question = colors.cyan('Run the format checker with these limits? (Y/n): ');
-    while (true) {
-        const answer = (await askLine(question)).trim().toLowerCase();
-        if (!answer || answer === 'y' || answer === 'yes')
+    return promptSingleKey(question, (key, raw) => {
+        if (!key)
+            return undefined;
+        if (key === 'y' || key === 'yes')
             return true;
-        if (answer === 'n' || answer === 'no')
+        if (key === 'n' || key === 'no')
             return false;
-        console.log(colors.yellow('Answer "yes" or "no", or press Enter to proceed.'));
-    }
+        console.log(colors.yellow('Answer "yes" or "no".'));
+        return undefined;
+    });
 }
 async function promptLimitsSequential(defaults) {
     console.log(colors.dim('Enter a number to override a limit or press Enter to keep the default.'));

package/dist/format-checker/index.js

@@ -1,5 +1,7 @@
 import { colors } from '../utils/log.js';
 import { captureConsoleOutput, exportReportLines, promptExportMode, } from '../utils/export.js';
+import { promptDirectorySelection, describeDirectorySelection } from '../directory-picker.js';
+import { runHelperCli } from '../helper-cli.js';
 import { rootDir } from '../helper-cli/env.js';
 import { loadFormatLimits, } from './config.js';
 import { collectSourceFiles, analyzeFiles } from './scan/index.js';
@@ -9,9 +11,54 @@ import { parseScanCliArgs, printScanUsage } from './cli/options.js';
 export async function runFormatChecker() {
     console.log(colors.cyan('Gathering defaults from .vscode/settings.json (manager.formatChecker)'));
     const defaults = await loadFormatLimits();
-    const limits = await promptLimits(defaults);
-    const exportMode = await promptExportMode();
-    await executeFormatCheck(limits, exportMode);
+    let limits = defaults;
+    let exportMode = 'console';
+    while (true) {
+        let lastAction;
+        const scripts = [
+            {
+                name: 'Run format checker',
+                emoji: '🧮',
+                description: `${formatLimitsSummary(limits)} · export=${exportMode}`,
+                handler: async () => {
+                    const selection = await promptDirectorySelection({
+                        title: 'Select directory for format scan',
+                    });
+                    if (!selection)
+                        return;
+                    lastAction = 'run';
+                    await executeFormatCheck(limits, exportMode, selection.absolutePath, describeDirectorySelection(selection));
+                },
+            },
+            {
+                name: 'Adjust limits',
+                emoji: '⚙️',
+                description: formatLimitsSummary(limits),
+                handler: async () => {
+                    limits = await promptLimits(limits);
+                    lastAction = 'configure';
+                },
+            },
+            {
+                name: 'Change export mode',
+                emoji: '📤',
+                description: `Current: ${exportMode}`,
+                handler: async () => {
+                    exportMode = await promptExportMode();
+                    lastAction = 'export';
+                },
+            },
+        ];
+        const ran = await runHelperCli({
+            title: 'Format checker helper',
+            scripts,
+            argv: [],
+        });
+        if (!ran)
+            return;
+        if (lastAction === 'run')
+            return;
+    }
 }
 export async function runFormatCheckerScanCli(argv) {
     const { overrides, help, exportMode } = parseScanCliArgs(argv);
@@ -24,9 +71,9 @@ export async function runFormatCheckerScanCli(argv) {
     console.log(colors.cyan('Running format checker scan (machine-friendly)'));
     await executeFormatCheck(limits, exportMode);
 }
-async function executeFormatCheck(limits, exportMode) {
-    console.log(colors.magenta('Scanning workspace for source files...'));
-    const files = await collectSourceFiles(rootDir);
+async function executeFormatCheck(limits, exportMode, scanRoot = rootDir, scopeLabel = 'workspace') {
+    console.log(colors.magenta(`Scanning ${scopeLabel} for source files...`));
+    const files = await collectSourceFiles(scanRoot);
     if (files.length === 0) {
         console.log(colors.yellow('No source files were found to analyze.'));
         return;
@@ -46,3 +93,6 @@ async function handleViolations(violations, reportingMode, exportMode) {
     await exportReportLines('format-checker', 'txt', lines);
     return result;
 }
+function formatLimitsSummary(limits) {
+    return `limits: fn≤${limits.maxFunctionLength} · indent≤${limits.maxIndentationDepth} · reporting=${limits.reportingMode} · exportOnly=${limits.exportOnly}`;
+}

package/dist/robot/coordinator.js

@@ -4,7 +4,8 @@ import { colors } from '../utils/log.js';
 import { exportReportLines, promptExportMode, } from '../utils/export.js';
 import { collectSourceFiles } from '../format-checker/scan/collect.js';
 import { resolveScriptKind } from '../format-checker/scan/utils.js';
-import { rootDir } from '../helper-cli/env.js';
+import { promptDirectorySelection, describeDirectorySelection } from '../directory-picker.js';
+import { runHelperCli } from '../helper-cli.js';
 import { loadRobotSettings } from './config.js';
 import { promptRobotSettings } from './cli/prompts.js';
 import { collectFunctions } from './extractors/functions.js';
@@ -14,28 +15,67 @@ import { collectTypes } from './extractors/types.js';
 import { collectClasses } from './extractors/classes.js';
 export async function runRobot() {
     const defaults = await loadRobotSettings();
-    const settings = await promptRobotSettings(defaults);
-    const exportMode = await promptExportMode();
+    let settings = defaults;
+    let exportMode = 'console';
     console.log(colors.magenta('Running robot analyzer (manager.robot settings)'));
-    const files = await collectSourceFiles(rootDir);
+    while (true) {
+        let lastAction;
+        let runResult;
+        const scripts = [
+            {
+                name: 'Run robot extractor',
+                emoji: '🤖',
+                description: robotSettingsSummary(settings),
+                handler: async () => {
+                    const selection = await promptDirectorySelection({
+                        title: 'Select directory for robot extractor',
+                    });
+                    if (!selection)
+                        return;
+                    lastAction = 'run';
+                    runResult = await executeRobotExtraction(settings, exportMode, selection.absolutePath, describeDirectorySelection(selection));
+                },
+            },
+            {
+                name: 'Adjust settings',
+                emoji: '⚙️',
+                description: robotSettingsSummary(settings),
+                handler: async () => {
+                    settings = await promptRobotSettings(settings);
+                    lastAction = 'configure';
+                },
+            },
+            {
+                name: 'Change export mode',
+                emoji: '📤',
+                description: `Current: ${exportMode}`,
+                handler: async () => {
+                    exportMode = await promptExportMode();
+                    lastAction = 'export';
+                },
+            },
+        ];
+        const ran = await runHelperCli({
+            title: 'Robot metadata helper',
+            scripts,
+            argv: [],
+        });
+        if (!ran)
+            return createEmptyRobotResult();
+        if (lastAction === 'run' && runResult) {
+            return runResult;
+        }
+    }
+}
+async function executeRobotExtraction(settings, exportMode, scanRoot, scanLabel) {
+    console.log(colors.magenta(`Scanning ${scanLabel} for metadata`));
+    const files = await collectSourceFiles(scanRoot);
     if (files.length === 0) {
         console.log(colors.yellow('No source files found for robot'));
-        return {
-            functions: [],
-            components: [],
-            types: [],
-            consts: [],
-            classes: [],
-        };
+        return createEmptyRobotResult();
     }
     console.log(colors.magenta(`Analyzing ${files.length} files for metadata`));
-    const result = {
-        functions: [],
-        components: [],
-        types: [],
-        consts: [],
-        classes: [],
-    };
+    const result = createEmptyRobotResult();
     for (const file of files) {
         let content;
         try {
@@ -92,6 +132,19 @@ export async function runRobot() {
     }
     return result;
 }
+function createEmptyRobotResult() {
+    return {
+        functions: [],
+        components: [],
+        types: [],
+        consts: [],
+        classes: [],
+    };
+}
+function robotSettingsSummary(settings) {
+    const kinds = settings.includeKinds.join(',');
+    return `kinds: ${kinds} · exportOnly=${settings.exportedOnly ? 'yes' : 'no'} · columns≤${settings.maxColumns}`;
+}
 function estimateTokenCount(serialized) {
     const length = Math.max(1, serialized.length);
     return Math.ceil(length / 4);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",