@emeryld/manager 1.2.0 → 1.3.1

package/README.md

@@ -65,8 +65,73 @@ You can also decide where the report lands: the manager will ask whether to stre
 
 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.
 
+The column width now controls how much context is emitted for each declaration. Symbols that start past the configured column keep their name/export status but drop heavyweight fields (IO signatures, docstrings, JSX locations, etc.), so you still see everything in the workspace but only the left-most definitions contribute rich metadata to your LLM prompt.
+
 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.
 
+To keep the payload more token-friendly, the interactive settings screen now exposes `Condense output for compact JSON` and `Docstring length limit`. Enabling the condensed output replaces the verbose object format with a small `fields` + `rows` array layout, and the docstring limit trims comments to the first N characters (set the value to `0` for unlimited). Set your preferred defaults in `.vscode/settings.json` under `manager.robot.condenseOutput` and `manager.robot.maxDocStringLength`.
+
+### Running with arguments
+Run `pnpm manager-cli`, pick the workspace (or “All packages”), then select the `robot metadata` action. The helper walks you through:
+
+1. Set the symbol kinds to capture (comma-separated list or `all`).
+2. Toggle `Only exported symbols`, adjust `Maximum columns`, `Condense output for compact JSON`, and `Docstring length limit`.
+3. Confirm the summary to trigger the run and choose whether to stream results to the console or editor.
+
+The same knobs live in `.vscode/settings.json` under `manager.robot`, for example:
+
+```json
+{
+  "manager.robot": {
+    "includeKinds": ["function", "type", "const"],
+    "exportedOnly": true,
+    "maxColumns": 120,
+    "condenseOutput": true,
+    "maxDocStringLength": 80
+  }
+}
+```
+
+### Example output
+`robot metadata` prints a summary followed by the parsed payload. With the default formatting you get readable JSON:
+
+```text
+Robot extraction complete (functions=4 components=1 types=2 consts=0 classes=1)
+Estimated tokens: 72
+Detailed results:
+{
+  "functions": [
+    {
+      "kind": "function",
+      "name": "buildManagerConfig",
+      "location": { "file": "src/menu.ts", "line": 45, "column": 3 },
+      "docString": "Builds the menu configuration for the helper CLI.",
+      "exported": true,
+      "inputs": ["packages: LoadedPackage[]"],
+      "output": "HelperScriptEntry[]"
+    }
+  ],
+  ...
+}
+```
+
+Enabling `Condense output for compact JSON` yields a compact payload that reduces tokens even when the detailed rows are long:
+
+```text
+Robot extraction complete (functions=4 components=1 types=2 consts=0 classes=1)
+Estimated tokens: 48
+Detailed results (condensed):
+{
+  "version": 1,
+  "summary": { "functions": 4, "components": 1, "types": 2, "consts": 0, "classes": 1 },
+  "fields": ["kind","file","line","column","name","signature","docString","exported"],
+  "rows": [
+    ["function","src/menu.ts",45,3,"buildManagerConfig","(packages: LoadedPackage[]) => HelperScriptEntry[]","Builds the menu configuration...",true],
+    ["component","src/ui/banner.ts",12,7,"Banner","(props: BannerProps) => JSX.Element","Lightweight banner used in the hero layout.",true]
+  ]
+}
+```
+
 ## 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/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/cli/prompts.js

@@ -35,6 +35,8 @@ async function promptRobotSettingsSequential(defaults) {
         includeKinds: await promptKinds(defaults.includeKinds),
         exportedOnly: await promptBoolean('Only consider exported symbols', defaults.exportedOnly),
         maxColumns: await promptNumber('Maximum columns', defaults.maxColumns),
+        condenseOutput: await promptBoolean('Condense output for compact JSON', defaults.condenseOutput),
+        maxDocStringLength: await promptNumber('Docstring length limit (0 = unlimited)', defaults.maxDocStringLength, { allowZero: true }),
     };
 }
 async function promptKinds(fallback) {
@@ -68,17 +70,21 @@ async function promptBoolean(label, fallback) {
         console.log(colors.yellow('Please answer "yes" or "no", or leave blank to keep the default.'));
     }
 }
-async function promptNumber(label, fallback) {
+async function promptNumber(label, fallback, options) {
     const question = colors.cyan(`${label} [default ${fallback}]: `);
+    const min = options?.allowZero ? 0 : 1;
+    const description = options?.allowZero ? 'non-negative integer' : 'positive integer';
     while (true) {
         const answer = await askLine(question);
         if (!answer)
             return fallback;
         const parsed = Number(answer);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            return Math.floor(parsed);
+        if (!Number.isNaN(parsed)) {
+            const floored = Math.floor(parsed);
+            if (floored >= min)
+                return floored;
         }
-        console.log(colors.yellow('Provide a positive integer or leave blank to keep the default.'));
+        console.log(colors.yellow(`Provide a ${description} or leave blank to keep the default.`));
     }
 }
 async function promptRobotSettingsInteractive(defaults) {

package/dist/robot/cli/settings.js

@@ -18,6 +18,18 @@ export const SETTING_DESCRIPTORS = [
         unit: 'columns',
         type: 'number',
     },
+    {
+        key: 'condenseOutput',
+        label: 'Condense output for compact JSON',
+        type: 'boolean',
+    },
+    {
+        key: 'maxDocStringLength',
+        label: 'Docstring length limit (0=unlimited)',
+        unit: 'characters',
+        type: 'number',
+        allowZero: true,
+    },
 ];
 export function formatValue(value, descriptor) {
     if (descriptor.type === 'boolean') {
@@ -63,6 +75,10 @@ export function validateRobotSettings(settings) {
     if (!Number.isFinite(settings.maxColumns) || settings.maxColumns <= 0) {
         return 'Maximum columns must be a positive number.';
     }
+    if (!Number.isFinite(settings.maxDocStringLength) ||
+        settings.maxDocStringLength < 0) {
+        return 'Docstring length limit must be zero or greater.';
+    }
     return undefined;
 }
 function parsePositiveInteger(inputValue, options) {

package/dist/robot/config.js

@@ -9,6 +9,8 @@ export const DEFAULT_ROBOT_SETTINGS = {
     includeKinds: [...ROBOT_KINDS],
     exportedOnly: true,
     maxColumns: 160,
+    condenseOutput: true,
+    maxDocStringLength: 0,
 };
 function coerceNumber(value, fallback) {
     const num = Number(value);
@@ -28,6 +30,13 @@ function coerceBoolean(value, fallback) {
     }
     return fallback;
 }
+function coerceNonNegativeNumber(value, fallback) {
+    const num = Number(value);
+    if (Number.isNaN(num) || num < 0) {
+        return fallback;
+    }
+    return Math.floor(num);
+}
 function coerceKinds(value) {
     const knownKinds = new Set(ROBOT_KINDS);
     if (typeof value === 'string') {
@@ -75,6 +84,8 @@ export async function loadRobotSettings() {
             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),
+            condenseOutput: coerceBoolean(record.condenseOutput ?? DEFAULT_ROBOT_SETTINGS.condenseOutput, DEFAULT_ROBOT_SETTINGS.condenseOutput),
+            maxDocStringLength: coerceNonNegativeNumber(record.maxDocStringLength ?? DEFAULT_ROBOT_SETTINGS.maxDocStringLength, DEFAULT_ROBOT_SETTINGS.maxDocStringLength),
         };
     }
     catch {

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';
@@ -12,30 +13,70 @@ import { collectComponents } from './extractors/components.js';
 import { collectConstants } from './extractors/constants.js';
 import { collectTypes } from './extractors/types.js';
 import { collectClasses } from './extractors/classes.js';
+import { serializeRobotResult } from './serializer.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 {
@@ -71,27 +112,43 @@ export async function runRobot() {
         consts: result.consts.length,
         classes: result.classes.length,
     };
-    const snapshot = JSON.stringify(result);
-    const tokenEstimate = estimateTokenCount(snapshot);
+    const serializedResult = serializeRobotResult(result, settings);
+    const tokenEstimate = estimateTokenCount(serializedResult);
     result.tokenEstimate = tokenEstimate;
+    const detailLabel = settings.condenseOutput
+        ? 'Detailed results (condensed)'
+        : 'Detailed results';
     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));
+        console.log(colors.dim(detailLabel));
+        console.log(serializedResult);
     }
     else {
         await exportReportLines('robot-metadata', 'json', [
             summaryText,
             `Token estimate: ${tokenEstimate}`,
             '',
-            'Detailed results:',
-            JSON.stringify(result, null, 2),
+            `${detailLabel}:`,
+            serializedResult,
         ]);
     }
     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/dist/robot/extractors/classes.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+import { EMPTY_LOCATION, getDocString, getLocation, isNodeExported, shouldIncludeContext, } from './shared.js';
 export function collectClasses(options) {
     const { sourceFile } = options.context;
     const records = [];
@@ -10,26 +10,27 @@ export function collectClasses(options) {
         }
         const name = node.name?.text;
         const location = getLocation(node, sourceFile);
-        if (!withinColumnLimit(location, options.settings.maxColumns)) {
-            ts.forEachChild(node, visit);
-            return;
-        }
+        const includeContext = shouldIncludeContext(location, options.settings.maxColumns);
         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));
+        let extendsText;
+        let implementsList;
+        if (includeContext) {
+            const extendsClause = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
+            const implementsClause = node.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword);
+            extendsText = extendsClause?.types
+                .map((expr) => expr.getText(sourceFile))
+                .join(', ');
+            implementsList = implementsClause?.types.map((expr) => expr.getText(sourceFile));
+        }
         records.push({
             kind: 'class',
             name,
-            location,
-            docString: getDocString(node),
+            location: includeContext ? location : EMPTY_LOCATION,
+            docString: includeContext ? getDocString(node) : undefined,
             exported,
             extends: extendsText,
             implements: implementsList,

package/dist/robot/extractors/components.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { describeParameter, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, withinColumnLimit, } from './shared.js';
+import { describeParameter, EMPTY_LOCATION, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, shouldIncludeContext, } from './shared.js';
 export function collectComponents(options) {
     const { sourceFile } = options.context;
     const records = [];
@@ -14,24 +14,31 @@ export function collectComponents(options) {
                 return;
             }
             const location = getLocation(node, sourceFile);
-            if (!withinColumnLimit(location, options.settings.maxColumns)) {
-                return;
-            }
+            const includeContext = shouldIncludeContext(location, options.settings.maxColumns);
             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);
+            const inputs = includeContext
+                ? node.parameters.map((param) => describeParameter(param, sourceFile))
+                : [];
+            const output = includeContext
+                ? node.type?.getText(sourceFile)
+                : undefined;
+            const docString = includeContext ? getDocString(node) : undefined;
+            let jsxLocation;
+            if (includeContext) {
+                const jsxNode = findFirstJsx(node);
+                jsxLocation = jsxNode ? getLocation(jsxNode, sourceFile) : location;
+            }
             records.push({
                 kind: 'component',
                 name,
-                location,
-                docString: getDocString(node),
+                location: includeContext ? location : EMPTY_LOCATION,
+                docString,
                 exported,
                 inputs,
                 output,
-                jsxLocation: jsxNode ? getLocation(jsxNode, sourceFile) : location,
+                jsxLocation,
             });
         }
         ts.forEachChild(node, visit);

package/dist/robot/extractors/constants.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+import { EMPTY_LOCATION, getDocString, getLocation, isNodeExported, shouldIncludeContext, } from './shared.js';
 export function collectConstants(options) {
     const { sourceFile } = options.context;
     const records = [];
@@ -23,15 +23,18 @@ export function collectConstants(options) {
                 if (!ts.isIdentifier(declaration.name))
                     return;
                 const location = getLocation(declaration.name, sourceFile);
-                if (!withinColumnLimit(location, options.settings.maxColumns))
-                    return;
+                const includeContext = shouldIncludeContext(location, options.settings.maxColumns);
+                const docString = includeContext ? getDocString(declaration) : undefined;
+                const value = includeContext
+                    ? declaration.initializer?.getText(sourceFile) ?? 'undefined'
+                    : '';
                 records.push({
                     kind: 'const',
                     name: declaration.name.text,
-                    location,
-                    docString: getDocString(declaration),
+                    location: includeContext ? location : EMPTY_LOCATION,
+                    docString,
                     exported,
-                    value: declaration.initializer?.getText(sourceFile) ?? 'undefined',
+                    value,
                 });
             });
         }

package/dist/robot/extractors/functions.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { describeParameter, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, withinColumnLimit, } from './shared.js';
+import { describeParameter, EMPTY_LOCATION, getDocString, getFunctionName, getLocation, isComponentFunction, isNodeExported, shouldIncludeContext, } from './shared.js';
 export function collectFunctions(options) {
     const { sourceFile } = options.context;
     const records = [];
@@ -15,19 +15,22 @@ export function collectFunctions(options) {
                 return;
             }
             const location = getLocation(node, sourceFile);
-            if (!withinColumnLimit(location, options.settings.maxColumns)) {
-                return;
-            }
+            const includeContext = shouldIncludeContext(location, options.settings.maxColumns);
             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 inputs = includeContext
+                ? node.parameters.map((param) => describeParameter(param, sourceFile))
+                : [];
+            const output = includeContext
+                ? node.type?.getText(sourceFile)
+                : undefined;
+            const docString = includeContext ? getDocString(node) : undefined;
             records.push({
                 kind: 'function',
                 name,
-                location,
-                docString: getDocString(node),
+                location: includeContext ? location : EMPTY_LOCATION,
+                docString,
                 exported,
                 inputs,
                 output,

package/dist/robot/extractors/shared.js

@@ -44,11 +44,16 @@ export function isNodeExported(node) {
         return true;
     return false;
 }
-export function withinColumnLimit(location, maxColumns) {
+export function shouldIncludeContext(location, maxColumns) {
     if (maxColumns <= 0)
         return true;
     return location.column <= maxColumns;
 }
+export const EMPTY_LOCATION = {
+    file: '',
+    line: 0,
+    column: 0,
+};
 export function getFunctionName(node) {
     if ('name' in node && node.name && ts.isIdentifier(node.name)) {
         return node.name.text;

package/dist/robot/extractors/types.js

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getDocString, getLocation, isNodeExported, withinColumnLimit, } from './shared.js';
+import { EMPTY_LOCATION, getDocString, getLocation, isNodeExported, shouldIncludeContext, } from './shared.js';
 export function collectTypes(options) {
     const { sourceFile } = options.context;
     const records = [];
@@ -16,10 +16,7 @@ export function collectTypes(options) {
         }
         if (typeKind) {
             const location = getLocation(node, sourceFile);
-            if (!withinColumnLimit(location, options.settings.maxColumns)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
+            const includeContext = shouldIncludeContext(location, options.settings.maxColumns);
             const exported = isNodeExported(node);
             if (options.settings.exportedOnly && !exported) {
                 ts.forEachChild(node, visit);
@@ -29,11 +26,11 @@ export function collectTypes(options) {
             records.push({
                 kind: 'type',
                 name,
-                location,
-                docString: getDocString(node),
+                location: includeContext ? location : EMPTY_LOCATION,
+                docString: includeContext ? getDocString(node) : undefined,
                 exported,
                 typeKind,
-                definition: node.getText(sourceFile),
+                definition: includeContext ? node.getText(sourceFile) : '',
             });
         }
         ts.forEachChild(node, visit);

package/dist/robot/serializer.js

@@ -0,0 +1,97 @@
+const CONDENSED_FIELDS = [
+    'kind',
+    'file',
+    'line',
+    'column',
+    'name',
+    'signature',
+    'docString',
+    'exported',
+];
+export function serializeRobotResult(result, settings) {
+    if (!settings.condenseOutput) {
+        return JSON.stringify(result, null, 2);
+    }
+    return JSON.stringify(buildCondensedPayload(result, settings));
+}
+function buildCondensedPayload(result, settings) {
+    const rows = [];
+    const limit = settings.maxDocStringLength;
+    for (const record of flattenRecords(result)) {
+        rows.push([
+            record.kind,
+            record.location.file,
+            record.location.line,
+            record.location.column,
+            record.name ?? '',
+            buildSignature(record),
+            trimDocString(record.docString, limit),
+            record.exported,
+        ]);
+    }
+    return {
+        version: 1,
+        summary: {
+            functions: result.functions.length,
+            components: result.components.length,
+            types: result.types.length,
+            consts: result.consts.length,
+            classes: result.classes.length,
+        },
+        fields: [...CONDENSED_FIELDS],
+        rows,
+    };
+}
+function flattenRecords(result) {
+    return [
+        ...result.functions,
+        ...result.components,
+        ...result.types,
+        ...result.consts,
+        ...result.classes,
+    ];
+}
+function buildSignature(record) {
+    switch (record.kind) {
+        case 'function':
+        case 'component': {
+            const params = record.inputs.join(', ');
+            const output = record.output ? ` => ${normalize(record.output)}` : '';
+            return `(${params})${output}`;
+        }
+        case 'type': {
+            const displayKind = record.typeKind === 'type-alias'
+                ? 'type alias'
+                : record.typeKind;
+            return normalize(`${displayKind} ${record.definition}`);
+        }
+        case 'const':
+            return normalize(record.value);
+        case 'class': {
+            const parts = [];
+            if (record.extends)
+                parts.push(`extends ${record.extends}`);
+            if (record.implements?.length) {
+                parts.push(`implements ${record.implements.join(', ')}`);
+            }
+            return normalize(parts.join(' '));
+        }
+        default:
+            return '';
+    }
+}
+function trimDocString(value, limit) {
+    if (!value) {
+        return '';
+    }
+    const normalized = normalize(value);
+    if (limit <= 0 || normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, limit)}...`;
+}
+function normalize(value) {
+    return (value ?? '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}

package/package.json

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