@emeryld/manager 1.3.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/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

@@ -13,6 +13,7 @@ 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();
     let settings = defaults;
@@ -111,23 +112,26 @@ async function executeRobotExtraction(settings, exportMode, scanRoot, scanLabel)
         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;

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.3.0",
+  "version": "1.3.1",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",