@emeryld/manager 1.1.0 → 1.2.0

package/dist/robot/config.js

@@ -0,0 +1,83 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { rootDir } from '../helper-cli/env.js';
+import { ROBOT_KINDS } from './types.js';
+const SETTINGS_SECTION = 'manager.robot';
+const workspaceSettingsPath = path.join(rootDir, '.vscode', 'settings.json');
+export const DEFAULT_ROBOT_SETTINGS = {
+    includeKinds: [...ROBOT_KINDS],
+    exportedOnly: true,
+    maxColumns: 160,
+};
+function coerceNumber(value, fallback) {
+    const num = Number(value);
+    if (Number.isNaN(num) || num <= 0) {
+        return fallback;
+    }
+    return Math.floor(num);
+}
+function coerceBoolean(value, fallback) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        if (value.toLowerCase() === 'true')
+            return true;
+        if (value.toLowerCase() === 'false')
+            return false;
+    }
+    return fallback;
+}
+function coerceKinds(value) {
+    const knownKinds = new Set(ROBOT_KINDS);
+    if (typeof value === 'string') {
+        const items = value
+            .split(',')
+            .map((chunk) => chunk.trim().toLowerCase())
+            .filter(Boolean);
+        const forced = [];
+        for (const entry of items) {
+            if (knownKinds.has(entry)) {
+                forced.push(entry);
+            }
+        }
+        if (forced.length > 0)
+            return forced;
+    }
+    if (Array.isArray(value)) {
+        const forced = [];
+        for (const entry of value) {
+            if (typeof entry === 'string') {
+                const normalized = entry.trim().toLowerCase();
+                if (knownKinds.has(normalized)) {
+                    forced.push(normalized);
+                }
+            }
+        }
+        if (forced.length > 0)
+            return forced;
+    }
+    return DEFAULT_ROBOT_SETTINGS.includeKinds;
+}
+export async function loadRobotSettings() {
+    if (!existsSync(workspaceSettingsPath)) {
+        return DEFAULT_ROBOT_SETTINGS;
+    }
+    try {
+        const raw = await readFile(workspaceSettingsPath, 'utf-8');
+        const json = JSON.parse(raw);
+        const settings = json[SETTINGS_SECTION];
+        if (!settings || typeof settings !== 'object') {
+            return DEFAULT_ROBOT_SETTINGS;
+        }
+        const record = settings;
+        return {
+            includeKinds: coerceKinds(record.includeKinds ?? record.kinds),
+            exportedOnly: coerceBoolean(record.exportedOnly ?? DEFAULT_ROBOT_SETTINGS.exportedOnly, DEFAULT_ROBOT_SETTINGS.exportedOnly),
+            maxColumns: coerceNumber(record.maxColumns ?? DEFAULT_ROBOT_SETTINGS.maxColumns, DEFAULT_ROBOT_SETTINGS.maxColumns),
+        };
+    }
+    catch {
+        return DEFAULT_ROBOT_SETTINGS;
+    }
+}

package/dist/robot/coordinator.js

@@ -0,0 +1,98 @@
+import { readFile } from 'node:fs/promises';
+import * as ts from 'typescript';
+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 { loadRobotSettings } from './config.js';
+import { promptRobotSettings } from './cli/prompts.js';
+import { collectFunctions } from './extractors/functions.js';
+import { collectComponents } from './extractors/components.js';
+import { collectConstants } from './extractors/constants.js';
+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();
+    console.log(colors.magenta('Running robot analyzer (manager.robot settings)'));
+    const files = await collectSourceFiles(rootDir);
+    if (files.length === 0) {
+        console.log(colors.yellow('No source files found for robot'));
+        return {
+            functions: [],
+            components: [],
+            types: [],
+            consts: [],
+            classes: [],
+        };
+    }
+    console.log(colors.magenta(`Analyzing ${files.length} files for metadata`));
+    const result = {
+        functions: [],
+        components: [],
+        types: [],
+        consts: [],
+        classes: [],
+    };
+    for (const file of files) {
+        let content;
+        try {
+            content = await readFile(file, 'utf-8');
+        }
+        catch {
+            console.log(colors.yellow(`Unable to read ${file}`));
+            continue;
+        }
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(file));
+        const context = { filePath: file, sourceFile };
+        const options = { settings, context };
+        if (settings.includeKinds.includes('function')) {
+            result.functions.push(...collectFunctions(options));
+        }
+        if (settings.includeKinds.includes('component')) {
+            result.components.push(...collectComponents(options));
+        }
+        if (settings.includeKinds.includes('type')) {
+            result.types.push(...collectTypes(options));
+        }
+        if (settings.includeKinds.includes('const')) {
+            result.consts.push(...collectConstants(options));
+        }
+        if (settings.includeKinds.includes('class')) {
+            result.classes.push(...collectClasses(options));
+        }
+    }
+    const summary = {
+        functions: result.functions.length,
+        components: result.components.length,
+        types: result.types.length,
+        consts: result.consts.length,
+        classes: result.classes.length,
+    };
+    const snapshot = JSON.stringify(result);
+    const tokenEstimate = estimateTokenCount(snapshot);
+    result.tokenEstimate = tokenEstimate;
+    const summaryText = `Robot extraction complete (functions=${summary.functions} components=${summary.components} types=${summary.types} consts=${summary.consts} classes=${summary.classes})`;
+    console.log(colors.green(summaryText));
+    console.log(colors.dim(`Estimated tokens: ${tokenEstimate}`));
+    if (exportMode === 'console') {
+        console.log(colors.dim('Detailed results:'));
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        await exportReportLines('robot-metadata', 'json', [
+            summaryText,
+            `Token estimate: ${tokenEstimate}`,
+            '',
+            'Detailed results:',
+            JSON.stringify(result, null, 2),
+        ]);
+    }
+    return result;
+}
+function estimateTokenCount(serialized) {
+    const length = Math.max(1, serialized.length);
+    return Math.ceil(length / 4);
+}

package/dist/robot/extractors/classes.js

@@ -0,0 +1,41 @@
+import * as ts from 'typescript';
+import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+export function collectClasses(options) {
+    const { sourceFile } = options.context;
+    const records = [];
+    function visit(node) {
+        if (!ts.isClassDeclaration(node)) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        const name = node.name?.text;
+        const location = getLocation(node, sourceFile);
+        if (!withinColumnLimit(location, options.settings.maxColumns)) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        const exported = isNodeExported(node);
+        if (options.settings.exportedOnly && !exported) {
+            ts.forEachChild(node, visit);
+            return;
+        }
+        const extendsClause = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+        const implementsClause = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword);
+        const extendsText = extendsClause?.types
+            .map((expr) => expr.getText(sourceFile))
+            .join(', ');
+        const implementsList = implementsClause?.types.map((expr) => expr.getText(sourceFile));
+        records.push({
+            kind: 'class',
+            name,
+            location,
+            docString: getDocString(node),
+            exported,
+            extends: extendsText,
+            implements: implementsList,
+        });
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}

package/dist/robot/extractors/components.js

@@ -0,0 +1,57 @@
+import * as ts from 'typescript';
+import { describeParameter, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, withinColumnLimit, } from './shared.js';
+export function collectComponents(options) {
+    const { sourceFile } = options.context;
+    const records = [];
+    function visit(node) {
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node)) &&
+            Boolean(node.body)) {
+            const name = getFunctionName(node);
+            if (!isComponentFunction(node, name)) {
+                return;
+            }
+            const location = getLocation(node, sourceFile);
+            if (!withinColumnLimit(location, options.settings.maxColumns)) {
+                return;
+            }
+            const exported = isNodeExported(node);
+            if (options.settings.exportedOnly && !exported)
+                return;
+            const inputs = node.parameters.map((param) => describeParameter(param, sourceFile));
+            const output = node.type?.getText(sourceFile);
+            const jsxNode = findFirstJsx(node);
+            records.push({
+                kind: 'component',
+                name,
+                location,
+                docString: getDocString(node),
+                exported,
+                inputs,
+                output,
+                jsxLocation: jsxNode ? getLocation(jsxNode, sourceFile) : location,
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}
+function findFirstJsx(node) {
+    let found;
+    function walk(child) {
+        if (child.kind === ts.SyntaxKind.JsxElement ||
+            child.kind === ts.SyntaxKind.JsxSelfClosingElement ||
+            child.kind === ts.SyntaxKind.JsxFragment) {
+            found = child;
+            return;
+        }
+        if (found)
+            return;
+        ts.forEachChild(child, walk);
+    }
+    ts.forEachChild(node, walk);
+    return found;
+}

package/dist/robot/extractors/constants.js

@@ -0,0 +1,42 @@
+import * as ts from 'typescript';
+import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+export function collectConstants(options) {
+    const { sourceFile } = options.context;
+    const records = [];
+    function visit(node) {
+        if (ts.isVariableStatement(node)) {
+            if (!(node.declarationList.flags & ts.NodeFlags.Const)) {
+                // only care about top-level consts
+                ts.forEachChild(node, visit);
+                return;
+            }
+            if (!ts.isSourceFile(node.parent)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const exported = isNodeExported(node);
+            if (options.settings.exportedOnly && !exported) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            node.declarationList.declarations.forEach((declaration) => {
+                if (!ts.isIdentifier(declaration.name))
+                    return;
+                const location = getLocation(declaration.name, sourceFile);
+                if (!withinColumnLimit(location, options.settings.maxColumns))
+                    return;
+                records.push({
+                    kind: 'const',
+                    name: declaration.name.text,
+                    location,
+                    docString: getDocString(declaration),
+                    exported,
+                    value: declaration.initializer?.getText(sourceFile) ?? 'undefined',
+                });
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}

package/dist/robot/extractors/functions.js

@@ -0,0 +1,40 @@
+import * as ts from 'typescript';
+import { describeParameter, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, withinColumnLimit, } from './shared.js';
+export function collectFunctions(options) {
+    const { sourceFile } = options.context;
+    const records = [];
+    function visit(node) {
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node)) &&
+            Boolean(node.body)) {
+            const name = getFunctionName(node);
+            if (isComponentFunction(node, name)) {
+                // components are handled separately
+                return;
+            }
+            const location = getLocation(node, sourceFile);
+            if (!withinColumnLimit(location, options.settings.maxColumns)) {
+                return;
+            }
+            const exported = isNodeExported(node);
+            if (options.settings.exportedOnly && !exported)
+                return;
+            const inputs = node.parameters.map((param) => describeParameter(param, sourceFile));
+            const output = node.type?.getText(sourceFile);
+            records.push({
+                kind: 'function',
+                name,
+                location,
+                docString: getDocString(node),
+                exported,
+                inputs,
+                output,
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}

package/dist/robot/extractors/shared.js

@@ -0,0 +1,99 @@
+import * as ts from 'typescript';
+export function getLocation(node, sourceFile) {
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    return {
+        file: sourceFile.fileName,
+        line: position.line + 1,
+        column: position.character + 1,
+    };
+}
+export function getDocString(node) {
+    const docNodes = node.jsDoc;
+    if (!docNodes || docNodes.length === 0)
+        return undefined;
+    const parts = [];
+    for (const doc of docNodes) {
+        if (typeof doc.comment === 'string') {
+            parts.push(doc.comment.trim());
+        }
+        if (doc.tags) {
+            for (const tag of doc.tags) {
+                if (typeof tag.comment === 'string') {
+                    parts.push(tag.comment.trim());
+                }
+            }
+        }
+    }
+    const combined = parts.filter(Boolean).join('\n');
+    return combined.length ? combined : undefined;
+}
+export function hasExportModifier(node) {
+    if (!node || !('modifiers' in node))
+        return false;
+    const modifiers = node.modifiers;
+    if (!modifiers)
+        return false;
+    return modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+}
+export function isNodeExported(node) {
+    if (hasExportModifier(node))
+        return true;
+    if (hasExportModifier(node.parent))
+        return true;
+    if (hasExportModifier(node.parent?.parent))
+        return true;
+    return false;
+}
+export function withinColumnLimit(location, maxColumns) {
+    if (maxColumns <= 0)
+        return true;
+    return location.column <= maxColumns;
+}
+export function getFunctionName(node) {
+    if ('name' in node && node.name && ts.isIdentifier(node.name)) {
+        return node.name.text;
+    }
+    const parent = node.parent;
+    if (!parent)
+        return undefined;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    if ((ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent)) &&
+        ts.isIdentifier(parent.name)) {
+        return parent.name.text;
+    }
+    return undefined;
+}
+export function isComponentFunction(node, name) {
+    if (!name)
+        return false;
+    if (!/^[A-Z]/.test(name))
+        return false;
+    return containsJsx(node);
+}
+export function containsJsx(node) {
+    let found = false;
+    function walk(child) {
+        if (child.kind === ts.SyntaxKind.JsxElement ||
+            child.kind === ts.SyntaxKind.JsxSelfClosingElement ||
+            child.kind === ts.SyntaxKind.JsxFragment) {
+            found = true;
+            return;
+        }
+        if (found)
+            return;
+        ts.forEachChild(child, walk);
+    }
+    ts.forEachChild(node, walk);
+    return found;
+}
+export function describeParameter(param, sourceFile) {
+    if (param.type) {
+        return param.type.getText(sourceFile);
+    }
+    if (ts.isIdentifier(param.name)) {
+        return param.name.text;
+    }
+    return param.name.getText(sourceFile);
+}

package/dist/robot/extractors/types.js

@@ -0,0 +1,43 @@
+import * as ts from 'typescript';
+import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+export function collectTypes(options) {
+    const { sourceFile } = options.context;
+    const records = [];
+    function visit(node) {
+        let typeKind;
+        if (ts.isTypeAliasDeclaration(node)) {
+            typeKind = 'type-alias';
+        }
+        else if (ts.isInterfaceDeclaration(node)) {
+            typeKind = 'interface';
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            typeKind = 'enum';
+        }
+        if (typeKind) {
+            const location = getLocation(node, sourceFile);
+            if (!withinColumnLimit(location, options.settings.maxColumns)) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const exported = isNodeExported(node);
+            if (options.settings.exportedOnly && !exported) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const name = node.name?.text;
+            records.push({
+                kind: 'type',
+                name,
+                location,
+                docString: getDocString(node),
+                exported,
+                typeKind,
+                definition: node.getText(sourceFile),
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}

package/dist/robot/index.js

@@ -0,0 +1 @@
+export { runRobot } from './coordinator.js';

package/dist/robot/types.js

@@ -0,0 +1 @@
+export const ROBOT_KINDS = ['function', 'component', 'type', 'const', 'class'];

package/dist/utils/export.js

@@ -0,0 +1,99 @@
+import { tmpdir } from 'node:os';
+import { unlink, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { colors } from './log.js';
+import { run } from './run.js';
+import { promptSingleKey } from '../prompts.js';
+const ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
+const DEFAULT_EXPORT_MODE = 'console';
+const EDITOR_CANDIDATES = [
+    process.env.MANAGER_EDITOR,
+    'code',
+    'code-insiders',
+    process.env.VISUAL,
+    process.env.EDITOR,
+];
+export const EXPORT_MODES = ['console', 'editor'];
+export async function promptExportMode(defaultMode = DEFAULT_EXPORT_MODE) {
+    const labels = EXPORT_MODES.map((mode) => {
+        const prefix = mode === 'console' ? 'c' : 'e';
+        const display = mode === defaultMode ? `${mode} (default)` : mode;
+        return `${prefix}=${display}`;
+    });
+    const question = colors.cyan(`View results in console or editor? (${labels.join(' / ')}): `);
+    return promptSingleKey(question, (key) => {
+        const normalized = key.trim().toLowerCase();
+        if (!normalized)
+            return defaultMode;
+        if (normalized === 'c')
+            return 'console';
+        if (normalized === 'e')
+            return 'editor';
+        return undefined;
+    });
+}
+export function captureConsoleOutput(callback) {
+    const lines = [];
+    const originalLog = console.log;
+    console.log = (...args) => {
+        lines.push(args.map((arg) => String(arg)).join(' '));
+    };
+    try {
+        const result = callback();
+        return { result, lines };
+    }
+    finally {
+        console.log = originalLog;
+    }
+}
+export async function exportReportLines(label, extension, lines) {
+    const sanitized = lines.map(stripAnsi);
+    const content = `${sanitized.join('\n')}\n`;
+    const filename = `${label}-${Date.now()}.${extension}`;
+    const filePath = path.join(tmpdir(), filename);
+    await writeFile(filePath, content, 'utf-8');
+    const opened = await tryOpenInEditor(filePath);
+    if (opened) {
+        await unlink(filePath).catch(() => { });
+        console.log(colors.green(`Opened the ${colors.bold(label)} report in your editor (temporary file removed).`));
+        return undefined;
+    }
+    console.log(colors.yellow(`Unable to launch an editor. The ${colors.bold(label)} report is at ${filePath}.`));
+    return filePath;
+}
+export function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE, '');
+}
+async function tryOpenInEditor(filePath) {
+    for (const candidate of EDITOR_CANDIDATES) {
+        if (!candidate)
+            continue;
+        const { command, args } = buildEditorCommand(candidate, filePath);
+        try {
+            await run(command, args, { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            // Try the next candidate if the command fails.
+        }
+    }
+    return false;
+}
+function buildEditorCommand(raw, filePath) {
+    const parts = raw.trim().split(/\s+/);
+    if (parts.length === 0) {
+        throw new Error('Editor command cannot be empty.');
+    }
+    const command = parts[0];
+    const extraArgs = parts.slice(1);
+    const terminalArgs = (() => {
+        if (command === 'code' || command === 'code-insiders') {
+            return [...extraArgs, '--goto', filePath, '--wait'];
+        }
+        if (command === 'open') {
+            return [...extraArgs, '-W', filePath];
+        }
+        return [...extraArgs, filePath];
+    })();
+    return { command, args: terminalArgs };
+}

package/dist/utils/run.js

@@ -17,5 +17,8 @@ export function run(command, args, options = {}) {
             else
                 reject(new Error(`Command "${command} ${args.join(' ')}" exited with ${code}`));
         });
+        child.on('error', (error) => {
+            reject(new Error(`Command "${command} ${args.join(' ')}" failed: ${error.message}`));
+        });
     });
 }

package/package.json

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