proteum 2.2.9 → 2.3.0

package/cli/commands/diagnose.ts

@@ -12,6 +12,7 @@ import type { TRequestTraceErrorResponse, TRequestTraceArmResponse } from '../..
 import type { TDevSessionErrorResponse, TDevSessionStartResponse } from '../../common/dev/session';
 import { summarizeTraceForDiagnose } from '@common/dev/inspection';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
+import { compactList, printAgentResponse, printJson, quoteCommandArgument, truncateForAgent } from '../utils/agentOutput';
 
 const normalizeBaseUrl = (value: string) => value.replace(/\/+$/, '');
 const truncate = (value: string, max = 160) => (value.length <= max ? value : `${value.slice(0, max)}...`);
@@ -237,6 +238,132 @@ const renderHuman = (manifest: ReturnType<typeof readProteumManifest>, response:
         renderLogs(response.serverLogs),
     ].join('\n');
 
+const compactOwnerMatch = (match: TDiagnoseResponse['owner']['matches'][number]) => ({
+    kind: match.kind,
+    label: match.label,
+    score: match.score,
+    scope: match.scopeLabel,
+    origin: match.originHint,
+    source: match.source,
+});
+
+const compactDiagnostic = (diagnostic: TDiagnoseResponse['doctor']['diagnostics'][number]) => ({
+    level: diagnostic.level,
+    code: diagnostic.code,
+    message: truncateForAgent(diagnostic.message),
+    filepath: diagnostic.filepath,
+    sourceLocation: diagnostic.sourceLocation,
+    fixHint: diagnostic.fixHint ? truncateForAgent(diagnostic.fixHint) : undefined,
+});
+
+const compactRequest = (request: TDiagnoseResponse['request']) =>
+    request
+        ? {
+              id: request.id,
+              method: request.method,
+              path: request.path,
+              statusCode: request.statusCode,
+              durationMs: request.durationMs,
+              capture: request.capture,
+              user: request.user,
+              errorMessage: request.errorMessage,
+              counts: {
+                  calls: request.calls.length,
+                  events: request.events.length,
+                  sqlQueries: request.sqlQueries.length,
+                  droppedEvents: request.droppedEvents,
+              },
+          }
+        : undefined;
+
+const buildDiagnoseFullDetailCommand = ({
+    hitPath,
+    query,
+}: {
+    hitPath: string;
+    query: string;
+}) =>
+    [
+        'proteum diagnose',
+        quoteCommandArgument(query),
+        hitPath ? `--hit ${quoteCommandArgument(hitPath)}` : '',
+        typeof cli.args.port === 'string' && cli.args.port ? `--port ${cli.args.port}` : '',
+        typeof cli.args.url === 'string' && cli.args.url ? `--url ${quoteCommandArgument(cli.args.url)}` : '',
+        '--full',
+    ]
+        .filter(Boolean)
+        .join(' ');
+
+const printCompactDiagnose = ({
+    hitPath,
+    query,
+    response,
+}: {
+    hitPath: string;
+    query: string;
+    response: TDiagnoseResponse;
+}) => {
+    const request = compactRequest(response.request);
+    const traceSummary = summarizeTraceForDiagnose(response.request);
+    const doctorSummary = `${response.doctor.summary.errors} doctor errors/${response.doctor.summary.warnings} warnings`;
+    const contractsSummary = `${response.contracts.summary.errors} contract errors/${response.contracts.summary.warnings} warnings`;
+    const summary = `${response.query || query || 'request'}: ${traceSummary}; ${doctorSummary}; ${contractsSummary}`;
+    const nextActions = response.orientation?.nextSteps || [];
+    const requestId = response.request?.id;
+
+    printAgentResponse({
+        summary,
+        data: {
+            query: response.query,
+            request,
+            owner: {
+                top: response.owner.matches[0] ? compactOwnerMatch(response.owner.matches[0]) : undefined,
+                matches: compactList(response.owner.matches, 4).map(compactOwnerMatch),
+                totalReturned: response.owner.matches.length,
+            },
+            suspects: compactList(response.suspects, 6),
+            chain: compactList(response.chain || [], 8),
+            diagnostics: {
+                doctor: {
+                    summary: response.doctor.summary,
+                    top: compactList(response.doctor.diagnostics, 6).map(compactDiagnostic),
+                    total: response.doctor.diagnostics.length,
+                },
+                contracts: {
+                    summary: response.contracts.summary,
+                    top: compactList(response.contracts.diagnostics, 6).map(compactDiagnostic),
+                    total: response.contracts.diagnostics.length,
+                },
+            },
+            logs: compactList(response.serverLogs.logs, 10).map((entry) => ({
+                level: entry.level,
+                time: entry.time,
+                text: truncateForAgent(entry.text),
+            })),
+            instructions: response.orientation
+                ? {
+                      mustRead: [...new Set([response.orientation.guidance.agents, ...response.orientation.guidance.areaAgents])],
+                      diagnostics: response.orientation.guidance.diagnostics,
+                      codingStyle: response.orientation.guidance.codingStyle,
+                      optimizations: response.orientation.guidance.optimizations,
+                  }
+                : undefined,
+        },
+        nextActions,
+        fullDetailCommand: buildDiagnoseFullDetailCommand({ hitPath, query }),
+        omitted: [
+            ...(requestId
+                ? [
+                      {
+                          reason: 'Full request events, API call payloads, and SQL text are omitted from the default diagnose response.',
+                          command: `proteum trace show ${quoteCommandArgument(requestId)} --events`,
+                      },
+                  ]
+                : []),
+        ],
+    });
+};
+
 const resolveManifest = async () => {
     try {
         return readProteumManifest(cli.paths.appRoot);
@@ -258,7 +385,6 @@ export const run = async () => {
     const method = typeof cli.args.method === 'string' && cli.args.method ? cli.args.method.trim().toUpperCase() : 'GET';
     const logsLevel = typeof cli.args.logsLevel === 'string' && cli.args.logsLevel ? cli.args.logsLevel.trim() : 'warn';
     const logsLimit = typeof cli.args.logsLimit === 'string' && cli.args.logsLimit ? cli.args.logsLimit.trim() : '40';
-    const shouldPrintJson = cli.args.json === true;
     const hitPath = hit || (target.startsWith('/') ? target : '');
     const query = target || hitPath;
     let parsedDataJson: unknown;
@@ -308,11 +434,16 @@ export const run = async () => {
     const diagnose = await requestJson<TDiagnoseResponse>(
         `/__proteum/diagnose?${new URLSearchParams(diagnoseRequest).toString()}`,
     );
-    if (shouldPrintJson) {
-        console.log(JSON.stringify(diagnose.body, null, 2));
+    if (cli.args.full === true) {
+        printJson(diagnose.body);
+        return;
+    }
+
+    if (cli.args.human === true) {
+        const manifest = await resolveManifest();
+        console.log(renderHuman(manifest, diagnose.body));
         return;
     }
 
-    const manifest = await resolveManifest();
-    console.log(renderHuman(manifest, diagnose.body));
+    printCompactDiagnose({ hitPath, query, response: diagnose.body });
 };

package/cli/commands/doctor.ts

@@ -3,8 +3,9 @@ import Compiler from '../compiler';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
 import { buildContractsDoctorResponse } from '@common/dev/contractsDoctor';
 import { buildDoctorResponse, renderDoctorHuman, renderDoctorResponseHuman } from '@common/dev/diagnostics';
+import { compactList, printAgentResponse, printJson, truncateForAgent } from '../utils/agentOutput';
 
-const allowedDoctorArgs = new Set(['contracts', 'json', 'strict']);
+const allowedDoctorArgs = new Set(['contracts', 'full', 'human', 'json', 'strict']);
 
 const validateDoctorArgs = () => {
     const enabledArgs = Object.entries(cli.args)
@@ -20,6 +21,15 @@ const validateDoctorArgs = () => {
     }
 };
 
+const compactDiagnostic = (diagnostic: ReturnType<typeof buildDoctorResponse>['diagnostics'][number]) => ({
+    level: diagnostic.level,
+    code: diagnostic.code,
+    message: truncateForAgent(diagnostic.message),
+    filepath: diagnostic.filepath,
+    sourceLocation: diagnostic.sourceLocation,
+    fixHint: diagnostic.fixHint ? truncateForAgent(diagnostic.fixHint) : undefined,
+});
+
 export const run = async (): Promise<void> => {
     validateDoctorArgs();
 
@@ -32,9 +42,9 @@ export const run = async (): Promise<void> => {
             ? buildContractsDoctorResponse(manifest, cli.args.strict === true)
             : buildDoctorResponse(manifest, cli.args.strict === true);
 
-    if (cli.args.json === true) {
-        console.log(JSON.stringify(response, null, 2));
-    } else {
+    if (cli.args.full === true) {
+        printJson(response);
+    } else if (cli.args.human === true) {
         console.log(
             cli.args.contracts === true
                 ? renderDoctorResponseHuman({
@@ -45,6 +55,16 @@ export const run = async (): Promise<void> => {
                   })
                 : renderDoctorHuman(manifest, cli.args.strict === true),
         );
+    } else {
+        printAgentResponse({
+            summary: `${cli.args.contracts === true ? 'Doctor contracts' : 'Doctor'}: ${response.summary.errors} errors, ${response.summary.warnings} warnings`,
+            data: {
+                summary: response.summary,
+                diagnostics: compactList(response.diagnostics, 10).map(compactDiagnostic),
+                totalDiagnostics: response.diagnostics.length,
+            },
+            fullDetailCommand: `proteum doctor${cli.args.contracts === true ? ' --contracts' : ''} --full`,
+        });
     }
 
     if (cli.args.strict === true && response.diagnostics.length > 0) {

package/cli/commands/explain.ts

@@ -2,14 +2,16 @@ import cli from '..';
 import Compiler from '../compiler';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
 import {
+    buildExplainSummaryItems,
     explainSectionNames,
     pickExplainManifestSections,
     renderExplainHuman,
     type TExplainSectionName,
 } from '@common/dev/diagnostics';
 import { explainOwner } from '@common/dev/inspection';
+import { compactList, printAgentResponse, printJson, quoteCommandArgument } from '../utils/agentOutput';
 
-const allowedExplainArgs = new Set(['json', 'all', ...explainSectionNames]);
+const allowedExplainArgs = new Set(['json', 'all', 'full', 'human', 'manifest', ...explainSectionNames]);
 
 const validateExplainArgs = () => {
     const enabledArgs = Object.entries(cli.args)
@@ -31,6 +33,93 @@ const getSelectedSections = (): TExplainSectionName[] => {
     return explainSectionNames.filter((sectionName) => cli.args[sectionName] === true);
 };
 
+const compactOwnerMatch = (match: ReturnType<typeof explainOwner>['matches'][number]) => ({
+    kind: match.kind,
+    label: match.label,
+    score: match.score,
+    scope: match.scopeLabel,
+    origin: match.originHint,
+    source: match.source,
+});
+
+const hasExplicitDetailSelection = (selectedSections: TExplainSectionName[]) =>
+    cli.args.full === true || cli.args.manifest === true || cli.args.all === true || selectedSections.length > 0;
+
+const printCompactOwner = (ownerQuery: string, response: ReturnType<typeof explainOwner>) => {
+    const topOwner = response.matches[0];
+
+    printAgentResponse({
+        summary: topOwner
+            ? `${ownerQuery} -> ${topOwner.kind} ${topOwner.label} (${topOwner.scopeLabel})`
+            : `${ownerQuery} -> no manifest owner matched`,
+        data: {
+            query: ownerQuery,
+            normalizedQuery: response.normalizedQuery,
+            top: topOwner ? compactOwnerMatch(topOwner) : undefined,
+            matches: compactList(response.matches, 6).map(compactOwnerMatch),
+            totalReturned: response.matches.length,
+        },
+        nextActions: [
+            {
+                label: 'Orient',
+                command: `proteum orient ${quoteCommandArgument(ownerQuery)}`,
+                reason: 'Resolve the owner together with the relevant instruction files and next command.',
+            },
+        ],
+        fullDetailCommand: `proteum explain owner ${quoteCommandArgument(ownerQuery)} --full`,
+    });
+};
+
+const printCompactExplain = (manifest: ReturnType<typeof readProteumManifest>) => {
+    const errors = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'error').length;
+    const warnings = manifest.diagnostics.filter((diagnostic) => diagnostic.level === 'warning').length;
+    const requiredEnvProvided = manifest.env.requiredVariables.filter((variable) => variable.provided).length;
+
+    printAgentResponse({
+        summary: `${manifest.app.identity.identifier}: ${manifest.controllers.length} controllers, ${manifest.routes.client.length + manifest.routes.server.length} routes, ${errors} errors, ${warnings} warnings`,
+        data: {
+            app: {
+                root: manifest.app.root,
+                coreRoot: manifest.app.coreRoot,
+                identifier: manifest.app.identity.identifier,
+                name: manifest.app.identity.name,
+            },
+            counts: {
+                commands: manifest.commands.length,
+                connectedProjects: manifest.connectedProjects.length,
+                controllers: manifest.controllers.length,
+                diagnostics: manifest.diagnostics.length,
+                layouts: manifest.layouts.length,
+                routesClient: manifest.routes.client.length,
+                routesServer: manifest.routes.server.length,
+                servicesApp: manifest.services.app.length,
+                servicesRouterPlugins: manifest.services.routerPlugins.length,
+            },
+            diagnostics: { errors, warnings },
+            env: {
+                requiredProvided: requiredEnvProvided,
+                requiredTotal: manifest.env.requiredVariables.length,
+                routerPort: manifest.env.resolved.routerPort,
+            },
+            summaryItems: buildExplainSummaryItems(manifest),
+        },
+        nextActions: [
+            {
+                label: 'Orient Target',
+                command: 'proteum orient <route|file|controller|error>',
+                reason: 'Use orient for task-specific owner, instruction, and next-command routing.',
+            },
+        ],
+        fullDetailCommand: 'proteum explain --manifest',
+        omitted: [
+            {
+                reason: 'Full manifest sections are omitted from the default agent summary.',
+                command: 'proteum explain --manifest',
+            },
+        ],
+    });
+};
+
 export const run = async (): Promise<void> => {
     validateExplainArgs();
 
@@ -42,8 +131,13 @@ export const run = async (): Promise<void> => {
 
     if (ownerQuery) {
         const response = explainOwner(manifest, ownerQuery);
-        if (cli.args.json === true) {
-            console.log(JSON.stringify(response, null, 2));
+        if (cli.args.full === true || cli.args.manifest === true) {
+            printJson(response);
+            return;
+        }
+
+        if (cli.args.human !== true) {
+            printCompactOwner(ownerQuery, response);
             return;
         }
 
@@ -64,10 +158,15 @@ export const run = async (): Promise<void> => {
 
     const selectedSections = getSelectedSections();
 
-    if (cli.args.json === true) {
-        console.log(JSON.stringify(pickExplainManifestSections(manifest, selectedSections), null, 2));
+    if (hasExplicitDetailSelection(selectedSections)) {
+        printJson(pickExplainManifestSections(manifest, cli.args.manifest === true ? [...explainSectionNames] : selectedSections));
+        return;
+    }
+
+    if (cli.args.human === true) {
+        console.log(renderExplainHuman(manifest, selectedSections));
         return;
     }
 
-    console.log(renderExplainHuman(manifest, selectedSections));
+    printCompactExplain(manifest);
 };

package/cli/commands/mcp.ts

@@ -0,0 +1,16 @@
+import cli from '..';
+import { CliProteumMcpProvider } from '../mcp/provider';
+import { startProteumMcpStdioServer } from '../mcp/stdio';
+
+export const run = async () => {
+    const provider = new CliProteumMcpProvider({
+        appRoot: cli.paths.appRoot,
+        sessionFilePath: typeof cli.args.sessionFile === 'string' && cli.args.sessionFile ? cli.args.sessionFile : undefined,
+        url: typeof cli.args.url === 'string' && cli.args.url ? cli.args.url : undefined,
+    });
+
+    await startProteumMcpStdioServer({
+        provider,
+        version: String(cli.packageJson.version || ''),
+    });
+};

package/cli/commands/orient.ts

@@ -8,6 +8,7 @@ import Compiler from '../compiler';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
 import { buildOrientationResponse, type TOrientResponse } from '@common/dev/inspection';
 import type { TProteumManifest } from '@common/dev/proteumManifest';
+import { compactList, printAgentResponse, printJson, quoteCommandArgument } from '../utils/agentOutput';
 
 const normalizeBaseUrl = (value: string) => value.replace(/\/+$/, '');
 const dedupe = <TValue>(values: TValue[]) => [...new Set(values)];
@@ -153,6 +154,63 @@ const renderHuman = (response: TOrientResponse) =>
         ...(response.warnings.length === 0 ? ['- none'] : response.warnings.map((warning) => `- ${warning}`)),
     ].join('\n');
 
+const compactOwnerMatch = (match: TOrientResponse['owner']['matches'][number]) => ({
+    kind: match.kind,
+    label: match.label,
+    score: match.score,
+    scope: match.scopeLabel,
+    origin: match.originHint,
+    source: match.source,
+});
+
+const buildInstructionPlan = (response: TOrientResponse) => ({
+    mustRead: [...new Set([response.guidance.agents, ...response.guidance.areaAgents])],
+    readWhen: [
+        {
+            file: response.guidance.diagnostics,
+            when: 'Read only for raw errors, failing requests, traces, perf regressions, or reproduction work.',
+        },
+        {
+            file: response.guidance.codingStyle,
+            when: 'Read before editing implementation files.',
+        },
+        {
+            file: response.guidance.optimizations,
+            when: 'Read after client-side implementation or when the task explicitly concerns packages, build, runtime, or performance.',
+        },
+    ],
+});
+
+const printCompactOrient = (response: TOrientResponse) => {
+    const topOwner = response.owner.matches[0];
+    const summary = topOwner
+        ? `${response.query} -> ${topOwner.kind} ${topOwner.label} (${topOwner.scopeLabel})`
+        : `${response.query} -> no manifest owner matched`;
+
+    printAgentResponse({
+        summary,
+        data: {
+            query: response.query,
+            app: response.app,
+            owner: {
+                top: topOwner ? compactOwnerMatch(topOwner) : undefined,
+                matches: compactList(response.owner.matches, 4).map(compactOwnerMatch),
+                totalReturned: response.owner.matches.length,
+            },
+            instructions: buildInstructionPlan(response),
+            connected: {
+                imports: compactList(response.connected.imports, 4),
+                producers: compactList(response.connected.producers, 3),
+                totalImports: response.connected.imports.length,
+                totalProducers: response.connected.producers.length,
+            },
+            warnings: response.warnings,
+        },
+        nextActions: response.nextSteps,
+        fullDetailCommand: `proteum orient ${quoteCommandArgument(response.query)} --full`,
+    });
+};
+
 export const run = async () => {
     const query = typeof cli.args.query === 'string' ? cli.args.query.trim() : '';
     if (!query) throw new UsageError('A query is required. Example: proteum orient /api/Auth/CurrentUser');
@@ -160,10 +218,15 @@ export const run = async () => {
     const manifest = await resolveManifest();
     const response = buildOrientationResponse(manifest, query);
 
-    if (cli.args.json === true) {
-        console.log(JSON.stringify(response, null, 2));
+    if (cli.args.full === true) {
+        printJson(response);
+        return;
+    }
+
+    if (cli.args.human === true) {
+        console.log(renderHuman(response));
         return;
     }
 
-    console.log(renderHuman(response));
+    printCompactOrient(response);
 };

package/cli/commands/perf.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import { UsageError } from 'clipanion';
 
 import cli from '..';
+import { compactList, printAgentResponse, printJson, quoteCommandArgument, truncateForAgent } from '../utils/agentOutput';
 import type {
     TPerfCompareResponse,
     TPerfMemoryResponse,
@@ -102,10 +103,6 @@ const requestJson = async <TResponse>(pathname: string) => {
     );
 };
 
-const printJson = (value: object) => {
-    console.log(JSON.stringify(value, null, 2));
-};
-
 const renderWindow = (label: string, value: { startedAt: string; finishedAt: string; requestCount: number; availableRequestCount: number }) =>
     `${label}=${value.requestCount}/${value.availableRequestCount} traces ${value.startedAt}..${value.finishedAt}`;
 
@@ -180,9 +177,113 @@ const renderRequest = (response: TPerfRequestResponse) =>
               )),
     ].join('\n');
 
+const compactTopLikeRow = (row: TPerfTopResponse['rows'][number]) => ({
+    label: row.label,
+    requestCount: row.requestCount,
+    avgDurationMs: row.avgDurationMs,
+    p95DurationMs: row.p95DurationMs,
+    maxDurationMs: row.maxDurationMs,
+    avgCpuMs: row.avgCpuMs,
+    avgSqlDurationMs: row.avgSqlDurationMs,
+    avgRenderDurationMs: row.avgRenderDurationMs,
+    avgHeapDeltaBytes: row.avgHeapDeltaBytes,
+    slowestRequestId: row.slowestRequestId,
+});
+
+const compactSql = (query: TPerfRequestResponse['request']['hottestSqlQueries'][number]) => ({
+    callerLabel: query.callerLabel,
+    operation: query.operation,
+    model: query.model,
+    fingerprint: query.fingerprint,
+    durationMs: query.durationMs,
+    query: truncateForAgent(query.query, 140),
+});
+
+const printCompactTop = (response: TPerfTopResponse) => {
+    printAgentResponse({
+        summary: `Perf top ${response.groupBy}: ${response.summary.requestCount} requests, ${response.summary.errorCount} errors, p95=${formatDuration(response.summary.p95DurationMs)}`,
+        data: {
+            groupBy: response.groupBy,
+            window: response.window,
+            summary: response.summary,
+            rows: compactList(response.rows, 8).map(compactTopLikeRow),
+            totalRows: response.rows.length,
+        },
+        fullDetailCommand: 'proteum perf top --full',
+    });
+};
+
+const printCompactCompare = (response: TPerfCompareResponse) => {
+    printAgentResponse({
+        summary: `Perf compare ${response.groupBy}: ${response.rows.length} rows`,
+        data: {
+            groupBy: response.groupBy,
+            baseline: response.baseline,
+            target: response.target,
+            rows: compactList(response.rows, 8),
+            totalRows: response.rows.length,
+        },
+        fullDetailCommand: 'proteum perf compare --full',
+    });
+};
+
+const printCompactMemory = (response: TPerfMemoryResponse) => {
+    printAgentResponse({
+        summary: `Perf memory ${response.groupBy}: ${response.rows.length} rows`,
+        data: {
+            groupBy: response.groupBy,
+            window: response.window,
+            rows: compactList(response.rows, 8),
+            totalRows: response.rows.length,
+        },
+        fullDetailCommand: 'proteum perf memory --full',
+    });
+};
+
+const printCompactRequest = (response: TPerfRequestResponse) => {
+    printAgentResponse({
+        summary: `${response.request.requestId}: ${response.request.method} ${response.request.path} total=${formatDuration(response.request.totalDurationMs)} cpu=${formatDuration(response.request.cpuTotalMs)} sql=${formatDuration(response.request.sqlDurationMs)}`,
+        data: {
+            request: {
+                requestId: response.request.requestId,
+                method: response.request.method,
+                path: response.request.path,
+                statusCode: response.request.statusCode,
+                routeLabel: response.request.routeLabel,
+                controllerLabel: response.request.controllerLabel,
+                totalDurationMs: response.request.totalDurationMs,
+                cpuTotalMs: response.request.cpuTotalMs,
+                sqlDurationMs: response.request.sqlDurationMs,
+                callDurationMs: response.request.callDurationMs,
+                renderDurationMs: response.request.renderDurationMs,
+                selfDurationMs: response.request.selfDurationMs,
+                heapDeltaBytes: response.request.heapDeltaBytes,
+            },
+            stages: compactList(response.request.stages, 8),
+            hotCalls: compactList(response.request.hottestCalls, 6),
+            chain: compactList(response.request.chain || [], 8),
+            hotSql: compactList(response.request.hottestSqlQueries, 6).map(compactSql),
+        },
+        nextActions: [
+            {
+                label: 'Diagnose Request',
+                command: `proteum diagnose ${quoteCommandArgument(response.request.path)}`,
+                reason: 'Combine this request with owner, diagnostics, suspects, and logs.',
+            },
+            {
+                label: 'Trace Events',
+                command: `proteum trace show ${quoteCommandArgument(response.request.requestId)} --events`,
+                reason: 'Open raw event detail only if the compact waterfall is insufficient.',
+            },
+        ],
+        fullDetailCommand: `proteum perf request ${quoteCommandArgument(response.request.requestId)} --full`,
+    });
+};
+
 export const run = async () => {
     const action = getAction();
-    const shouldPrintJson = cli.args.json === true;
+    const shouldPrintFull = cli.args.full === true;
+    const shouldPrintHuman = cli.args.human === true;
     const groupBy = typeof cli.args.groupBy === 'string' && cli.args.groupBy ? cli.args.groupBy : 'path';
     const limit =
         typeof cli.args.limit === 'string' && cli.args.limit ? Math.max(1, Number.parseInt(cli.args.limit, 10) || 12) : 12;
@@ -192,12 +293,13 @@ export const run = async () => {
         const response = await requestJson<TPerfTopResponse>(
             `/__proteum/perf/top?${new URLSearchParams({ groupBy, limit: String(limit), since }).toString()}`,
         );
-        if (shouldPrintJson) {
+        if (shouldPrintFull) {
             printJson(response);
             return;
         }
 
-        console.log(renderTop(response));
+        if (shouldPrintHuman) console.log(renderTop(response));
+        else printCompactTop(response);
         return;
     }
 
@@ -212,12 +314,13 @@ export const run = async () => {
                 target: targetWindow,
             }).toString()}`,
         );
-        if (shouldPrintJson) {
+        if (shouldPrintFull) {
             printJson(response);
             return;
         }
 
-        console.log(renderCompare(response));
+        if (shouldPrintHuman) console.log(renderCompare(response));
+        else printCompactCompare(response);
         return;
     }
 
@@ -226,12 +329,13 @@ export const run = async () => {
         const response = await requestJson<TPerfMemoryResponse>(
             `/__proteum/perf/memory?${new URLSearchParams({ groupBy, limit: String(limit), since }).toString()}`,
         );
-        if (shouldPrintJson) {
+        if (shouldPrintFull) {
             printJson(response);
             return;
         }
 
-        console.log(renderMemory(response));
+        if (shouldPrintHuman) console.log(renderMemory(response));
+        else printCompactMemory(response);
         return;
     }
 
@@ -241,10 +345,11 @@ export const run = async () => {
     const response = await requestJson<TPerfRequestResponse>(
         `/__proteum/perf/request?${new URLSearchParams({ query: requestTarget }).toString()}`,
     );
-    if (shouldPrintJson) {
+    if (shouldPrintFull) {
         printJson(response);
         return;
     }
 
-    console.log(renderRequest(response));
+    if (shouldPrintHuman) console.log(renderRequest(response));
+    else printCompactRequest(response);
 };