0
# Taze
1

2
Taze is a modern command-line interface tool for dependency management that helps developers keep their package dependencies fresh and up-to-date. Built with TypeScript and designed for the modern JavaScript ecosystem, it provides intelligent dependency updating with built-in monorepo support, safe version range management, and interactive updating workflows.
3

4
## Package Information
5

6
- **Package Name**: taze
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install taze` or use directly with `npx taze`
10

11
## Core Imports
12

13
```typescript
14
import { CheckPackages, loadPackages, writePackage, defineConfig } from "taze";
15
```
16

17
For CommonJS:
18

19
```javascript
20
const { CheckPackages, loadPackages, writePackage, defineConfig } = require("taze");
21
```
22

23
## Basic Usage
24

25
### CLI Usage
26

27
```bash
28
# Check for dependency updates
29
npx taze
30

31
# Check for major updates
32
npx taze major
33

34
# Update dependencies interactively
35
npx taze -I
36

37
# Write updates to package.json
38
npx taze -w
39

40
# Recursively check monorepo
41
npx taze -r
42
```
43

44
### Programmatic API Usage
45

46
```typescript
47
import { CheckPackages, defineConfig } from "taze";
48

49
// Basic dependency checking
50
const result = await CheckPackages({
51
  cwd: process.cwd(),
52
  mode: "minor",
53
  write: false
54
});
55

56
// Configuration-based usage
57
const config = defineConfig({
58
  mode: "patch",
59
  include: ["react", "typescript"],
60
  exclude: ["legacy-lib"]
61
});
62

63
const results = await CheckPackages(config, {
64
  afterPackagesLoaded: (packages) => {
65
    console.log(`Found ${packages.length} packages`);
66
  }
67
});
68
```
69

70
## Architecture
71

72
Taze is built around several key components:
73

74
- **Package Discovery**: Automatic detection of package.json files and workspace configurations
75
- **Dependency Resolution**: Fetches latest versions from npm/yarn/pnpm registries with caching
76
- **Version Analysis**: Intelligent comparison of current vs available versions with semantic versioning
77
- **Update Management**: Safe version range updates respecting semantic versioning constraints
78
- **Package Manager Integration**: Native support for npm, yarn, and pnpm with automatic detection
79
- **Monorepo Support**: Workspace-aware dependency management for complex project structures
80

81
## Capabilities
82

83
### Programmatic API
84

85
Core functions for programmatic dependency management and package analysis. Ideal for integration into build tools, CI/CD pipelines, and custom automation scripts.
86

87
```typescript { .api }
88
function CheckPackages(
89
  options: CheckOptions,
90
  callbacks?: CheckEventCallbacks
91
): Promise<{ packages: PackageMeta[] }>;
92

93
function defineConfig(config: Partial<CheckOptions>): Partial<CheckOptions>;
94
```
95

96
[API Usage](./api-usage.md)
97

98
### Command Line Interface
99

100
Full-featured CLI for interactive and automated dependency management with extensive configuration options and workflow support.
101

102
```bash { .api }
103
taze [mode] [options]
104

105
# Available modes: default | major | minor | patch | latest | newest | next
106
# Key options: -w (write), -I (interactive), -r (recursive), -f (force)
107
```
108

109
[CLI Usage](./cli-usage.md)
110

111
### Configuration Management
112

113
Flexible configuration system supporting file-based configuration, environment variables, and runtime options with intelligent defaults.
114

115
```typescript { .api }
116
interface CheckOptions extends CommonOptions {
117
  mode?: RangeMode;
118
  write?: boolean;
119
  interactive?: boolean;
120
  install?: boolean;
121
  update?: boolean;
122
  global?: boolean;
123
}
124
```
125

126
[Configuration](./configuration.md)
127

128
## Core Types
129

130
```typescript { .api }
131
type RangeMode = "default" | "major" | "minor" | "patch" | "latest" | "newest" | "next";
132

133
interface PackageMeta {
134
  name: string;
135
  version: string;
136
  filepath: string;
137
  deps: RawDep[];
138
  resolved: ResolvedDepChange[];
139
}
140

141
interface ResolvedDepChange {
142
  name: string;
143
  currentVersion: string;
144
  targetVersion: string;
145
  diff: "major" | "minor" | "patch" | "error" | null;
146
  update: boolean;
147
}
148
```