knip 6.23.0 → 6.25.0

package/dist/plugins/stencil/index.js

@@ -1,6 +1,10 @@
+import { Visitor } from 'oxc-parser';
+import scss from '../../compilers/scss.js';
+import { IMPORT_FLAGS } from '../../constants.js';
 import { toConfig, toEntry, toProductionEntry } from '../../util/input.js';
+import { dirname, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { collectPropertyValues, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
 const title = 'Stencil';
 const enablers = ['@stencil/core'];
@@ -9,8 +13,49 @@ const config = ['stencil.config.{ts,js}'];
 const production = ['src/**/*.tsx'];
 const entry = ['**/*.spec.{ts,tsx}', '**/*.e2e.{ts,tsx}'];
 const isStencilSpecifier = (specifier) => specifier === '@stencil/core';
+const registerCompilers = ({ hasDependency, registerCompiler }) => {
+    if (hasDependency('@stencil/sass'))
+        for (const ext of ['.scss', '.sass'])
+            registerCompiler({ extension: ext, compiler: scss.compiler });
+};
 const registerVisitors = ({ ctx, registerVisitor }) => {
     registerVisitor(createCustomElementVisitor(ctx, isStencilSpecifier, { decoratorName: 'Component' }));
+    const componentNames = new Set();
+    registerVisitor({
+        Program() {
+            componentNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!isStencilSpecifier(node.source?.value))
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportSpecifier' &&
+                    spec.imported.type === 'Identifier' &&
+                    spec.imported.name === 'Component')
+                    componentNames.add(spec.local.name);
+            }
+        },
+        ClassDeclaration(node) {
+            resolveStyleUrls(node);
+        },
+    });
+    function resolveStyleUrls(node) {
+        const dir = dirname(ctx.filePath);
+        for (const decorator of node.decorators ?? []) {
+            const expr = decorator.expression;
+            if (expr?.type !== 'CallExpression')
+                continue;
+            if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
+                continue;
+            const arg = expr.arguments?.[0];
+            if (arg?.type !== 'ObjectExpression')
+                continue;
+            for (const url of getPropertyValues(arg, 'styleUrl'))
+                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+            for (const url of getPropertyValues(arg, 'styleUrls'))
+                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+        }
+    }
 };
 const resolveFromAST = program => {
     const inputs = [];
@@ -22,6 +67,18 @@ const resolveFromAST = program => {
     for (const script of collectPropertyValues(program, 'globalScript')) {
         inputs.push(toProductionEntry(script));
     }
+    for (const style of collectPropertyValues(program, 'globalStyle')) {
+        inputs.push(toProductionEntry(style));
+    }
+    new Visitor({
+        ObjectExpression(node) {
+            const typeValues = getPropertyValues(node, 'type');
+            if (!typeValues.has('global-style'))
+                return;
+            for (const input of getPropertyValues(node, 'input'))
+                inputs.push(toProductionEntry(input));
+        },
+    }).visit(program);
     for (const tsconfig of collectPropertyValues(program, 'tsconfig')) {
         inputs.push(toConfig('typescript', tsconfig));
     }
@@ -41,6 +98,7 @@ const plugin = {
     entry,
     production,
     resolveFromAST,
+    registerCompilers,
     registerVisitors,
 };
 export default plugin;

package/dist/plugins/storybook/index.js

@@ -1,3 +1,4 @@
+import MDX from '../../compilers/mdx.js';
 import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
 import { join, relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
@@ -54,6 +55,11 @@ const resolveConfig = async (localConfig, options) => {
         ...configs,
     ];
 };
+const registerCompilers = ({ registerCompiler, hasDependency }) => {
+    if (hasDependency('@storybook/addon-docs') || hasDependency('@storybook/addon-essentials')) {
+        registerCompiler({ extension: '.mdx', compiler: MDX.compiler });
+    }
+};
 const plugin = {
     title,
     enablers,
@@ -62,5 +68,6 @@ const plugin = {
     entry,
     project,
     resolveConfig,
+    registerCompilers,
 };
 export default plugin;

package/dist/plugins/svelte/compiler.d.ts

@@ -1,2 +1,3 @@
-declare const compiler: import("../../compilers/types.ts").CompilerSync;
+import type { CompilerSync } from '../../compilers/types.ts';
+declare const compiler: CompilerSync;
 export default compiler;

package/dist/plugins/svelte/compiler.js

@@ -1,3 +1,10 @@
 import { importsWithinScripts } from '../../compilers/compilers.js';
-const compiler = importsWithinScripts;
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+const compiler = (text, path) => {
+    const scripts = importsWithinScripts(text, path);
+    const styles = stylePreprocessorImports(text, path);
+    if (!scripts)
+        return styles;
+    return styles ? `${scripts};\n${styles}` : scripts;
+};
 export default compiler;

package/dist/plugins/tailwind/compiler.js

@@ -1,8 +1,11 @@
 const directiveMatcher = /@(?:import|config|plugin)\s+['"]([^'"]+)['"][^;]*;/g;
 const compiler = (text) => {
+    if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin'))
+        return '';
     const imports = [];
     let match;
     let index = 0;
+    directiveMatcher.lastIndex = 0;
     while ((match = directiveMatcher.exec(text)))
         if (match[1])
             imports.push(`import _$${index++} from '${match[1]}';`);

package/dist/plugins/tailwind/index.js

@@ -5,8 +5,12 @@ const enablers = ['tailwindcss', '@tailwindcss/vite', '@tailwindcss/postcss', '@
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts,cts,mts}'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
-    if (enablers.some(enabler => hasDependency(enabler)))
+    for (const enabler of enablers) {
+        if (!hasDependency(enabler))
+            continue;
         registerCompiler({ extension: '.css', compiler });
+        break;
+    }
 };
 const plugin = {
     title,

package/dist/plugins/typedoc/index.js

@@ -1,4 +1,5 @@
-import { toDeferResolve } from '../../util/input.js';
+import { toDeferResolve, toEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 const title = 'TypeDoc';
 const enablers = ['typedoc'];
@@ -12,11 +13,16 @@ const config = [
     'package.json',
     'tsconfig.json',
 ];
-const resolveConfig = config => {
+const resolveConfig = (config, options) => {
     const cfg = 'typedocOptions' in config ? config.typedocOptions : config;
     const plugins = cfg?.plugin ?? [];
     const themes = cfg?.theme ?? [];
-    return [...plugins, ...themes].map(id => toDeferResolve(id));
+    const inputs = [...plugins, ...themes].map(id => toDeferResolve(id));
+    for (const file of [cfg?.customCss, cfg?.customJs]) {
+        if (file)
+            inputs.push(toEntry(join(options.configFileDir, file)));
+    }
+    return inputs;
 };
 const args = {
     resolve: ['plugin', 'theme'],

package/dist/plugins/typedoc/types.d.ts

@@ -1,4 +1,6 @@
 export type TypeDocConfig = {
     plugin?: string[];
     theme?: string[];
+    customCss?: string;
+    customJs?: string;
 };

package/dist/plugins/vite/visitors/importMetaGlob.js

@@ -1,6 +1,3 @@
-import { IMPORT_FLAGS } from '../../../constants.js';
-import { _syncGlob } from '../../../util/glob.js';
-import { dirname, isAbsolute, join } from '../../../util/path.js';
 import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 export function createImportMetaGlobVisitor(ctx) {
     return {
@@ -25,11 +22,7 @@ export function createImportMetaGlobVisitor(ctx) {
             }
             if (!patterns?.length)
                 return;
-            const dir = dirname(ctx.filePath);
-            const files = _syncGlob({ patterns, cwd: dir });
-            for (const f of files) {
-                ctx.addImport(isAbsolute(f) ? f : join(dir, f), arg.start, IMPORT_FLAGS.ENTRY);
-            }
+            ctx.addImportGlob(patterns);
         },
     };
 }

package/dist/plugins/vue/compiler.d.ts

@@ -1,2 +1,3 @@
-declare const compiler: import("../../compilers/types.ts").CompilerSync;
+import type { CompilerSync } from '../../compilers/types.ts';
+declare const compiler: CompilerSync;
 export default compiler;

package/dist/plugins/vue/compiler.js

@@ -1,3 +1,10 @@
 import { scriptBodies } from '../../compilers/compilers.js';
-const compiler = scriptBodies;
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+const compiler = (text, path) => {
+    const scripts = scriptBodies(text, path);
+    const styles = stylePreprocessorImports(text, path);
+    if (!scripts)
+        return styles;
+    return styles ? `${scripts};\n${styles}` : scripts;
+};
 export default compiler;

package/dist/plugins/webpack/visitors/requireContext.js

@@ -1,6 +1,3 @@
-import { IMPORT_FLAGS } from '../../../constants.js';
-import { _syncGlob } from '../../../util/glob.js';
-import { dirname, join, toRelative } from '../../../util/path.js';
 import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
 export function createRequireContextVisitor(ctx) {
     return {
@@ -17,16 +14,8 @@ export function createRequireContextVisitor(ctx) {
             const arg1 = node.arguments[1];
             const recursive = !(arg1?.type === 'Literal' && 'value' in arg1 && arg1.value === false);
             const regexArg = node.arguments[2];
-            const dir = dirname(ctx.filePath);
-            const baseDir = join(dir, dirArg);
-            const pattern = recursive ? '**/*' : '*';
-            const files = _syncGlob({ patterns: [pattern], cwd: baseDir });
-            const regex = regexArg && 'regex' in regexArg ? new RegExp(regexArg.regex.pattern, regexArg.regex.flags) : undefined;
-            for (const f of files) {
-                if (!regex || regex.test(`./${toRelative(f, baseDir)}`)) {
-                    ctx.addImport(f, node.arguments[0].start, IMPORT_FLAGS.ENTRY);
-                }
-            }
+            const filter = regexArg && 'regex' in regexArg ? new RegExp(regexArg.regex.pattern, regexArg.regex.flags) : undefined;
+            ctx.addImportGlob([recursive ? '**/*' : '*'], { base: dirArg, filter });
         },
     };
 }

package/dist/plugins/yarn/index.js

@@ -1,13 +1,13 @@
 import { isFile } from '../../util/fs.js';
-import { toEntry } from '../../util/input.js';
+import { toDependency, toEntry } from '../../util/input.js';
 const title = 'Yarn';
-const enablers = 'This plugin is enabled when a `yarn.lock` file is found in the root folder.';
-const isEnabled = ({ cwd }) => isFile(cwd, 'yarn.lock');
+const enablers = 'This plugin is enabled when a `yarn.lock` file is found in the root directory, or when `yarn@` is specified in the `packageManager` field of `package.json`.';
+const isEnabled = async ({ cwd, manifest }) => manifest.packageManager?.startsWith('yarn@') || isFile(cwd, 'yarn.lock');
 const isRootOnly = true;
 const config = ['.yarnrc.yml'];
 const entry = ['yarn.config.cjs'];
 const resolveConfig = config => {
-    const inputs = entry.map(id => toEntry(id));
+    const inputs = entry.map(toEntry);
     if (Array.isArray(config.plugins)) {
         for (const plugin of config.plugins) {
             if (typeof plugin === 'string')
@@ -19,6 +19,15 @@ const resolveConfig = config => {
     if (config.yarnPath) {
         inputs.push(toEntry(config.yarnPath));
     }
+    if (config.packageExtensions) {
+        for (const extension of Object.values(config.packageExtensions)) {
+            if (extension.peerDependencies) {
+                for (const dep of Object.keys(extension.peerDependencies)) {
+                    inputs.push(toDependency(dep));
+                }
+            }
+        }
+    }
     return inputs;
 };
 const plugin = {

package/dist/plugins/yarn/types.d.ts

@@ -0,0 +1,10 @@
+import type { Dependencies } from '../../types/package-json.ts';
+export type YarnConfig = {
+    plugins?: Array<string | {
+        path?: string;
+    }>;
+    yarnPath?: string;
+    packageExtensions?: Record<string, {
+        peerDependencies?: Dependencies;
+    }>;
+};

package/dist/plugins/yarn/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/zx/visitors/zx.js

@@ -1,13 +1,13 @@
+import { getScriptFromTemplate } from '../../../typescript/ast-nodes.js';
 export function createZxVisitor(ctx) {
     return {
         TaggedTemplateExpression(node) {
             if (!ctx.sourceText.startsWith('#!/usr/bin/env zx'))
                 return;
             if (node.tag.type === 'Identifier' && node.tag.name === '$') {
-                for (const q of node.quasi.quasis) {
-                    if (q.value.raw)
-                        ctx.addScript(q.value.raw);
-                }
+                const script = getScriptFromTemplate(node.quasi);
+                if (script)
+                    ctx.addScript(script);
             }
         },
     };

package/dist/reporters/compact.js

@@ -5,11 +5,10 @@ const logIssueRecord = (issues, cwd) => {
         console.log(getIssueLine(issue, cwd));
 };
 export default ({ report, issues, isShowProgress, cwd }) => {
-    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
+            const title = getIssueTypeTitle(reportType);
             const issuesForType = reportType === 'duplicates'
                 ? flattenIssues(issues[reportType])
                 : Object.values(issues[reportType])

package/dist/reporters/cycles.d.ts

@@ -0,0 +1,3 @@
+import type { ReporterOptions } from '../types/issues.ts';
+export default _default;
+declare function _default({ cwd, issues, isShowProgress }: ReporterOptions): void;

package/dist/reporters/cycles.js

@@ -0,0 +1,79 @@
+import st from '../util/colors.js';
+import { relative } from '../util/path.js';
+import { flattenIssues, getColoredTitle, getIssueTypeTitle } from './util/util.js';
+const kindLabels = {
+    import: 'import',
+    importAs: 'aliased import',
+    importNS: 'namespace import',
+    reExport: 're-export',
+    reExportAs: 'aliased re-export',
+    reExportNS: 'namespace re-export',
+    reExportStar: 'star re-export',
+    dynamicImport: 'dynamic import',
+    sideEffectImport: 'side-effect import',
+};
+const formatEdge = (edge) => {
+    const kind = kindLabels[edge.kind ?? 'import'] ?? edge.kind ?? 'import';
+    const specifier = edge.specifier ? `${st.dim(' ')}${st.cyanBright(edge.specifier)}` : '';
+    return `${st.cyan(kind)}${specifier}${st.dim(' → ')}`;
+};
+const getLocation = (file) => {
+    const location = file.line === undefined ? '' : `:${file.line}${file.col === undefined ? '' : `:${file.col}`}`;
+    return `${file.symbol}${location}`;
+};
+const formatFile = (file) => st.white(getLocation(file));
+const getIssueRootLocation = (issue, cwd) => {
+    const root = issue.symbols?.[0];
+    return root ? getLocation(root) : relative(cwd, issue.filePath);
+};
+const sortByFilePath = (cwd) => (a, b) => {
+    const aFilePath = relative(cwd, a.filePath);
+    const bFilePath = relative(cwd, b.filePath);
+    const filePath = aFilePath.localeCompare(bFilePath);
+    if (filePath !== 0)
+        return filePath;
+    const rootLocation = getIssueRootLocation(a, cwd).localeCompare(getIssueRootLocation(b, cwd));
+    return rootLocation === 0 ? a.symbol.localeCompare(b.symbol) : rootLocation;
+};
+export default ({ cwd, issues, isShowProgress }) => {
+    const cycles = flattenIssues(issues.cycles).sort(sortByFilePath(cwd));
+    if (cycles.length === 0) {
+        if (isShowProgress)
+            console.log('✂️  No circular dependencies found.');
+        return;
+    }
+    console.log(getColoredTitle(getIssueTypeTitle('cycles'), cycles.length));
+    const rootCounts = new Map();
+    for (const issue of cycles) {
+        const files = issue.symbols ?? issue.symbol.split(' → ').map(symbol => ({ symbol }));
+        const root = files[0];
+        if (root) {
+            const rootLocation = getLocation(root);
+            rootCounts.set(rootLocation, (rootCounts.get(rootLocation) ?? 0) + 1);
+        }
+    }
+    let previousRoot = '';
+    for (const issue of cycles) {
+        const files = issue.symbols ?? issue.symbol.split(' → ').map(symbol => ({ symbol }));
+        const root = files[0];
+        if (!root)
+            continue;
+        const rootLocation = getLocation(root);
+        if (rootLocation !== previousRoot) {
+            const count = rootCounts.get(rootLocation) ?? 0;
+            const countLabel = count > 1 ? st.dim(` (${count} cycles)`) : '';
+            console.log(`\n${formatFile(root)}${countLabel}`);
+            previousRoot = rootLocation;
+        }
+        else {
+            console.log('');
+        }
+        for (let depth = 1; depth <= files.length; depth++) {
+            const isClose = depth === files.length;
+            const edge = files[depth - 1];
+            const file = isClose ? root : files[depth];
+            const connector = st.dim(`${'    '.repeat(depth - 1)}└── `);
+            console.log(`${connector}${formatEdge(edge)}${formatFile(file)}${isClose ? st.dim(' ↩') : ''}`);
+        }
+    }
+};

package/dist/reporters/index.d.ts

@@ -2,6 +2,7 @@ declare const _default: {
     symbols: (options: import("../types.ts").ReporterOptions) => void;
     compact: ({ report, issues, isShowProgress, cwd }: import("../types.ts").ReporterOptions) => void;
     codeowners: ({ report, issues, isShowProgress, options, cwd }: import("../types.ts").ReporterOptions) => void;
+    cycles: ({ cwd, issues, isShowProgress }: import("../types.ts").ReporterOptions) => void;
     disclosure: ({ report, issues, cwd }: import("../types.ts").ReporterOptions) => void;
     codeclimate: ({ report, issues, cwd }: import("../types.ts").ReporterOptions) => Promise<void>;
     json: ({ report, issues, options, cwd }: import("../types.ts").ReporterOptions) => Promise<void>;

package/dist/reporters/index.js

@@ -1,6 +1,7 @@
 import codeclimate from './codeclimate.js';
 import codeowners from './codeowners.js';
 import compact from './compact.js';
+import cycles from './cycles.js';
 import disclosure from './disclosure.js';
 import githubActions from './github-actions.js';
 import json from './json.js';
@@ -10,6 +11,7 @@ export default {
     symbols,
     compact,
     codeowners,
+    cycles,
     disclosure,
     codeclimate,
     json,

package/dist/reporters/json.d.ts

@@ -4,6 +4,8 @@ export interface JSONReportNamedItem {
 }
 export interface JSONReportItem extends JSONReportNamedItem {
     namespace?: string;
+    kind?: string;
+    specifier?: string;
     pos?: number;
     line?: number;
     col?: number;
@@ -13,6 +15,7 @@ export type JSONReportEntry = {
     owners?: Array<JSONReportNamedItem>;
     binaries?: Array<JSONReportNamedItem>;
     catalog?: Array<JSONReportItem>;
+    cycles?: Array<Array<JSONReportItem>>;
     dependencies?: Array<JSONReportItem>;
     devDependencies?: Array<JSONReportItem>;
     duplicates?: Array<Array<JSONReportItem>>;

package/dist/reporters/json.js

@@ -20,6 +20,7 @@ export default async ({ report, issues, options, cwd }) => {
             ...(findOwners && { owners: findOwners(file).map(name => ({ name })) }),
             ...(report.binaries && { binaries: [] }),
             ...(report.catalog && { catalog: [] }),
+            ...(report.cycles && { cycles: [] }),
             ...(report.dependencies && { dependencies: [] }),
             ...(report.devDependencies && { devDependencies: [] }),
             ...(report.duplicates && { duplicates: [] }),
@@ -41,7 +42,7 @@ export default async ({ report, issues, options, cwd }) => {
             for (const issue of flattenIssues(issues[type])) {
                 const { filePath, symbol, symbols } = issue;
                 json[filePath] = json[filePath] ?? initRow(filePath);
-                if (type === 'duplicates') {
+                if (type === 'duplicates' || type === 'cycles') {
                     symbols && json[filePath][type]?.push(symbols.map(convert));
                 }
                 else if (type === 'binaries') {

package/dist/reporters/symbols.js

@@ -2,11 +2,10 @@ import { printConfigurationHints, printTagHints } from './util/configuration-hin
 import { dim, flattenIssues, getColoredTitle, getIssueTypeTitle, getTableForType } from './util/util.js';
 export default (options) => {
     const { report, issues, isDisableConfigHints, isDisableTagHints, isShowProgress } = options;
-    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
+            const title = getIssueTypeTitle(reportType);
             const issuesForType = flattenIssues(issues[reportType]);
             if (issuesForType.length > 0) {
                 title && console.log(getColoredTitle(title, issuesForType.length));

package/dist/reporters/util/util.d.ts

@@ -3,7 +3,7 @@ import type { Issue, IssueRecords, IssueSeverity, IssueSymbol, IssueType } from
 import { Table } from '../../util/table.ts';
 export declare const dim: (text: string | number | null | undefined) => string;
 export declare const bright: (text: string | number | null | undefined) => string;
-export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => "Duplicate exports" | "Exported types in used namespace" | "Exports in used namespace" | "Referenced optional peerDependencies" | "Unlisted binaries" | "Unlisted dependencies" | "Unresolved imports" | "Unused catalog entries" | "Unused dependencies" | "Unused devDependencies" | "Unused exported enum members" | "Unused exported namespace members" | "Unused exported types" | "Unused exports" | "Unused files";
+export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => "Circular dependencies" | "Duplicate exports" | "Exported types in used namespace" | "Exports in used namespace" | "Referenced optional peerDependencies" | "Unlisted binaries" | "Unlisted dependencies" | "Unresolved imports" | "Unused catalog entries" | "Unused dependencies" | "Unused devDependencies" | "Unused exported enum members" | "Unused exported namespace members" | "Unused exported types" | "Unused exports" | "Unused files";
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;
 type LogIssueLine = {
@@ -17,6 +17,8 @@ export declare const getIssueLine: ({ owner, filePath, symbols, parentSymbol, se
 export declare const convert: (issue: Issue | IssueSymbol) => {
     namespace: string | undefined;
     name: string;
+    kind: string | undefined;
+    specifier: string | undefined;
     line: number | undefined;
     col: number | undefined;
     pos: number | undefined;

package/dist/reporters/util/util.js

@@ -17,6 +17,8 @@ export const getIssueLine = ({ owner, filePath, symbols, parentSymbol, severity
 export const convert = (issue) => ({
     namespace: 'parentSymbol' in issue ? issue.parentSymbol : undefined,
     name: issue.symbol,
+    kind: 'kind' in issue ? issue.kind : undefined,
+    specifier: 'kind' in issue ? issue.specifier : undefined,
     line: issue.line,
     col: issue.col,
     pos: issue.pos,
@@ -44,7 +46,9 @@ export const getTableForType = (issues, cwd, options = { isUseColors: true }) =>
         table.row();
         const print = options.isUseColors && (issue.isFixed || issue.severity === 'warn') ? dim : plain;
         const isFileIssue = issue.type === 'files';
-        const symbol = issue.symbols ? issue.symbols.map(s => s.symbol).join(', ') : issue.symbol;
+        const symbol = issue.symbols
+            ? issue.symbols.map(s => s.symbol).join(issue.type === 'cycles' ? ' → ' : ', ')
+            : issue.symbol;
         if (!isFileIssue)
             table.cell('symbol', print(symbol), options.isUseColors ? highlightSymbol(issue) : () => symbol);
         table.cell('parentSymbol', issue.parentSymbol && print(issue.parentSymbol));