dev module detect-dependencies

Automatically detect runtime dependencies from source code

Command version: 0.0.0
Command configuration: dev-tool:dev.module.detect-dependencies@0.0.0

Arguments

Argument	Type	Required	Default	Description
`--validate`, `--no-validate`	`boolean`	No	`false`	Validate detected dependencies against declared dependencies (dependencies + devDependencies + testDependencies)
`--out`	`string`	No		Optional path for detected dependency graph output. Relative paths are resolved from --repo-root.
`--format`	`string` one of `dot`	No	`"dot"`	Detected dependency graph output format (default: dot)
`--group-by`	`string` one of `type`, `module`	No	`"type"`	Group the dependency listing by dependency type or by module (default: type)
`--exclude-tests`, `--no-exclude-tests`	`boolean`	No	`false`	Exclude test-only dependency analysis/output (detectedTestDependencies and test dependency validation)
`--hide-submodule-dependencies`, `--no-hide-submodule-dependencies`	`boolean`	No	`false`	Hide dependencies that target descendant submodules of the same module in response output and DOT export
`--recurse`, `--no-recurse`	`boolean`	No	`false`	Validate every repository this one pins as well, each in its own checkout by its own manifest and what it vendored -- what its own gate reads standing alone -- and the adapter checkout a tracked adapter catalog pins among them. A run from a tree's root otherwise reads the root's manifest, and can pass a manifest the repository holding it would refuse. Refused without `--validate`

It also takes the global arguments.

Output

It answers with a detect_dependencies.detectedDependenciesResult.

Types

`detect_dependencies.detectedDependenciesResult`

Field	Type	Required	Default	Description
`isComplete`	`boolean`	Yes		Whether every module was analysed; `false` where `skippedModules` names any, which fails the run as `DETECTED_DEPENDENCY_DISCOVERY_FAILED`
`moduleCount`	`integer`	Yes		How many modules there were to analyse: those of the manifest and of every repository in the tree that declares its own packages
`analyzedModuleCount`	`integer`	Yes		How many of those modules were analysed
`detectedDependencies`	`list[detect_dependencies.DetectedDependencyEntry]`	No	`[]`	The runtime dependencies found in each module's source, one entry per analysed module
`detectedBuildDependencies`	`list[detect_dependencies.DetectedDependencyEntry]`	No	`[]`	The build dependencies found for each module: what its schema documents and other documents reference a schema of
`detectedDevDependencies`	`list[detect_dependencies.DetectedDependencyEntry]`	No	`[]`	What each module's source reaches for development alone, such as an import made only for type checking, and does not reach at runtime
`detectedTestDependencies`	`list[detect_dependencies.DetectedDependencyEntry]`	No	`[]`	What each module's test files reach and the rest of its source does not. Empty under `--exclude-tests`
`skippedModules`	`list[detect_dependencies.SkippedModuleEntry]`	No	`[]`	Each module that could not be analysed, and why
`crossModulePathReferences`	`list[detect_dependencies.CrossModulePathReference]`	No	`[]`	Each schema reference written as a path that reaches a module outside the referencing document's own module tree. Such a reference is to be written by coordinate, and any entry here fails `--validate`
`dependencyDelivery`	`list[detect_dependencies.DependencyDeliveryEntry]`	No	`[]`	How the repository declaring each coordinate edge obtains the package it names: vendored from a build catalog, vendored as a schema, taken from a path by the language's package manager, or delivered by none of its own declarations. A path is build and deployment coupling a vendored package does not have. Reported, never validated.
`validated`	`boolean`	Yes		Whether `--validate` was given, so that what was detected was compared with what the modules declare
`excludeTests`	`boolean`	Yes		Whether `--exclude-tests` was given, which leaves test dependencies out of the detection and of the validation
`hideSubmoduleDependencies`	`boolean`	Yes		Whether `--hide-submodule-dependencies` was given, which leaves out each edge between a module and one nested under it or enclosing it
`groupBy`	`enum` one of `type`, `module`	No	`"type"`	How the human-readable listing is grouped, as `--group-by` gave it: by kind of dependency or by module
`outputPath`	`string`	No		The graph file the run wrote, as an absolute path; absent where `--out` was not given
`outputFormat`	`string`	No		The format of the file `outputPath` names, as `--format` gave it; absent where `--out` was not given
`isValid`	`boolean`	No		Whether `--validate` found nothing to refuse: no module skipped, no edge undeclared or unused, no path reference across modules, and every coordinate edge delivered as it may be. Absent where `--validate` was not given
`undeclaredDependencies`	`list[detect_dependencies.ValidationIssue]`	No		Each detected edge the module does not declare under that kind. Absent where `--validate` was not given
`unusedDeclaredDependencies`	`list[detect_dependencies.ValidationIssue]`	No		Each declared edge nothing in the module was detected to use. A declared coordinate whose publisher is no manifest in the tree is not reported, since nothing could have detected it. Absent where `--validate` was not given
`detectedTestLibraryDependencies`	`list[detect_dependencies.ValidationIssue]`	No		Each runtime edge detected onto a `test-library` module, which test files alone may reach. Absent where `--validate` was not given

`detect_dependencies.DetectedDependencyEntry`

Field	Type	Required	Default	Description
`module`	`string`	Yes		The module's name
`dependencies`	`list[string]`	No	`[]`	What was detected for the module, each a module name or a coordinate

`detect_dependencies.SkippedModuleEntry`

Field	Type	Required	Default	Description
`module`	`string`	Yes		The module that was not analysed
`reason`	`string`	No	`""`	Why it could not be analysed, as the failure was reported

`detect_dependencies.CrossModulePathReference`

Field	Type	Required	Default	Description
`module`	`string`	Yes		The module that holds the referencing document
`dependency`	`string`	Yes		The module the referenced path lies in
`document`	`string`	Yes		The referencing document, relative to the repository root
`alias`	`string`	No	`""`	The name the document gives the reference among its `externalSchemas`

`detect_dependencies.DependencyDeliveryEntry`

Field	Type	Required	Default	Description
`repository`	`string`	Yes		Whose declarations answered, as a path from the tree's root. One edge can have two answers: the tree taking a package from a path so its edits are live, and the checkout holding the module vendoring it.
`module`	`string`	Yes		The module that declares the edge.
`dependency`	`string`	Yes		The coordinate the edge names.
`type`	`string`	Yes		The kind of edge -- runtime, build, dev or test.
`delivery`	`enum` one of `vendored`, `vendored-schema`, `path`, `undelivered`	Yes		How that repository obtains the package: `vendored` from a build catalog, `vendored-schema` as a schema, `path` through the language's package manager, or `undelivered` where none of its declarations delivers it.
`via`	`string`	No	`""`	What delivers it: the vendored library or schema coordinate, or the path as the package manager's declaration writes it. Empty when nothing does.

`detect_dependencies.ValidationIssue`

Field	Type	Required	Default	Description
`module`	`string`	No	`""`	The module whose edge the finding is about
`dependency`	`string`	No	`""`	The module name or coordinate at the other end of the edge
`type`	`string`	No	`""`	The kind of edge: `runtime`, `build`, `dev` or `test`