This is page 4 of 4. Use http://codebase.md/hongsw/claude-agents-power-mcp-server?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .claude
│ └── agents
│ ├── devops-engineer.md
│ ├── frontend-developer.md
│ ├── qa-engineer.md
│ ├── README.md
│ ├── security-engineer.md
│ └── tech-lead.md
├── .gitignore
├── agents
│ ├── backend-engineer.md
│ ├── data-scientist.md
│ ├── devops-engineer.md
│ ├── frontend-developer.md
│ ├── full-stack-developer.md
│ ├── mobile-developer.md
│ ├── qa-engineer.md
│ ├── README.md
│ ├── security-engineer.md
│ ├── tech-lead.md
│ └── ui-designer.md
├── CHANGELOG.md
├── claude
│ └── agents
│ ├── company-roles.md
│ ├── en
│ │ ├── account-manager.md
│ │ ├── accountant.md
│ │ ├── accounting-manager.md
│ │ ├── agile-coach.md
│ │ ├── ai-researcher.md
│ │ ├── backend-developer.md
│ │ ├── backend-engineer.md
│ │ ├── bi-developer.md
│ │ ├── blockchain-developer.md
│ │ ├── brand-manager.md
│ │ ├── budget-analyst.md
│ │ ├── business-analyst.md
│ │ ├── business-developer.md
│ │ ├── business-development-manager.md
│ │ ├── business-intelligence-analyst.md
│ │ ├── business-process-analyst.md
│ │ ├── change-management-specialist.md
│ │ ├── change-manager.md
│ │ ├── chief-data-officer.md
│ │ ├── chief-executive-officer.md
│ │ ├── chief-financial-officer.md
│ │ ├── chief-human-resources-officer.md
│ │ ├── chief-information-officer.md
│ │ ├── chief-marketing-officer.md
│ │ ├── chief-operating-officer.md
│ │ ├── chief-product-officer.md
│ │ ├── chief-technology-officer.md
│ │ ├── clinical-researcher.md
│ │ ├── cloud-architect.md
│ │ ├── communications-director.md
│ │ ├── compensation-benefits-manager.md
│ │ ├── compensation-benefits.md
│ │ ├── compliance-manager.md
│ │ ├── compliance-officer.md
│ │ ├── content-creator.md
│ │ ├── content-marketer.md
│ │ ├── content-marketing-manager.md
│ │ ├── contract-manager.md
│ │ ├── controller.md
│ │ ├── copywriter.md
│ │ ├── corporate-trainer.md
│ │ ├── creative-director.md
│ │ ├── credit-analyst.md
│ │ ├── curriculum-developer.md
│ │ ├── customer-service-manager.md
│ │ ├── customer-success-manager.md
│ │ ├── data-analyst.md
│ │ ├── data-engineer.md
│ │ ├── data-scientist.md
│ │ ├── database-administrator.md
│ │ ├── design-lead.md
│ │ ├── devops-engineer.md
│ │ ├── digital-marketer.md
│ │ ├── digital-marketing-specialist.md
│ │ ├── diversity-inclusion-manager.md
│ │ ├── diversity-inclusion.md
│ │ ├── embedded-systems-engineer.md
│ │ ├── environmental-engineer.md
│ │ ├── event-manager.md
│ │ ├── executive-assistant.md
│ │ ├── facilities-manager.md
│ │ ├── facility-manager.md
│ │ ├── financial-analyst.md
│ │ ├── financial-controller.md
│ │ ├── frontend-developer.md
│ │ ├── full-stack-developer.md
│ │ ├── game-developer.md
│ │ ├── graphic-designer.md
│ │ ├── growth-hacker.md
│ │ ├── growth-marketing-manager.md
│ │ ├── health-informatics.md
│ │ ├── healthcare-analyst.md
│ │ ├── help-desk-specialist.md
│ │ ├── hr-manager.md
│ │ ├── implementation-consultant.md
│ │ ├── innovation-manager.md
│ │ ├── instructional-designer.md
│ │ ├── interaction-designer.md
│ │ ├── internal-auditor.md
│ │ ├── investment-analyst.md
│ │ ├── investor-relations-manager.md
│ │ ├── investor-relations.md
│ │ ├── it-administrator.md
│ │ ├── learning-development-manager.md
│ │ ├── learning-development.md
│ │ ├── legal-counsel.md
│ │ ├── machine-learning-engineer.md
│ │ ├── marketing-analyst.md
│ │ ├── marketing-manager.md
│ │ ├── medical-writer.md
│ │ ├── mobile-developer.md
│ │ ├── motion-designer.md
│ │ ├── network-engineer.md
│ │ ├── office-manager.md
│ │ ├── operations-manager.md
│ │ ├── organizational-developer.md
│ │ ├── organizational-development-manager.md
│ │ ├── partnership-manager.md
│ │ ├── patent-engineer.md
│ │ ├── payroll-manager.md
│ │ ├── pr-manager.md
│ │ ├── pre-sales-consultant.md
│ │ ├── privacy-officer.md
│ │ ├── process-engineer.md
│ │ ├── procurement-manager.md
│ │ ├── procurement-specialist.md
│ │ ├── product-designer.md
│ │ ├── product-manager.md
│ │ ├── product-owner.md
│ │ ├── production-manager.md
│ │ ├── program-manager.md
│ │ ├── project-manager.md
│ │ ├── public-relations-manager.md
│ │ ├── qa-engineer.md
│ │ ├── quality-assurance-manager.md
│ │ ├── quality-engineer.md
│ │ ├── r-and-d-engineer.md
│ │ ├── real-estate-analyst.md
│ │ ├── research-scientist.md
│ │ ├── risk-manager.md
│ │ ├── sales-engineer.md
│ │ ├── sales-manager.md
│ │ ├── scrum-master.md
│ │ ├── security-engineer.md
│ │ ├── seo-specialist.md
│ │ ├── site-reliability-engineer.md
│ │ ├── social-media-manager.md
│ │ ├── software-engineer.md
│ │ ├── solution-architect.md
│ │ ├── strategy-consultant.md
│ │ ├── supply-chain-manager.md
│ │ ├── sustainability-manager.md
│ │ ├── talent-acquisition-specialist.md
│ │ ├── talent-acquisition.md
│ │ ├── tax-manager.md
│ │ ├── tech-lead.md
│ │ ├── technical-pm.md
│ │ ├── technical-support-engineer.md
│ │ ├── technical-support.md
│ │ ├── technical-writer.md
│ │ ├── training-specialist.md
│ │ ├── treasury-manager.md
│ │ ├── ui-designer.md
│ │ ├── ux-designer.md
│ │ ├── ux-researcher.md
│ │ └── video-producer.md
│ ├── ja
│ │ ├── backend-engineer.md
│ │ ├── data-scientist.md
│ │ ├── devops-engineer.md
│ │ ├── frontend-developer.md
│ │ └── product-manager.md
│ ├── ko
│ │ ├── account-manager.md
│ │ ├── accountant.md
│ │ ├── backend-developer.md
│ │ ├── backend-engineer.md
│ │ ├── bi-developer.md
│ │ ├── blockchain-developer.md
│ │ ├── brand-manager.md
│ │ ├── budget-analyst.md
│ │ ├── business-analyst.md
│ │ ├── business-developer.md
│ │ ├── change-manager.md
│ │ ├── clinical-researcher.md
│ │ ├── cloud-architect.md
│ │ ├── communications-director.md
│ │ ├── compensation-benefits.md
│ │ ├── compliance-officer.md
│ │ ├── content-creator.md
│ │ ├── content-marketer.md
│ │ ├── contract-manager.md
│ │ ├── controller.md
│ │ ├── copywriter.md
│ │ ├── corporate-trainer.md
│ │ ├── curriculum-developer.md
│ │ ├── customer-success-manager.md
│ │ ├── data-analyst.md
│ │ ├── data-engineer.md
│ │ ├── data-scientist.md
│ │ ├── devops-engineer.md
│ │ ├── digital-marketer.md
│ │ ├── diversity-inclusion.md
│ │ ├── environmental-engineer.md
│ │ ├── event-manager.md
│ │ ├── executive-assistant.md
│ │ ├── facility-manager.md
│ │ ├── financial-analyst.md
│ │ ├── frontend-developer.md
│ │ ├── full-stack-developer.md
│ │ ├── graphic-designer.md
│ │ ├── growth-hacker.md
│ │ ├── health-informatics.md
│ │ ├── healthcare-analyst.md
│ │ ├── help-desk-specialist.md
│ │ ├── hr-manager.md
│ │ ├── innovation-manager.md
│ │ ├── instructional-designer.md
│ │ ├── internal-auditor.md
│ │ ├── investor-relations.md
│ │ ├── it-administrator.md
│ │ ├── learning-development.md
│ │ ├── legal-counsel.md
│ │ ├── machine-learning-engineer.md
│ │ ├── marketing-analyst.md
│ │ ├── medical-writer.md
│ │ ├── mobile-developer.md
│ │ ├── motion-designer.md
│ │ ├── operations-manager.md
│ │ ├── organizational-developer.md
│ │ ├── patent-engineer.md
│ │ ├── pr-manager.md
│ │ ├── privacy-officer.md
│ │ ├── process-engineer.md
│ │ ├── procurement-specialist.md
│ │ ├── product-designer.md
│ │ ├── product-manager.md
│ │ ├── product-owner.md
│ │ ├── production-manager.md
│ │ ├── project-manager.md
│ │ ├── qa-engineer.md
│ │ ├── quality-engineer.md
│ │ ├── r-and-d-engineer.md
│ │ ├── real-estate-analyst.md
│ │ ├── research-scientist.md
│ │ ├── risk-manager.md
│ │ ├── sales-manager.md
│ │ ├── scrum-master.md
│ │ ├── security-engineer.md
│ │ ├── social-media-manager.md
│ │ ├── software-engineer.md
│ │ ├── strategy-consultant.md
│ │ ├── supply-chain-manager.md
│ │ ├── sustainability-manager.md
│ │ ├── talent-acquisition.md
│ │ ├── technical-pm.md
│ │ ├── technical-support.md
│ │ ├── treasury-manager.md
│ │ ├── ui-designer.md
│ │ └── ux-designer.md
│ └── zh
│ ├── backend-engineer.md
│ ├── data-scientist.md
│ ├── devops-engineer.md
│ ├── frontend-developer.md
│ ├── product-manager.md
│ ├── project-manager.md
│ ├── qa-engineer.md
│ └── security-engineer.md
├── claude-slash-commands
│ ├── agent-download.md
│ ├── agents-load.md
│ ├── agents-search.md
│ ├── agents-suggest.md
│ ├── agents-version.md
│ └── splash.md
├── CLAUDE.md
├── dist
│ ├── agentManager.d.ts
│ ├── agentManager.d.ts.map
│ ├── agentManager.js
│ ├── agentManager.js.map
│ ├── githubIntegration.d.ts
│ ├── githubIntegration.d.ts.map
│ ├── githubIntegration.js
│ ├── githubIntegration.js.map
│ ├── index.d.ts
│ ├── index.d.ts.map
│ ├── index.js
│ ├── index.js.map
│ ├── projectAnalyzer.d.ts
│ ├── projectAnalyzer.d.ts.map
│ ├── projectAnalyzer.js
│ └── projectAnalyzer.js.map
├── docs
│ ├── company_roles.md
│ └── index.html
├── examples
│ └── usage.md
├── EXAMPLES.md
├── FIXED.md
├── index.html
├── install-slash-commands.js
├── INSTALL.md
├── INSTALLATION.md
├── LICENSE
├── node_modules
│ ├── .bin
│ │ ├── esbuild
│ │ ├── glob
│ │ ├── js-yaml
│ │ ├── node-which
│ │ ├── tsc
│ │ ├── tsserver
│ │ └── tsx
│ ├── .package-lock.json
│ ├── @esbuild
│ │ └── darwin-arm64
│ │ ├── bin
│ │ │ └── esbuild
│ │ ├── package.json
│ │ └── README.md
│ ├── @isaacs
│ │ └── cliui
│ │ ├── build
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ └── lib
│ │ │ └── index.js
│ │ ├── index.mjs
│ │ ├── LICENSE.txt
│ │ ├── package.json
│ │ └── README.md
│ ├── @modelcontextprotocol
│ │ └── sdk
│ │ ├── dist
│ │ │ ├── cli.d.ts
│ │ │ ├── cli.d.ts.map
│ │ │ ├── cli.js
│ │ │ ├── cli.js.map
│ │ │ ├── client
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── index.test.d.ts
│ │ │ │ ├── index.test.d.ts.map
│ │ │ │ ├── index.test.js
│ │ │ │ ├── index.test.js.map
│ │ │ │ ├── sse.d.ts
│ │ │ │ ├── sse.d.ts.map
│ │ │ │ ├── sse.js
│ │ │ │ ├── sse.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ ├── stdio.test.js.map
│ │ │ │ ├── websocket.d.ts
│ │ │ │ ├── websocket.d.ts.map
│ │ │ │ ├── websocket.js
│ │ │ │ └── websocket.js.map
│ │ │ ├── inMemory.d.ts
│ │ │ ├── inMemory.d.ts.map
│ │ │ ├── inMemory.js
│ │ │ ├── inMemory.js.map
│ │ │ ├── inMemory.test.d.ts
│ │ │ ├── inMemory.test.d.ts.map
│ │ │ ├── inMemory.test.js
│ │ │ ├── inMemory.test.js.map
│ │ │ ├── server
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── index.test.d.ts
│ │ │ │ ├── index.test.d.ts.map
│ │ │ │ ├── index.test.js
│ │ │ │ ├── index.test.js.map
│ │ │ │ ├── sse.d.ts
│ │ │ │ ├── sse.d.ts.map
│ │ │ │ ├── sse.js
│ │ │ │ ├── sse.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ └── stdio.test.js.map
│ │ │ ├── shared
│ │ │ │ ├── protocol.d.ts
│ │ │ │ ├── protocol.d.ts.map
│ │ │ │ ├── protocol.js
│ │ │ │ ├── protocol.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ ├── stdio.test.js.map
│ │ │ │ ├── transport.d.ts
│ │ │ │ ├── transport.d.ts.map
│ │ │ │ ├── transport.js
│ │ │ │ └── transport.js.map
│ │ │ ├── types.d.ts
│ │ │ ├── types.d.ts.map
│ │ │ ├── types.js
│ │ │ ├── types.js.map
│ │ │ ├── utils.d.ts
│ │ │ ├── utils.d.ts.map
│ │ │ ├── utils.js
│ │ │ ├── utils.js.map
│ │ │ ├── utils.test.d.ts
│ │ │ ├── utils.test.d.ts.map
│ │ │ ├── utils.test.js
│ │ │ └── utils.test.js.map
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── @pkgjs
│ │ └── parseargs
│ │ ├── .editorconfig
│ │ ├── CHANGELOG.md
│ │ ├── examples
│ │ │ ├── is-default-value.js
│ │ │ ├── limit-long-syntax.js
│ │ │ ├── negate.js
│ │ │ ├── no-repeated-options.js
│ │ │ ├── ordered-options.mjs
│ │ │ └── simple-hard-coded.js
│ │ ├── index.js
│ │ ├── internal
│ │ │ ├── errors.js
│ │ │ ├── primordials.js
│ │ │ ├── util.js
│ │ │ └── validators.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── utils.js
│ ├── @types
│ │ ├── js-yaml
│ │ │ ├── index.d.mts
│ │ │ ├── index.d.ts
│ │ │ ├── LICENSE
│ │ │ ├── package.json
│ │ │ └── README.md
│ │ └── node
│ │ ├── assert
│ │ │ └── strict.d.ts
│ │ ├── assert.d.ts
│ │ ├── async_hooks.d.ts
│ │ ├── buffer.buffer.d.ts
│ │ ├── buffer.d.ts
│ │ ├── child_process.d.ts
│ │ ├── cluster.d.ts
│ │ ├── compatibility
│ │ │ ├── disposable.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── indexable.d.ts
│ │ │ └── iterators.d.ts
│ │ ├── console.d.ts
│ │ ├── constants.d.ts
│ │ ├── crypto.d.ts
│ │ ├── dgram.d.ts
│ │ ├── diagnostics_channel.d.ts
│ │ ├── dns
│ │ │ └── promises.d.ts
│ │ ├── dns.d.ts
│ │ ├── dom-events.d.ts
│ │ ├── domain.d.ts
│ │ ├── events.d.ts
│ │ ├── fs
│ │ │ └── promises.d.ts
│ │ ├── fs.d.ts
│ │ ├── globals.d.ts
│ │ ├── globals.typedarray.d.ts
│ │ ├── http.d.ts
│ │ ├── http2.d.ts
│ │ ├── https.d.ts
│ │ ├── index.d.ts
│ │ ├── inspector.d.ts
│ │ ├── LICENSE
│ │ ├── module.d.ts
│ │ ├── net.d.ts
│ │ ├── os.d.ts
│ │ ├── package.json
│ │ ├── path.d.ts
│ │ ├── perf_hooks.d.ts
│ │ ├── process.d.ts
│ │ ├── punycode.d.ts
│ │ ├── querystring.d.ts
│ │ ├── readline
│ │ │ └── promises.d.ts
│ │ ├── readline.d.ts
│ │ ├── README.md
│ │ ├── repl.d.ts
│ │ ├── sea.d.ts
│ │ ├── stream
│ │ │ ├── consumers.d.ts
│ │ │ ├── promises.d.ts
│ │ │ └── web.d.ts
│ │ ├── stream.d.ts
│ │ ├── string_decoder.d.ts
│ │ ├── test.d.ts
│ │ ├── timers
│ │ │ └── promises.d.ts
│ │ ├── timers.d.ts
│ │ ├── tls.d.ts
│ │ ├── trace_events.d.ts
│ │ ├── ts5.6
│ │ │ ├── buffer.buffer.d.ts
│ │ │ ├── globals.typedarray.d.ts
│ │ │ └── index.d.ts
│ │ ├── tty.d.ts
│ │ ├── url.d.ts
│ │ ├── util.d.ts
│ │ ├── v8.d.ts
│ │ ├── vm.d.ts
│ │ ├── wasi.d.ts
│ │ ├── worker_threads.d.ts
│ │ └── zlib.d.ts
│ ├── ansi-regex
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── ansi-styles
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── argparse
│ │ ├── argparse.js
│ │ ├── CHANGELOG.md
│ │ ├── lib
│ │ │ ├── sub.js
│ │ │ └── textwrap.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── balanced-match
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── index.js
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── brace-expansion
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── bytes
│ │ ├── History.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── Readme.md
│ ├── color-convert
│ │ ├── CHANGELOG.md
│ │ ├── conversions.js
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── route.js
│ ├── color-name
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── commander
│ │ ├── esm.mjs
│ │ ├── index.js
│ │ ├── lib
│ │ │ ├── argument.js
│ │ │ ├── command.js
│ │ │ ├── error.js
│ │ │ ├── help.js
│ │ │ ├── option.js
│ │ │ └── suggestSimilar.js
│ │ ├── LICENSE
│ │ ├── package-support.json
│ │ ├── package.json
│ │ ├── Readme.md
│ │ └── typings
│ │ ├── esm.d.mts
│ │ └── index.d.ts
│ ├── content-type
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── cross-spawn
│ │ ├── index.js
│ │ ├── lib
│ │ │ ├── enoent.js
│ │ │ ├── parse.js
│ │ │ └── util
│ │ │ ├── escape.js
│ │ │ ├── readShebang.js
│ │ │ └── resolveCommand.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── depd
│ │ ├── History.md
│ │ ├── index.js
│ │ ├── lib
│ │ │ └── browser
│ │ │ └── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── Readme.md
│ ├── eastasianwidth
│ │ ├── eastasianwidth.js
│ │ ├── package.json
│ │ └── README.md
│ ├── emoji-regex
│ │ ├── es2015
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── RGI_Emoji.d.ts
│ │ │ ├── RGI_Emoji.js
│ │ │ ├── text.d.ts
│ │ │ └── text.js
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE-MIT.txt
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── RGI_Emoji.d.ts
│ │ ├── RGI_Emoji.js
│ │ ├── text.d.ts
│ │ └── text.js
│ ├── esbuild
│ │ ├── bin
│ │ │ └── esbuild
│ │ ├── install.js
│ │ ├── lib
│ │ │ ├── main.d.ts
│ │ │ └── main.js
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── foreground-child
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── all-signals.d.ts
│ │ │ │ ├── all-signals.d.ts.map
│ │ │ │ ├── all-signals.js
│ │ │ │ ├── all-signals.js.map
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── package.json
│ │ │ │ ├── proxy-signals.d.ts
│ │ │ │ ├── proxy-signals.d.ts.map
│ │ │ │ ├── proxy-signals.js
│ │ │ │ ├── proxy-signals.js.map
│ │ │ │ ├── watchdog.d.ts
│ │ │ │ ├── watchdog.d.ts.map
│ │ │ │ ├── watchdog.js
│ │ │ │ └── watchdog.js.map
│ │ │ └── esm
│ │ │ ├── all-signals.d.ts
│ │ │ ├── all-signals.d.ts.map
│ │ │ ├── all-signals.js
│ │ │ ├── all-signals.js.map
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── package.json
│ │ │ ├── proxy-signals.d.ts
│ │ │ ├── proxy-signals.d.ts.map
│ │ │ ├── proxy-signals.js
│ │ │ ├── proxy-signals.js.map
│ │ │ ├── watchdog.d.ts
│ │ │ ├── watchdog.d.ts.map
│ │ │ ├── watchdog.js
│ │ │ └── watchdog.js.map
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── get-tsconfig
│ │ ├── dist
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ ├── index.d.mts
│ │ │ └── index.mjs
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── glob
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── glob.d.ts
│ │ │ │ ├── glob.d.ts.map
│ │ │ │ ├── glob.js
│ │ │ │ ├── glob.js.map
│ │ │ │ ├── has-magic.d.ts
│ │ │ │ ├── has-magic.d.ts.map
│ │ │ │ ├── has-magic.js
│ │ │ │ ├── has-magic.js.map
│ │ │ │ ├── ignore.d.ts
│ │ │ │ ├── ignore.d.ts.map
│ │ │ │ ├── ignore.js
│ │ │ │ ├── ignore.js.map
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── package.json
│ │ │ │ ├── pattern.d.ts
│ │ │ │ ├── pattern.d.ts.map
│ │ │ │ ├── pattern.js
│ │ │ │ ├── pattern.js.map
│ │ │ │ ├── processor.d.ts
│ │ │ │ ├── processor.d.ts.map
│ │ │ │ ├── processor.js
│ │ │ │ ├── processor.js.map
│ │ │ │ ├── walker.d.ts
│ │ │ │ ├── walker.d.ts.map
│ │ │ │ ├── walker.js
│ │ │ │ └── walker.js.map
│ │ │ └── esm
│ │ │ ├── bin.d.mts
│ │ │ ├── bin.d.mts.map
│ │ │ ├── bin.mjs
│ │ │ ├── bin.mjs.map
│ │ │ ├── glob.d.ts
│ │ │ ├── glob.d.ts.map
│ │ │ ├── glob.js
│ │ │ ├── glob.js.map
│ │ │ ├── has-magic.d.ts
│ │ │ ├── has-magic.d.ts.map
│ │ │ ├── has-magic.js
│ │ │ ├── has-magic.js.map
│ │ │ ├── ignore.d.ts
│ │ │ ├── ignore.d.ts.map
│ │ │ ├── ignore.js
│ │ │ ├── ignore.js.map
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── package.json
│ │ │ ├── pattern.d.ts
│ │ │ ├── pattern.d.ts.map
│ │ │ ├── pattern.js
│ │ │ ├── pattern.js.map
│ │ │ ├── processor.d.ts
│ │ │ ├── processor.d.ts.map
│ │ │ ├── processor.js
│ │ │ ├── processor.js.map
│ │ │ ├── walker.d.ts
│ │ │ ├── walker.d.ts.map
│ │ │ ├── walker.js
│ │ │ └── walker.js.map
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── http-errors
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── iconv-lite
│ │ ├── .github
│ │ │ └── dependabot.yml
│ │ ├── .idea
│ │ │ ├── codeStyles
│ │ │ │ ├── codeStyleConfig.xml
│ │ │ │ └── Project.xml
│ │ │ ├── iconv-lite.iml
│ │ │ ├── inspectionProfiles
│ │ │ │ └── Project_Default.xml
│ │ │ ├── modules.xml
│ │ │ └── vcs.xml
│ │ ├── Changelog.md
│ │ ├── encodings
│ │ │ ├── dbcs-codec.js
│ │ │ ├── dbcs-data.js
│ │ │ ├── index.js
│ │ │ ├── internal.js
│ │ │ ├── sbcs-codec.js
│ │ │ ├── sbcs-data-generated.js
│ │ │ ├── sbcs-data.js
│ │ │ ├── tables
│ │ │ │ ├── big5-added.json
│ │ │ │ ├── cp936.json
│ │ │ │ ├── cp949.json
│ │ │ │ ├── cp950.json
│ │ │ │ ├── eucjp.json
│ │ │ │ ├── gb18030-ranges.json
│ │ │ │ ├── gbk-added.json
│ │ │ │ └── shiftjis.json
│ │ │ ├── utf16.js
│ │ │ ├── utf32.js
│ │ │ └── utf7.js
│ │ ├── lib
│ │ │ ├── bom-handling.js
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ └── streams.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── inherits
│ │ ├── inherits_browser.js
│ │ ├── inherits.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── is-fullwidth-code-point
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── isexe
│ │ ├── .npmignore
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── mode.js
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── test
│ │ │ └── basic.js
│ │ └── windows.js
│ ├── jackspeak
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── package.json
│ │ │ │ ├── parse-args-cjs.cjs.map
│ │ │ │ ├── parse-args-cjs.d.cts.map
│ │ │ │ ├── parse-args.d.ts
│ │ │ │ └── parse-args.js
│ │ │ └── esm
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── package.json
│ │ │ ├── parse-args.d.ts
│ │ │ ├── parse-args.d.ts.map
│ │ │ ├── parse-args.js
│ │ │ └── parse-args.js.map
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── js-yaml
│ │ ├── bin
│ │ │ └── js-yaml.js
│ │ ├── CHANGELOG.md
│ │ ├── dist
│ │ │ ├── js-yaml.js
│ │ │ ├── js-yaml.min.js
│ │ │ └── js-yaml.mjs
│ │ ├── index.js
│ │ ├── lib
│ │ │ ├── common.js
│ │ │ ├── dumper.js
│ │ │ ├── exception.js
│ │ │ ├── loader.js
│ │ │ ├── schema
│ │ │ │ ├── core.js
│ │ │ │ ├── default.js
│ │ │ │ ├── failsafe.js
│ │ │ │ └── json.js
│ │ │ ├── schema.js
│ │ │ ├── snippet.js
│ │ │ ├── type
│ │ │ │ ├── binary.js
│ │ │ │ ├── bool.js
│ │ │ │ ├── float.js
│ │ │ │ ├── int.js
│ │ │ │ ├── map.js
│ │ │ │ ├── merge.js
│ │ │ │ ├── null.js
│ │ │ │ ├── omap.js
│ │ │ │ ├── pairs.js
│ │ │ │ ├── seq.js
│ │ │ │ ├── set.js
│ │ │ │ ├── str.js
│ │ │ │ └── timestamp.js
│ │ │ └── type.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── lru-cache
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── index.min.js
│ │ │ │ ├── index.min.js.map
│ │ │ │ └── package.json
│ │ │ └── esm
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── index.min.js
│ │ │ ├── index.min.js.map
│ │ │ └── package.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── minimatch
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── assert-valid-pattern.d.ts
│ │ │ │ ├── assert-valid-pattern.d.ts.map
│ │ │ │ ├── assert-valid-pattern.js
│ │ │ │ ├── assert-valid-pattern.js.map
│ │ │ │ ├── ast.d.ts
│ │ │ │ ├── ast.d.ts.map
│ │ │ │ ├── ast.js
│ │ │ │ ├── ast.js.map
│ │ │ │ ├── brace-expressions.d.ts
│ │ │ │ ├── brace-expressions.d.ts.map
│ │ │ │ ├── brace-expressions.js
│ │ │ │ ├── brace-expressions.js.map
│ │ │ │ ├── escape.d.ts
│ │ │ │ ├── escape.d.ts.map
│ │ │ │ ├── escape.js
│ │ │ │ ├── escape.js.map
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── package.json
│ │ │ │ ├── unescape.d.ts
│ │ │ │ ├── unescape.d.ts.map
│ │ │ │ ├── unescape.js
│ │ │ │ └── unescape.js.map
│ │ │ └── esm
│ │ │ ├── assert-valid-pattern.d.ts
│ │ │ ├── assert-valid-pattern.d.ts.map
│ │ │ ├── assert-valid-pattern.js
│ │ │ ├── assert-valid-pattern.js.map
│ │ │ ├── ast.d.ts
│ │ │ ├── ast.d.ts.map
│ │ │ ├── ast.js
│ │ │ ├── ast.js.map
│ │ │ ├── brace-expressions.d.ts
│ │ │ ├── brace-expressions.d.ts.map
│ │ │ ├── brace-expressions.js
│ │ │ ├── brace-expressions.js.map
│ │ │ ├── escape.d.ts
│ │ │ ├── escape.d.ts.map
│ │ │ ├── escape.js
│ │ │ ├── escape.js.map
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── package.json
│ │ │ ├── unescape.d.ts
│ │ │ ├── unescape.d.ts.map
│ │ │ ├── unescape.js
│ │ │ └── unescape.js.map
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── minipass
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ └── package.json
│ │ │ └── esm
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ └── package.json
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── package-json-from-dist
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ └── package.json
│ │ │ └── esm
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ └── package.json
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── path-key
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── path-scurry
│ │ ├── dist
│ │ │ ├── commonjs
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ └── package.json
│ │ │ └── esm
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ └── package.json
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── raw-body
│ │ ├── HISTORY.md
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── SECURITY.md
│ ├── resolve-pkg-maps
│ │ ├── dist
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ ├── index.d.mts
│ │ │ └── index.mjs
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── safer-buffer
│ │ ├── dangerous.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── Porting-Buffer.md
│ │ ├── Readme.md
│ │ ├── safer.js
│ │ └── tests.js
│ ├── setprototypeof
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ └── index.js
│ ├── shebang-command
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── shebang-regex
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── signal-exit
│ │ ├── dist
│ │ │ ├── cjs
│ │ │ │ ├── browser.d.ts
│ │ │ │ ├── browser.d.ts.map
│ │ │ │ ├── browser.js
│ │ │ │ ├── browser.js.map
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── package.json
│ │ │ │ ├── signals.d.ts
│ │ │ │ ├── signals.d.ts.map
│ │ │ │ ├── signals.js
│ │ │ │ └── signals.js.map
│ │ │ └── mjs
│ │ │ ├── browser.d.ts
│ │ │ ├── browser.d.ts.map
│ │ │ ├── browser.js
│ │ │ ├── browser.js.map
│ │ │ ├── index.d.ts
│ │ │ ├── index.d.ts.map
│ │ │ ├── index.js
│ │ │ ├── index.js.map
│ │ │ ├── package.json
│ │ │ ├── signals.d.ts
│ │ │ ├── signals.d.ts.map
│ │ │ ├── signals.js
│ │ │ └── signals.js.map
│ │ ├── LICENSE.txt
│ │ ├── package.json
│ │ └── README.md
│ ├── statuses
│ │ ├── codes.json
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── string-width
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── string-width-cjs
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── node_modules
│ │ │ ├── ansi-regex
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── license
│ │ │ │ ├── package.json
│ │ │ │ └── readme.md
│ │ │ ├── emoji-regex
│ │ │ │ ├── es2015
│ │ │ │ │ ├── index.js
│ │ │ │ │ └── text.js
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── LICENSE-MIT.txt
│ │ │ │ ├── package.json
│ │ │ │ ├── README.md
│ │ │ │ └── text.js
│ │ │ └── strip-ansi
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── license
│ │ │ ├── package.json
│ │ │ └── readme.md
│ │ ├── package.json
│ │ └── readme.md
│ ├── strip-ansi
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── strip-ansi-cjs
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── node_modules
│ │ │ └── ansi-regex
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── license
│ │ │ ├── package.json
│ │ │ └── readme.md
│ │ ├── package.json
│ │ └── readme.md
│ ├── toidentifier
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── tsx
│ │ ├── dist
│ │ │ ├── cjs
│ │ │ │ ├── api
│ │ │ │ │ ├── index.cjs
│ │ │ │ │ ├── index.d.cts
│ │ │ │ │ ├── index.d.mts
│ │ │ │ │ └── index.mjs
│ │ │ │ ├── index.cjs
│ │ │ │ └── index.mjs
│ │ │ ├── cli.cjs
│ │ │ ├── cli.mjs
│ │ │ ├── client-BQVF1NaW.mjs
│ │ │ ├── client-D6NvIMSC.cjs
│ │ │ ├── esm
│ │ │ │ ├── api
│ │ │ │ │ ├── index.cjs
│ │ │ │ │ ├── index.d.cts
│ │ │ │ │ ├── index.d.mts
│ │ │ │ │ └── index.mjs
│ │ │ │ ├── index.cjs
│ │ │ │ └── index.mjs
│ │ │ ├── get-pipe-path-BHW2eJdv.mjs
│ │ │ ├── get-pipe-path-BoR10qr8.cjs
│ │ │ ├── index-7AaEi15b.mjs
│ │ │ ├── index-BWFBUo6r.cjs
│ │ │ ├── index-gbaejti9.mjs
│ │ │ ├── index-gckBtVBf.cjs
│ │ │ ├── lexer-DgIbo0BU.cjs
│ │ │ ├── lexer-DQCqS3nf.mjs
│ │ │ ├── loader.cjs
│ │ │ ├── loader.mjs
│ │ │ ├── node-features-_8ZFwP_x.mjs
│ │ │ ├── node-features-roYmp9jK.cjs
│ │ │ ├── package-BgRDTLo0.mjs
│ │ │ ├── package-BTMRuUqB.cjs
│ │ │ ├── patch-repl.cjs
│ │ │ ├── patch-repl.mjs
│ │ │ ├── preflight.cjs
│ │ │ ├── preflight.mjs
│ │ │ ├── register-2sWVXuRQ.cjs
│ │ │ ├── register-B7jrtLTO.mjs
│ │ │ ├── register-CFH5oNdT.mjs
│ │ │ ├── register-D46fvsV_.cjs
│ │ │ ├── repl.cjs
│ │ │ ├── repl.mjs
│ │ │ ├── require-D4F1Lv60.cjs
│ │ │ ├── require-DQxpCAr4.mjs
│ │ │ ├── suppress-warnings.cjs
│ │ │ ├── suppress-warnings.mjs
│ │ │ ├── temporary-directory-B83uKxJF.cjs
│ │ │ ├── temporary-directory-CwHp0_NW.mjs
│ │ │ └── types-Cxp8y2TL.d.ts
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── typescript
│ │ ├── bin
│ │ │ ├── tsc
│ │ │ └── tsserver
│ │ ├── lib
│ │ │ ├── _tsc.js
│ │ │ ├── _tsserver.js
│ │ │ ├── _typingsInstaller.js
│ │ │ ├── cs
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── de
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── es
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── fr
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── it
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ja
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ko
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── lib.d.ts
│ │ │ ├── lib.decorators.d.ts
│ │ │ ├── lib.decorators.legacy.d.ts
│ │ │ ├── lib.dom.asynciterable.d.ts
│ │ │ ├── lib.dom.d.ts
│ │ │ ├── lib.dom.iterable.d.ts
│ │ │ ├── lib.es2015.collection.d.ts
│ │ │ ├── lib.es2015.core.d.ts
│ │ │ ├── lib.es2015.d.ts
│ │ │ ├── lib.es2015.generator.d.ts
│ │ │ ├── lib.es2015.iterable.d.ts
│ │ │ ├── lib.es2015.promise.d.ts
│ │ │ ├── lib.es2015.proxy.d.ts
│ │ │ ├── lib.es2015.reflect.d.ts
│ │ │ ├── lib.es2015.symbol.d.ts
│ │ │ ├── lib.es2015.symbol.wellknown.d.ts
│ │ │ ├── lib.es2016.array.include.d.ts
│ │ │ ├── lib.es2016.d.ts
│ │ │ ├── lib.es2016.full.d.ts
│ │ │ ├── lib.es2016.intl.d.ts
│ │ │ ├── lib.es2017.arraybuffer.d.ts
│ │ │ ├── lib.es2017.d.ts
│ │ │ ├── lib.es2017.date.d.ts
│ │ │ ├── lib.es2017.full.d.ts
│ │ │ ├── lib.es2017.intl.d.ts
│ │ │ ├── lib.es2017.object.d.ts
│ │ │ ├── lib.es2017.sharedmemory.d.ts
│ │ │ ├── lib.es2017.string.d.ts
│ │ │ ├── lib.es2017.typedarrays.d.ts
│ │ │ ├── lib.es2018.asyncgenerator.d.ts
│ │ │ ├── lib.es2018.asynciterable.d.ts
│ │ │ ├── lib.es2018.d.ts
│ │ │ ├── lib.es2018.full.d.ts
│ │ │ ├── lib.es2018.intl.d.ts
│ │ │ ├── lib.es2018.promise.d.ts
│ │ │ ├── lib.es2018.regexp.d.ts
│ │ │ ├── lib.es2019.array.d.ts
│ │ │ ├── lib.es2019.d.ts
│ │ │ ├── lib.es2019.full.d.ts
│ │ │ ├── lib.es2019.intl.d.ts
│ │ │ ├── lib.es2019.object.d.ts
│ │ │ ├── lib.es2019.string.d.ts
│ │ │ ├── lib.es2019.symbol.d.ts
│ │ │ ├── lib.es2020.bigint.d.ts
│ │ │ ├── lib.es2020.d.ts
│ │ │ ├── lib.es2020.date.d.ts
│ │ │ ├── lib.es2020.full.d.ts
│ │ │ ├── lib.es2020.intl.d.ts
│ │ │ ├── lib.es2020.number.d.ts
│ │ │ ├── lib.es2020.promise.d.ts
│ │ │ ├── lib.es2020.sharedmemory.d.ts
│ │ │ ├── lib.es2020.string.d.ts
│ │ │ ├── lib.es2020.symbol.wellknown.d.ts
│ │ │ ├── lib.es2021.d.ts
│ │ │ ├── lib.es2021.full.d.ts
│ │ │ ├── lib.es2021.intl.d.ts
│ │ │ ├── lib.es2021.promise.d.ts
│ │ │ ├── lib.es2021.string.d.ts
│ │ │ ├── lib.es2021.weakref.d.ts
│ │ │ ├── lib.es2022.array.d.ts
│ │ │ ├── lib.es2022.d.ts
│ │ │ ├── lib.es2022.error.d.ts
│ │ │ ├── lib.es2022.full.d.ts
│ │ │ ├── lib.es2022.intl.d.ts
│ │ │ ├── lib.es2022.object.d.ts
│ │ │ ├── lib.es2022.regexp.d.ts
│ │ │ ├── lib.es2022.string.d.ts
│ │ │ ├── lib.es2023.array.d.ts
│ │ │ ├── lib.es2023.collection.d.ts
│ │ │ ├── lib.es2023.d.ts
│ │ │ ├── lib.es2023.full.d.ts
│ │ │ ├── lib.es2023.intl.d.ts
│ │ │ ├── lib.es2024.arraybuffer.d.ts
│ │ │ ├── lib.es2024.collection.d.ts
│ │ │ ├── lib.es2024.d.ts
│ │ │ ├── lib.es2024.full.d.ts
│ │ │ ├── lib.es2024.object.d.ts
│ │ │ ├── lib.es2024.promise.d.ts
│ │ │ ├── lib.es2024.regexp.d.ts
│ │ │ ├── lib.es2024.sharedmemory.d.ts
│ │ │ ├── lib.es2024.string.d.ts
│ │ │ ├── lib.es5.d.ts
│ │ │ ├── lib.es6.d.ts
│ │ │ ├── lib.esnext.array.d.ts
│ │ │ ├── lib.esnext.collection.d.ts
│ │ │ ├── lib.esnext.d.ts
│ │ │ ├── lib.esnext.decorators.d.ts
│ │ │ ├── lib.esnext.disposable.d.ts
│ │ │ ├── lib.esnext.float16.d.ts
│ │ │ ├── lib.esnext.full.d.ts
│ │ │ ├── lib.esnext.intl.d.ts
│ │ │ ├── lib.esnext.iterator.d.ts
│ │ │ ├── lib.esnext.promise.d.ts
│ │ │ ├── lib.scripthost.d.ts
│ │ │ ├── lib.webworker.asynciterable.d.ts
│ │ │ ├── lib.webworker.d.ts
│ │ │ ├── lib.webworker.importscripts.d.ts
│ │ │ ├── lib.webworker.iterable.d.ts
│ │ │ ├── pl
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── pt-br
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ru
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── tr
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── tsc.js
│ │ │ ├── tsserver.js
│ │ │ ├── tsserverlibrary.d.ts
│ │ │ ├── tsserverlibrary.js
│ │ │ ├── typescript.d.ts
│ │ │ ├── typescript.js
│ │ │ ├── typesMap.json
│ │ │ ├── typingsInstaller.js
│ │ │ ├── watchGuard.js
│ │ │ ├── zh-cn
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ └── zh-tw
│ │ │ └── diagnosticMessages.generated.json
│ │ ├── LICENSE.txt
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ └── ThirdPartyNoticeText.txt
│ ├── undici-types
│ │ ├── agent.d.ts
│ │ ├── api.d.ts
│ │ ├── balanced-pool.d.ts
│ │ ├── cache.d.ts
│ │ ├── client.d.ts
│ │ ├── connector.d.ts
│ │ ├── content-type.d.ts
│ │ ├── cookies.d.ts
│ │ ├── diagnostics-channel.d.ts
│ │ ├── dispatcher.d.ts
│ │ ├── env-http-proxy-agent.d.ts
│ │ ├── errors.d.ts
│ │ ├── eventsource.d.ts
│ │ ├── fetch.d.ts
│ │ ├── file.d.ts
│ │ ├── filereader.d.ts
│ │ ├── formdata.d.ts
│ │ ├── global-dispatcher.d.ts
│ │ ├── global-origin.d.ts
│ │ ├── handlers.d.ts
│ │ ├── header.d.ts
│ │ ├── index.d.ts
│ │ ├── interceptors.d.ts
│ │ ├── LICENSE
│ │ ├── mock-agent.d.ts
│ │ ├── mock-client.d.ts
│ │ ├── mock-errors.d.ts
│ │ ├── mock-interceptor.d.ts
│ │ ├── mock-pool.d.ts
│ │ ├── package.json
│ │ ├── patch.d.ts
│ │ ├── pool-stats.d.ts
│ │ ├── pool.d.ts
│ │ ├── proxy-agent.d.ts
│ │ ├── readable.d.ts
│ │ ├── README.md
│ │ ├── retry-agent.d.ts
│ │ ├── retry-handler.d.ts
│ │ ├── util.d.ts
│ │ ├── webidl.d.ts
│ │ └── websocket.d.ts
│ ├── unpipe
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── which
│ │ ├── bin
│ │ │ └── node-which
│ │ ├── CHANGELOG.md
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── which.js
│ ├── wrap-ansi
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── wrap-ansi-cjs
│ │ ├── index.js
│ │ ├── license
│ │ ├── node_modules
│ │ │ ├── ansi-regex
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── license
│ │ │ │ ├── package.json
│ │ │ │ └── readme.md
│ │ │ ├── ansi-styles
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── license
│ │ │ │ ├── package.json
│ │ │ │ └── readme.md
│ │ │ ├── emoji-regex
│ │ │ │ ├── es2015
│ │ │ │ │ ├── index.js
│ │ │ │ │ └── text.js
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── LICENSE-MIT.txt
│ │ │ │ ├── package.json
│ │ │ │ ├── README.md
│ │ │ │ └── text.js
│ │ │ ├── string-width
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.js
│ │ │ │ ├── license
│ │ │ │ ├── package.json
│ │ │ │ └── readme.md
│ │ │ └── strip-ansi
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── license
│ │ │ ├── package.json
│ │ │ └── readme.md
│ │ ├── package.json
│ │ └── readme.md
│ └── zod
│ ├── index.cjs
│ ├── index.d.cts
│ ├── index.d.ts
│ ├── index.js
│ ├── LICENSE
│ ├── package.json
│ ├── README.md
│ ├── src
│ │ ├── index.ts
│ │ ├── v3
│ │ │ ├── benchmarks
│ │ │ │ ├── datetime.ts
│ │ │ │ ├── discriminatedUnion.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── ipv4.ts
│ │ │ │ ├── object.ts
│ │ │ │ ├── primitives.ts
│ │ │ │ ├── realworld.ts
│ │ │ │ ├── string.ts
│ │ │ │ └── union.ts
│ │ │ ├── errors.ts
│ │ │ ├── external.ts
│ │ │ ├── helpers
│ │ │ │ ├── enumUtil.ts
│ │ │ │ ├── errorUtil.ts
│ │ │ │ ├── parseUtil.ts
│ │ │ │ ├── partialUtil.ts
│ │ │ │ ├── typeAliases.ts
│ │ │ │ └── util.ts
│ │ │ ├── index.ts
│ │ │ ├── locales
│ │ │ │ └── en.ts
│ │ │ ├── standard-schema.ts
│ │ │ ├── tests
│ │ │ │ ├── all-errors.test.ts
│ │ │ │ ├── anyunknown.test.ts
│ │ │ │ ├── array.test.ts
│ │ │ │ ├── async-parsing.test.ts
│ │ │ │ ├── async-refinements.test.ts
│ │ │ │ ├── base.test.ts
│ │ │ │ ├── bigint.test.ts
│ │ │ │ ├── branded.test.ts
│ │ │ │ ├── catch.test.ts
│ │ │ │ ├── coerce.test.ts
│ │ │ │ ├── complex.test.ts
│ │ │ │ ├── custom.test.ts
│ │ │ │ ├── date.test.ts
│ │ │ │ ├── deepmasking.test.ts
│ │ │ │ ├── default.test.ts
│ │ │ │ ├── description.test.ts
│ │ │ │ ├── discriminated-unions.test.ts
│ │ │ │ ├── enum.test.ts
│ │ │ │ ├── error.test.ts
│ │ │ │ ├── firstparty.test.ts
│ │ │ │ ├── firstpartyschematypes.test.ts
│ │ │ │ ├── function.test.ts
│ │ │ │ ├── generics.test.ts
│ │ │ │ ├── instanceof.test.ts
│ │ │ │ ├── intersection.test.ts
│ │ │ │ ├── language-server.source.ts
│ │ │ │ ├── language-server.test.ts
│ │ │ │ ├── literal.test.ts
│ │ │ │ ├── map.test.ts
│ │ │ │ ├── masking.test.ts
│ │ │ │ ├── mocker.test.ts
│ │ │ │ ├── Mocker.ts
│ │ │ │ ├── nan.test.ts
│ │ │ │ ├── nativeEnum.test.ts
│ │ │ │ ├── nullable.test.ts
│ │ │ │ ├── number.test.ts
│ │ │ │ ├── object-augmentation.test.ts
│ │ │ │ ├── object-in-es5-env.test.ts
│ │ │ │ ├── object.test.ts
│ │ │ │ ├── optional.test.ts
│ │ │ │ ├── parser.test.ts
│ │ │ │ ├── parseUtil.test.ts
│ │ │ │ ├── partials.test.ts
│ │ │ │ ├── pickomit.test.ts
│ │ │ │ ├── pipeline.test.ts
│ │ │ │ ├── preprocess.test.ts
│ │ │ │ ├── primitive.test.ts
│ │ │ │ ├── promise.test.ts
│ │ │ │ ├── readonly.test.ts
│ │ │ │ ├── record.test.ts
│ │ │ │ ├── recursive.test.ts
│ │ │ │ ├── refine.test.ts
│ │ │ │ ├── safeparse.test.ts
│ │ │ │ ├── set.test.ts
│ │ │ │ ├── standard-schema.test.ts
│ │ │ │ ├── string.test.ts
│ │ │ │ ├── transformer.test.ts
│ │ │ │ ├── tuple.test.ts
│ │ │ │ ├── unions.test.ts
│ │ │ │ ├── validations.test.ts
│ │ │ │ └── void.test.ts
│ │ │ ├── types.ts
│ │ │ └── ZodError.ts
│ │ ├── v4
│ │ │ ├── classic
│ │ │ │ ├── checks.ts
│ │ │ │ ├── coerce.ts
│ │ │ │ ├── compat.ts
│ │ │ │ ├── errors.ts
│ │ │ │ ├── external.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── iso.ts
│ │ │ │ ├── parse.ts
│ │ │ │ ├── schemas.ts
│ │ │ │ └── tests
│ │ │ │ ├── anyunknown.test.ts
│ │ │ │ ├── array.test.ts
│ │ │ │ ├── assignability.test.ts
│ │ │ │ ├── async-parsing.test.ts
│ │ │ │ ├── async-refinements.test.ts
│ │ │ │ ├── base.test.ts
│ │ │ │ ├── bigint.test.ts
│ │ │ │ ├── brand.test.ts
│ │ │ │ ├── catch.test.ts
│ │ │ │ ├── coalesce.test.ts
│ │ │ │ ├── coerce.test.ts
│ │ │ │ ├── continuability.test.ts
│ │ │ │ ├── custom.test.ts
│ │ │ │ ├── date.test.ts
│ │ │ │ ├── datetime.test.ts
│ │ │ │ ├── default.test.ts
│ │ │ │ ├── description.test.ts
│ │ │ │ ├── discriminated-unions.test.ts
│ │ │ │ ├── enum.test.ts
│ │ │ │ ├── error-utils.test.ts
│ │ │ │ ├── error.test.ts
│ │ │ │ ├── file.test.ts
│ │ │ │ ├── firstparty.test.ts
│ │ │ │ ├── function.test.ts
│ │ │ │ ├── generics.test.ts
│ │ │ │ ├── index.test.ts
│ │ │ │ ├── instanceof.test.ts
│ │ │ │ ├── intersection.test.ts
│ │ │ │ ├── json.test.ts
│ │ │ │ ├── lazy.test.ts
│ │ │ │ ├── literal.test.ts
│ │ │ │ ├── map.test.ts
│ │ │ │ ├── nan.test.ts
│ │ │ │ ├── nested-refine.test.ts
│ │ │ │ ├── nonoptional.test.ts
│ │ │ │ ├── nullable.test.ts
│ │ │ │ ├── number.test.ts
│ │ │ │ ├── object.test.ts
│ │ │ │ ├── optional.test.ts
│ │ │ │ ├── partial.test.ts
│ │ │ │ ├── pickomit.test.ts
│ │ │ │ ├── pipe.test.ts
│ │ │ │ ├── prefault.test.ts
│ │ │ │ ├── preprocess.test.ts
│ │ │ │ ├── primitive.test.ts
│ │ │ │ ├── promise.test.ts
│ │ │ │ ├── prototypes.test.ts
│ │ │ │ ├── readonly.test.ts
│ │ │ │ ├── record.test.ts
│ │ │ │ ├── recursive-types.test.ts
│ │ │ │ ├── refine.test.ts
│ │ │ │ ├── registries.test.ts
│ │ │ │ ├── set.test.ts
│ │ │ │ ├── standard-schema.test.ts
│ │ │ │ ├── string-formats.test.ts
│ │ │ │ ├── string.test.ts
│ │ │ │ ├── stringbool.test.ts
│ │ │ │ ├── template-literal.test.ts
│ │ │ │ ├── to-json-schema.test.ts
│ │ │ │ ├── transform.test.ts
│ │ │ │ ├── tuple.test.ts
│ │ │ │ ├── union.test.ts
│ │ │ │ ├── validations.test.ts
│ │ │ │ └── void.test.ts
│ │ │ ├── core
│ │ │ │ ├── api.ts
│ │ │ │ ├── checks.ts
│ │ │ │ ├── config.ts
│ │ │ │ ├── core.ts
│ │ │ │ ├── doc.ts
│ │ │ │ ├── errors.ts
│ │ │ │ ├── function.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── json-schema.ts
│ │ │ │ ├── parse.ts
│ │ │ │ ├── regexes.ts
│ │ │ │ ├── registries.ts
│ │ │ │ ├── schemas.ts
│ │ │ │ ├── standard-schema.ts
│ │ │ │ ├── tests
│ │ │ │ │ ├── index.test.ts
│ │ │ │ │ └── locales
│ │ │ │ │ ├── be.test.ts
│ │ │ │ │ ├── en.test.ts
│ │ │ │ │ ├── ru.test.ts
│ │ │ │ │ └── tr.test.ts
│ │ │ │ ├── to-json-schema.ts
│ │ │ │ ├── util.ts
│ │ │ │ ├── versions.ts
│ │ │ │ └── zsf.ts
│ │ │ ├── index.ts
│ │ │ ├── locales
│ │ │ │ ├── ar.ts
│ │ │ │ ├── az.ts
│ │ │ │ ├── be.ts
│ │ │ │ ├── ca.ts
│ │ │ │ ├── cs.ts
│ │ │ │ ├── de.ts
│ │ │ │ ├── en.ts
│ │ │ │ ├── eo.ts
│ │ │ │ ├── es.ts
│ │ │ │ ├── fa.ts
│ │ │ │ ├── fi.ts
│ │ │ │ ├── fr-CA.ts
│ │ │ │ ├── fr.ts
│ │ │ │ ├── he.ts
│ │ │ │ ├── hu.ts
│ │ │ │ ├── id.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── it.ts
│ │ │ │ ├── ja.ts
│ │ │ │ ├── kh.ts
│ │ │ │ ├── ko.ts
│ │ │ │ ├── mk.ts
│ │ │ │ ├── ms.ts
│ │ │ │ ├── nl.ts
│ │ │ │ ├── no.ts
│ │ │ │ ├── ota.ts
│ │ │ │ ├── pl.ts
│ │ │ │ ├── ps.ts
│ │ │ │ ├── pt.ts
│ │ │ │ ├── ru.ts
│ │ │ │ ├── sl.ts
│ │ │ │ ├── sv.ts
│ │ │ │ ├── ta.ts
│ │ │ │ ├── th.ts
│ │ │ │ ├── tr.ts
│ │ │ │ ├── ua.ts
│ │ │ │ ├── ur.ts
│ │ │ │ ├── vi.ts
│ │ │ │ ├── zh-CN.ts
│ │ │ │ └── zh-TW.ts
│ │ │ └── mini
│ │ │ ├── checks.ts
│ │ │ ├── coerce.ts
│ │ │ ├── external.ts
│ │ │ ├── index.ts
│ │ │ ├── iso.ts
│ │ │ ├── parse.ts
│ │ │ ├── schemas.ts
│ │ │ └── tests
│ │ │ ├── assignability.test.ts
│ │ │ ├── brand.test.ts
│ │ │ ├── checks.test.ts
│ │ │ ├── computed.test.ts
│ │ │ ├── error.test.ts
│ │ │ ├── functions.test.ts
│ │ │ ├── index.test.ts
│ │ │ ├── number.test.ts
│ │ │ ├── object.test.ts
│ │ │ ├── prototypes.test.ts
│ │ │ ├── recursive-types.test.ts
│ │ │ └── string.test.ts
│ │ └── v4-mini
│ │ └── index.ts
│ ├── v3
│ │ ├── errors.cjs
│ │ ├── errors.d.cts
│ │ ├── errors.d.ts
│ │ ├── errors.js
│ │ ├── external.cjs
│ │ ├── external.d.cts
│ │ ├── external.d.ts
│ │ ├── external.js
│ │ ├── helpers
│ │ │ ├── enumUtil.cjs
│ │ │ ├── enumUtil.d.cts
│ │ │ ├── enumUtil.d.ts
│ │ │ ├── enumUtil.js
│ │ │ ├── errorUtil.cjs
│ │ │ ├── errorUtil.d.cts
│ │ │ ├── errorUtil.d.ts
│ │ │ ├── errorUtil.js
│ │ │ ├── parseUtil.cjs
│ │ │ ├── parseUtil.d.cts
│ │ │ ├── parseUtil.d.ts
│ │ │ ├── parseUtil.js
│ │ │ ├── partialUtil.cjs
│ │ │ ├── partialUtil.d.cts
│ │ │ ├── partialUtil.d.ts
│ │ │ ├── partialUtil.js
│ │ │ ├── typeAliases.cjs
│ │ │ ├── typeAliases.d.cts
│ │ │ ├── typeAliases.d.ts
│ │ │ ├── typeAliases.js
│ │ │ ├── util.cjs
│ │ │ ├── util.d.cts
│ │ │ ├── util.d.ts
│ │ │ └── util.js
│ │ ├── index.cjs
│ │ ├── index.d.cts
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── locales
│ │ │ ├── en.cjs
│ │ │ ├── en.d.cts
│ │ │ ├── en.d.ts
│ │ │ └── en.js
│ │ ├── standard-schema.cjs
│ │ ├── standard-schema.d.cts
│ │ ├── standard-schema.d.ts
│ │ ├── standard-schema.js
│ │ ├── types.cjs
│ │ ├── types.d.cts
│ │ ├── types.d.ts
│ │ ├── types.js
│ │ ├── ZodError.cjs
│ │ ├── ZodError.d.cts
│ │ ├── ZodError.d.ts
│ │ └── ZodError.js
│ ├── v4
│ │ ├── classic
│ │ │ ├── checks.cjs
│ │ │ ├── checks.d.cts
│ │ │ ├── checks.d.ts
│ │ │ ├── checks.js
│ │ │ ├── coerce.cjs
│ │ │ ├── coerce.d.cts
│ │ │ ├── coerce.d.ts
│ │ │ ├── coerce.js
│ │ │ ├── compat.cjs
│ │ │ ├── compat.d.cts
│ │ │ ├── compat.d.ts
│ │ │ ├── compat.js
│ │ │ ├── errors.cjs
│ │ │ ├── errors.d.cts
│ │ │ ├── errors.d.ts
│ │ │ ├── errors.js
│ │ │ ├── external.cjs
│ │ │ ├── external.d.cts
│ │ │ ├── external.d.ts
│ │ │ ├── external.js
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── iso.cjs
│ │ │ ├── iso.d.cts
│ │ │ ├── iso.d.ts
│ │ │ ├── iso.js
│ │ │ ├── parse.cjs
│ │ │ ├── parse.d.cts
│ │ │ ├── parse.d.ts
│ │ │ ├── parse.js
│ │ │ ├── schemas.cjs
│ │ │ ├── schemas.d.cts
│ │ │ ├── schemas.d.ts
│ │ │ └── schemas.js
│ │ ├── core
│ │ │ ├── api.cjs
│ │ │ ├── api.d.cts
│ │ │ ├── api.d.ts
│ │ │ ├── api.js
│ │ │ ├── checks.cjs
│ │ │ ├── checks.d.cts
│ │ │ ├── checks.d.ts
│ │ │ ├── checks.js
│ │ │ ├── core.cjs
│ │ │ ├── core.d.cts
│ │ │ ├── core.d.ts
│ │ │ ├── core.js
│ │ │ ├── doc.cjs
│ │ │ ├── doc.d.cts
│ │ │ ├── doc.d.ts
│ │ │ ├── doc.js
│ │ │ ├── errors.cjs
│ │ │ ├── errors.d.cts
│ │ │ ├── errors.d.ts
│ │ │ ├── errors.js
│ │ │ ├── function.cjs
│ │ │ ├── function.d.cts
│ │ │ ├── function.d.ts
│ │ │ ├── function.js
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── json-schema.cjs
│ │ │ ├── json-schema.d.cts
│ │ │ ├── json-schema.d.ts
│ │ │ ├── json-schema.js
│ │ │ ├── parse.cjs
│ │ │ ├── parse.d.cts
│ │ │ ├── parse.d.ts
│ │ │ ├── parse.js
│ │ │ ├── regexes.cjs
│ │ │ ├── regexes.d.cts
│ │ │ ├── regexes.d.ts
│ │ │ ├── regexes.js
│ │ │ ├── registries.cjs
│ │ │ ├── registries.d.cts
│ │ │ ├── registries.d.ts
│ │ │ ├── registries.js
│ │ │ ├── schemas.cjs
│ │ │ ├── schemas.d.cts
│ │ │ ├── schemas.d.ts
│ │ │ ├── schemas.js
│ │ │ ├── standard-schema.cjs
│ │ │ ├── standard-schema.d.cts
│ │ │ ├── standard-schema.d.ts
│ │ │ ├── standard-schema.js
│ │ │ ├── to-json-schema.cjs
│ │ │ ├── to-json-schema.d.cts
│ │ │ ├── to-json-schema.d.ts
│ │ │ ├── to-json-schema.js
│ │ │ ├── util.cjs
│ │ │ ├── util.d.cts
│ │ │ ├── util.d.ts
│ │ │ ├── util.js
│ │ │ ├── versions.cjs
│ │ │ ├── versions.d.cts
│ │ │ ├── versions.d.ts
│ │ │ └── versions.js
│ │ ├── index.cjs
│ │ ├── index.d.cts
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── locales
│ │ │ ├── ar.cjs
│ │ │ ├── ar.d.cts
│ │ │ ├── ar.d.ts
│ │ │ ├── ar.js
│ │ │ ├── az.cjs
│ │ │ ├── az.d.cts
│ │ │ ├── az.d.ts
│ │ │ ├── az.js
│ │ │ ├── be.cjs
│ │ │ ├── be.d.cts
│ │ │ ├── be.d.ts
│ │ │ ├── be.js
│ │ │ ├── ca.cjs
│ │ │ ├── ca.d.cts
│ │ │ ├── ca.d.ts
│ │ │ ├── ca.js
│ │ │ ├── cs.cjs
│ │ │ ├── cs.d.cts
│ │ │ ├── cs.d.ts
│ │ │ ├── cs.js
│ │ │ ├── de.cjs
│ │ │ ├── de.d.cts
│ │ │ ├── de.d.ts
│ │ │ ├── de.js
│ │ │ ├── en.cjs
│ │ │ ├── en.d.cts
│ │ │ ├── en.d.ts
│ │ │ ├── en.js
│ │ │ ├── eo.cjs
│ │ │ ├── eo.d.cts
│ │ │ ├── eo.d.ts
│ │ │ ├── eo.js
│ │ │ ├── es.cjs
│ │ │ ├── es.d.cts
│ │ │ ├── es.d.ts
│ │ │ ├── es.js
│ │ │ ├── fa.cjs
│ │ │ ├── fa.d.cts
│ │ │ ├── fa.d.ts
│ │ │ ├── fa.js
│ │ │ ├── fi.cjs
│ │ │ ├── fi.d.cts
│ │ │ ├── fi.d.ts
│ │ │ ├── fi.js
│ │ │ ├── fr-CA.cjs
│ │ │ ├── fr-CA.d.cts
│ │ │ ├── fr-CA.d.ts
│ │ │ ├── fr-CA.js
│ │ │ ├── fr.cjs
│ │ │ ├── fr.d.cts
│ │ │ ├── fr.d.ts
│ │ │ ├── fr.js
│ │ │ ├── he.cjs
│ │ │ ├── he.d.cts
│ │ │ ├── he.d.ts
│ │ │ ├── he.js
│ │ │ ├── hu.cjs
│ │ │ ├── hu.d.cts
│ │ │ ├── hu.d.ts
│ │ │ ├── hu.js
│ │ │ ├── id.cjs
│ │ │ ├── id.d.cts
│ │ │ ├── id.d.ts
│ │ │ ├── id.js
│ │ │ ├── index.cjs
│ │ │ ├── index.d.cts
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── it.cjs
│ │ │ ├── it.d.cts
│ │ │ ├── it.d.ts
│ │ │ ├── it.js
│ │ │ ├── ja.cjs
│ │ │ ├── ja.d.cts
│ │ │ ├── ja.d.ts
│ │ │ ├── ja.js
│ │ │ ├── kh.cjs
│ │ │ ├── kh.d.cts
│ │ │ ├── kh.d.ts
│ │ │ ├── kh.js
│ │ │ ├── ko.cjs
│ │ │ ├── ko.d.cts
│ │ │ ├── ko.d.ts
│ │ │ ├── ko.js
│ │ │ ├── mk.cjs
│ │ │ ├── mk.d.cts
│ │ │ ├── mk.d.ts
│ │ │ ├── mk.js
│ │ │ ├── ms.cjs
│ │ │ ├── ms.d.cts
│ │ │ ├── ms.d.ts
│ │ │ ├── ms.js
│ │ │ ├── nl.cjs
│ │ │ ├── nl.d.cts
│ │ │ ├── nl.d.ts
│ │ │ ├── nl.js
│ │ │ ├── no.cjs
│ │ │ ├── no.d.cts
│ │ │ ├── no.d.ts
│ │ │ ├── no.js
│ │ │ ├── ota.cjs
│ │ │ ├── ota.d.cts
│ │ │ ├── ota.d.ts
│ │ │ ├── ota.js
│ │ │ ├── pl.cjs
│ │ │ ├── pl.d.cts
│ │ │ ├── pl.d.ts
│ │ │ ├── pl.js
│ │ │ ├── ps.cjs
│ │ │ ├── ps.d.cts
│ │ │ ├── ps.d.ts
│ │ │ ├── ps.js
│ │ │ ├── pt.cjs
│ │ │ ├── pt.d.cts
│ │ │ ├── pt.d.ts
│ │ │ ├── pt.js
│ │ │ ├── ru.cjs
│ │ │ ├── ru.d.cts
│ │ │ ├── ru.d.ts
│ │ │ ├── ru.js
│ │ │ ├── sl.cjs
│ │ │ ├── sl.d.cts
│ │ │ ├── sl.d.ts
│ │ │ ├── sl.js
│ │ │ ├── sv.cjs
│ │ │ ├── sv.d.cts
│ │ │ ├── sv.d.ts
│ │ │ ├── sv.js
│ │ │ ├── ta.cjs
│ │ │ ├── ta.d.cts
│ │ │ ├── ta.d.ts
│ │ │ ├── ta.js
│ │ │ ├── th.cjs
│ │ │ ├── th.d.cts
│ │ │ ├── th.d.ts
│ │ │ ├── th.js
│ │ │ ├── tr.cjs
│ │ │ ├── tr.d.cts
│ │ │ ├── tr.d.ts
│ │ │ ├── tr.js
│ │ │ ├── ua.cjs
│ │ │ ├── ua.d.cts
│ │ │ ├── ua.d.ts
│ │ │ ├── ua.js
│ │ │ ├── ur.cjs
│ │ │ ├── ur.d.cts
│ │ │ ├── ur.d.ts
│ │ │ ├── ur.js
│ │ │ ├── vi.cjs
│ │ │ ├── vi.d.cts
│ │ │ ├── vi.d.ts
│ │ │ ├── vi.js
│ │ │ ├── zh-CN.cjs
│ │ │ ├── zh-CN.d.cts
│ │ │ ├── zh-CN.d.ts
│ │ │ ├── zh-CN.js
│ │ │ ├── zh-TW.cjs
│ │ │ ├── zh-TW.d.cts
│ │ │ ├── zh-TW.d.ts
│ │ │ └── zh-TW.js
│ │ └── mini
│ │ ├── checks.cjs
│ │ ├── checks.d.cts
│ │ ├── checks.d.ts
│ │ ├── checks.js
│ │ ├── coerce.cjs
│ │ ├── coerce.d.cts
│ │ ├── coerce.d.ts
│ │ ├── coerce.js
│ │ ├── external.cjs
│ │ ├── external.d.cts
│ │ ├── external.d.ts
│ │ ├── external.js
│ │ ├── index.cjs
│ │ ├── index.d.cts
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── iso.cjs
│ │ ├── iso.d.cts
│ │ ├── iso.d.ts
│ │ ├── iso.js
│ │ ├── parse.cjs
│ │ ├── parse.d.cts
│ │ ├── parse.d.ts
│ │ ├── parse.js
│ │ ├── schemas.cjs
│ │ ├── schemas.d.cts
│ │ ├── schemas.d.ts
│ │ └── schemas.js
│ └── v4-mini
│ ├── index.cjs
│ ├── index.d.cts
│ ├── index.d.ts
│ └── index.js
├── package-lock.json
├── package.json
├── README.ko.md
├── README.kr.md
├── README.md
├── src
│ ├── agentDownloader.ts
│ ├── agentManager.ts
│ ├── aiAnalysisService.ts
│ ├── analytics.ts
│ ├── githubIntegration.ts
│ ├── index.ts
│ ├── projectAnalyzer.ts
│ └── splashCommand.ts
├── start.sh
├── test-CLAUDE.md
├── test-server.js
├── TROUBLESHOOTING.md
├── tsconfig.json
└── USER_GUIDE.md
```
# Files
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
ListResourcesRequestSchema,
ReadResourceRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
import { Command } from 'commander';
import { ProjectAnalyzer } from './projectAnalyzer.js';
import { AgentManager } from './agentManager.js';
import { initializeAnalytics, trackEvent, AnalyticsEvents, shutdown as shutdownAnalytics } from './analytics.js';
import path from 'path';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
import fs from 'fs';
import os from 'os';
import dotenv from 'dotenv';
import { AgentDownloader, DownloadOptions } from './agentDownloader.js';
import { AIAnalysisService, AIAgentRecommendation } from './aiAnalysisService.js';
import { executeSplashCommand } from './splashCommand.js';
// ES module compatibility
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
// Load environment variables from .env file
dotenv.config();
// Get version from package.json
const packageJsonPath = path.join(__dirname, '../package.json');
let version = '1.6.0'; // fallback version
try {
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
version = packageJson.version;
} catch (error) {
console.error('[MCP Sub-Agents] Could not read package.json version:', error);
}
// Check for splash and other special commands first (manual parsing to avoid commander issues)
const hasSplash = process.argv.includes('splash') || process.argv.includes('--splash');
const hasInstall = process.argv.includes('--install');
const hasInstallSlashCommands = process.argv.includes('--install-slash-commands');
const hasUninstallSlashCommands = process.argv.includes('--uninstall-slash-commands');
const hasAgentDownload = process.argv.includes('--agent-download');
const hasInstallCC = process.argv.includes('--install-cc');
// Parse CLI arguments using commander
const program = new Command()
.name('claude-agents-power')
.version(version)
.option('--transport <stdio>', 'transport type', 'stdio')
.option('--debug', 'enable debug logging')
.option('--install', 'install MCP configuration to Claude Desktop')
.option('--install-cc', 'show claude mcp add command for Claude Code')
.option('--install-slash-commands', 'install slash commands to Claude Code')
.option('--uninstall-slash-commands', 'uninstall slash commands from Claude Code')
.option('--agent-download', 'download recommended agents for current project')
.option('--target-dir <dir>', 'target directory for agent files (default: "./agents")')
.option('--claude-md <path>', 'path to CLAUDE.md file (default: "./CLAUDE.md")')
.option('--format <format>', 'agent file format: md, yaml, json (default: "md")')
.option('--language <lang>', 'preferred language: en, ko, ja, zh (default: "en")')
.option('--limit <n>', 'maximum number of agents to download (default: 10)')
.option('--dry-run', 'preview recommendations without downloading')
.option('--overwrite', 'overwrite existing agent files')
.allowUnknownOption(); // let MCP Inspector / other wrappers pass through extra flags
// Add splash command (only if not already handled by early exit)
if (!hasSplash) {
program
.command('splash')
.description('Quick setup: analyze project and recommend agents')
.action(async () => {
try {
await initializeAnalytics();
trackEvent(AnalyticsEvents.TOOL_CALLED, { tool_name: 'splash', version });
const result = await executeSplashCommand();
if (!result.success) {
console.error('❌ Splash command failed:', result.error || result.message);
process.exit(1);
}
await shutdownAnalytics();
process.exit(0);
} catch (error) {
console.error('❌ Splash command error:', error);
process.exit(1);
}
});
}
// Handle splash command early before parsing
if (hasSplash) {
// Skip to splash command execution
(async () => {
try {
await initializeAnalytics();
trackEvent(AnalyticsEvents.TOOL_CALLED, { tool_name: 'splash', version });
const result = await executeSplashCommand();
if (!result.success) {
console.error('❌ Splash command failed:', result.error || result.message);
process.exit(1);
}
await shutdownAnalytics();
process.exit(0);
} catch (error) {
console.error('❌ Splash command error:', error);
process.exit(1);
}
})();
}
// Early exit for install to avoid commander parsing issues
if (hasInstall) {
console.log('🚀 Claude Agents Power MCP Installer\n');
// Get Claude Desktop config path
const configPaths = [
path.join(os.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
path.join(os.homedir(), '.config', 'claude', 'claude_desktop_config.json'),
path.join(os.homedir(), 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json')
];
let configPath = null;
for (const p of configPaths) {
if (fs.existsSync(p)) {
configPath = p;
break;
}
}
if (!configPath) {
// Try to find Claude config directory
const configDirs = [
path.join(os.homedir(), 'Library', 'Application Support', 'Claude'),
path.join(os.homedir(), '.config', 'claude'),
path.join(os.homedir(), 'AppData', 'Roaming', 'Claude')
];
for (const dir of configDirs) {
if (fs.existsSync(dir)) {
configPath = path.join(dir, 'claude_desktop_config.json');
break;
}
}
}
if (!configPath) {
console.error('❌ Could not find Claude Desktop configuration directory');
console.log('\nPlease create the config file manually at one of these locations:');
configPaths.forEach(p => console.log(` - ${p}`));
process.exit(1);
}
console.log(`📁 Found Claude config at: ${configPath}`);
// Read existing config or create new one
let config: any = { mcpServers: {} };
if (fs.existsSync(configPath)) {
try {
const content = fs.readFileSync(configPath, 'utf8');
config = JSON.parse(content);
if (!config.mcpServers) {
config.mcpServers = {};
}
} catch (error) {
console.error('⚠️ Error reading existing config, will create new one');
}
}
// Check if already installed
if (config.mcpServers['claude-agents-power']) {
console.log('✅ claude-agents-power is already configured in Claude Desktop');
console.log('\nTo update, remove the existing entry and run this installer again.');
process.exit(0);
}
// Add claude-agents-power to config
config.mcpServers['claude-agents-power'] = {
command: 'npx',
args: ['claude-agents-power']
};
// Write config
try {
// Create directory if it doesn't exist
const dir = path.dirname(configPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
console.log('✅ Successfully added claude-agents-power to Claude Desktop configuration');
console.log('\n📝 Next steps:');
console.log('1. Restart Claude Desktop');
console.log('2. Look for MCP tools starting with "mcp__claude-agents-power__"');
console.log('\n🎯 Example usage in Claude:');
console.log(' "claude-agents-power를 이용해서 이 프로젝트를 위한 추천 및 agents/*.md 파일을 다운로드 해줘"');
} catch (error: any) {
console.error('❌ Error writing configuration:', error.message);
console.log('\nPlease add this to your claude_desktop_config.json manually:');
console.log(JSON.stringify({
mcpServers: {
'claude-agents-power': {
command: 'npx',
args: ['claude-agents-power']
}
}
}, null, 2));
process.exit(1);
}
process.exit(0);
}
// Early exit for install-cc to avoid commander parsing issues
if (hasInstallCC) {
(async () => {
console.log('🚀 Claude Agents Power - Claude Code MCP Installation\n');
// Check if globally installed via npm
let isGloballyInstalled = false;
try {
const { execSync } = await import('child_process');
execSync('npm list -g claude-agents-power', { stdio: 'pipe' });
isGloballyInstalled = true;
} catch {
// Not globally installed
}
console.log('📋 Copy and paste one of these commands into Claude Code:\n');
if (isGloballyInstalled) {
console.log(' Option 1 (Recommended - NPM global package):');
console.log(' ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
console.log(' claude mcp add claude-agents-power');
console.log('');
}
// Get the current user's home directory and construct the path
const currentDir = process.cwd();
const homeDir = os.homedir();
const username = path.basename(homeDir);
// Determine the actual path to this MCP server
let serverPath: string;
// Check if we're running from the source directory (development)
if (currentDir.includes('claude-agents-power-mcp-server')) {
serverPath = currentDir;
} else {
// Default to the expected installation location
serverPath = path.join(homeDir, 'Claude', 'claude-agents-power', 'claude-agents-power-mcp-server');
}
console.log(' Option 2 (Local file path):');
console.log(' ━━━━━━━━━━━━━━━━━━━━━━━━━');
console.log(` claude mcp add file://${serverPath}`);
console.log('');
console.log('📍 Installation Details:');
if (isGloballyInstalled) {
console.log(' ✅ Package is globally installed via NPM');
}
console.log(` 📁 Local Path: ${serverPath}`);
console.log(` 👤 User: ${username}`);
console.log('');
console.log('💡 Usage Tips:');
console.log(' • Use Option 1 if you installed via npm install -g');
console.log(' • Use Option 2 if you cloned the repository locally');
console.log(' • The MCP server will be available immediately after adding');
console.log('');
console.log('📝 Next steps after running the command:');
console.log(' 1. Claude Code will recognize the MCP server');
console.log(' 2. Use tools like "analyze-project" and "agents" in your conversations');
console.log(' 3. Get agent recommendations and download them to your projects');
process.exit(0);
})();
}
program.parse(process.argv);
const cliOptions = program.opts<{
transport: string;
debug?: boolean;
install?: boolean;
installCc?: boolean;
installSlashCommands?: boolean;
uninstallSlashCommands?: boolean;
agentDownload?: boolean;
targetDir?: string;
claudeMd?: string;
format?: string;
language?: string;
limit?: string;
dryRun?: boolean;
overwrite?: boolean;
}>();
// Override with manual parsing results
if (hasInstallSlashCommands) {
cliOptions.installSlashCommands = true;
}
if (hasUninstallSlashCommands) {
cliOptions.uninstallSlashCommands = true;
}
if (hasAgentDownload) {
cliOptions.agentDownload = true;
}
if (hasInstallCC) {
cliOptions.installCc = true;
}
// Handle --install-slash-commands flag
if (cliOptions.installSlashCommands) {
console.log('🚀 Claude Agents Power - Slash Commands Installer\n');
try {
const claudeDir = path.join(os.homedir(), '.claude');
const commandsDir = path.join(claudeDir, 'commands');
const sourceDir = path.join(__dirname, '../claude-slash-commands');
// Create directories if they don't exist
if (!fs.existsSync(claudeDir)) {
fs.mkdirSync(claudeDir, { recursive: true });
console.log(`📁 Created: ${claudeDir}`);
}
if (!fs.existsSync(commandsDir)) {
fs.mkdirSync(commandsDir, { recursive: true });
console.log(`📁 Created: ${commandsDir}`);
}
// Copy command files
console.log('📋 Installing slash commands...');
const commandFiles = fs.readdirSync(sourceDir);
for (const file of commandFiles) {
if (file.endsWith('.md')) {
const sourcePath = path.join(sourceDir, file);
const targetPath = path.join(commandsDir, file);
fs.copyFileSync(sourcePath, targetPath);
console.log(` ✅ Installed: ${file}`);
}
}
// Create README
const readmeContent = `# Claude Agents Power - Slash Commands
Available commands:
- /agents:load - Load and display available agents
- /agents:search - Search agents by skills or keywords
- /agents:suggest - Get intelligent agent recommendations
- /agents:version - Check system version and status
Generated by claude-agents-power v${version}
`;
fs.writeFileSync(path.join(commandsDir, 'README.md'), readmeContent);
console.log('\n✅ Slash commands installed successfully!');
console.log('\nAvailable commands in Claude Code:');
console.log(' /agents:load - Load and display available agents');
console.log(' /agents:search - Search agents by skills or keywords');
console.log(' /agents:suggest - Get intelligent agent recommendations');
console.log(' /agents:version - Check system version and status');
console.log('\n💡 Try "/agents:load" in Claude Code to get started!');
} catch (error) {
console.error('❌ Installation failed:', error);
process.exit(1);
}
process.exit(0);
}
// Handle --uninstall-slash-commands flag
if (cliOptions.uninstallSlashCommands) {
console.log('🗑️ Uninstalling claude-agents-power slash commands...\n');
try {
const commandsDir = path.join(os.homedir(), '.claude', 'commands');
if (fs.existsSync(commandsDir)) {
const files = fs.readdirSync(commandsDir);
const agentCommandFiles = files.filter(file => file.startsWith('agents-') && file.endsWith('.md'));
for (const file of agentCommandFiles) {
const filePath = path.join(commandsDir, file);
fs.unlinkSync(filePath);
console.log(` 🗑️ Removed: ${file}`);
}
// Remove README if it exists
const readmePath = path.join(commandsDir, 'README.md');
if (fs.existsSync(readmePath)) {
fs.unlinkSync(readmePath);
console.log(' 🗑️ Removed: README.md');
}
console.log('\n✅ Slash commands uninstalled successfully!');
} else {
console.log('No slash commands found to uninstall.');
}
} catch (error) {
console.error('❌ Uninstallation failed:', error);
process.exit(1);
}
process.exit(0);
}
// Handle --agent-download flag
if (cliOptions.agentDownload) {
console.log('🤖 Claude Agents Power - Agent Downloader\n');
try {
const downloader = new AgentDownloader();
const options: DownloadOptions = {
targetDir: cliOptions.targetDir || './agents',
claudeMdPath: cliOptions.claudeMd || './CLAUDE.md',
format: (cliOptions.format as 'md' | 'yaml' | 'json') || 'md',
language: (cliOptions.language as 'en' | 'ko' | 'ja' | 'zh') || 'en',
limit: cliOptions.limit ? parseInt(cliOptions.limit) : 10,
dryRun: cliOptions.dryRun || false,
overwrite: cliOptions.overwrite || false
};
console.log('🔍 Analyzing project...');
const result = await downloader.downloadAgents(options);
// Display enhanced AI analysis results
console.log('\n🧠 AI-Powered Project Analysis Results:');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
console.log(`📊 Project Type: ${result.analysis.projectType}`);
console.log(`🛠️ Technologies: ${result.analysis.technologies.join(', ') || 'None detected'}`);
console.log(`📚 Frameworks: ${result.analysis.frameworks.join(', ') || 'None detected'}`);
console.log(`📈 Complexity: ${result.analysis.complexity}/10`);
console.log(`🚀 Development Phase: ${result.analysis.phase}`);
console.log(`👥 Recommended Team Size: ${result.analysis.teamSize} agents`);
if (result.analysis.description) {
console.log(`📝 Description: ${result.analysis.description}`);
}
// Display quality indicators
if (result.analysis.qualityIndicators) {
console.log('\n📋 Quality Assessment:');
const qi = result.analysis.qualityIndicators;
console.log(` ${qi.hasTests ? '✅' : '❌'} Automated Testing`);
console.log(` ${qi.hasDocumentation ? '✅' : '❌'} Documentation`);
console.log(` ${qi.hasCI ? '✅' : '✅'} CI/CD Pipeline`);
console.log(` ${qi.hasLinting ? '✅' : '❌'} Code Quality Tools`);
console.log(` 📊 Code Complexity: ${qi.codeComplexity}`);
}
// Display architectural patterns if available
if (result.analysis.architecturalPatterns && result.analysis.architecturalPatterns.length > 0) {
console.log(`\n🏗️ Architectural Patterns: ${result.analysis.architecturalPatterns.join(', ')}`);
}
// Display development practices if available
if (result.analysis.developmentPractices && result.analysis.developmentPractices.length > 0) {
console.log(`\n⚙️ Development Practices: ${result.analysis.developmentPractices.join(', ')}`);
}
console.log('\n🏆 AI-Generated Recommendations:');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
result.recommendations.forEach((rec, index) => {
const icon = rec.priority === 'essential' ? '⭐' :
rec.priority === 'recommended' ? '🔧' : '💡';
console.log(`${index + 1}. ${icon} ${rec.name} (${rec.relevanceScore}% match)`);
console.log(` └─ ${rec.reasoning}`);
// Display specific tasks if available
if (rec.specificTasks && rec.specificTasks.length > 0) {
console.log(` 🎯 Key Tasks: ${rec.specificTasks.slice(0, 2).join(', ')}${rec.specificTasks.length > 2 ? '...' : ''}`);
}
// Display integration points if available
if (rec.integrationPoints && rec.integrationPoints.length > 0) {
console.log(` 🔗 Integrations: ${rec.integrationPoints.slice(0, 2).join(', ')}${rec.integrationPoints.length > 2 ? '...' : ''}`);
}
});
if (options.dryRun) {
console.log('\n💡 This was an AI-powered dry run analysis. Use without --dry-run to download agents.');
console.log('\n🧠 AI Analysis Features Used:');
console.log(' • Intelligent project structure analysis');
console.log(' • Context-aware agent recommendations');
console.log(' • Dynamic priority assignment');
console.log(' • Task-specific role matching');
} else if (result.downloaded && result.downloaded.length > 0) {
console.log('\n📥 Downloaded AI-Recommended Agents:');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
result.downloaded.forEach(filePath => {
const fileName = path.basename(filePath);
const fileSize = fs.statSync(filePath).size;
const fileSizeKB = (fileSize / 1024).toFixed(1);
console.log(`✅ ${fileName.padEnd(25)} (${fileSizeKB}KB)`);
});
console.log('\n📊 AI-Powered Summary:');
console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
console.log(`✅ ${result.downloaded.length} agents intelligently selected and downloaded`);
console.log(`📁 Files saved to: ${options.targetDir}`);
console.log(`📋 Enhanced README.md created with AI analysis insights`);
console.log(`🧠 AI Features: Dynamic analysis, context-aware recommendations, smart prioritization`);
console.log(`💡 Next: Try using your AI-recommended agents in your development workflow`);
}
} catch (error) {
console.error('❌ Agent download failed:', error);
process.exit(1);
}
process.exit(0);
}
// Debug logging function
const debug = (...args: any[]) => {
if (cliOptions.debug) {
console.error('[MCP Sub-Agents DEBUG]', ...args);
}
};
// Validate transport option
const allowedTransports = ['stdio'];
if (!allowedTransports.includes(cliOptions.transport)) {
console.error(
`Invalid --transport value: '${cliOptions.transport}'. Must be: stdio.`
);
process.exit(1);
}
// Transport configuration
const TRANSPORT_TYPE = 'stdio';
// Function to create a new server instance with all tools registered
function createServerInstance() {
const server = new Server(
{
name: 'claude-agents-power-mcp-server',
version: version,
},
{
capabilities: {
tools: {},
resources: {},
},
}
);
return server;
}
// Initialize analytics
initializeAnalytics();
trackEvent(AnalyticsEvents.SERVER_STARTED, {
debug_mode: cliOptions.debug,
transport: cliOptions.transport,
});
// Initialize managers
// Support both development and production paths
const isDevelopment = process.env.NODE_ENV === 'development';
// Try multiple possible agent paths
let agentsPath: string;
const possiblePaths = [
// Development path
path.join(__dirname, '../../claude/agents'),
// Production NPM global install
path.join(__dirname, '../claude/agents'),
// Alternative production path
path.resolve(process.cwd(), 'claude/agents'),
// NPM package structure
path.join(__dirname, '..', '..', 'claude', 'agents'),
];
// Find the first existing path
agentsPath = possiblePaths.find(p => {
const exists = existsSync(p);
if (cliOptions.debug) {
console.error(`[MCP Sub-Agents DEBUG] Checking path: ${p} - ${exists ? 'EXISTS' : 'NOT FOUND'}`);
}
return exists;
}) || possiblePaths[0];
debug(`Current working directory: ${process.cwd()}`);
debug(`__dirname: ${__dirname}`);
debug(`Loading agents from: ${agentsPath}`);
// Check if agents directory exists
import { existsSync } from 'fs';
if (cliOptions.debug && existsSync(agentsPath)) {
debug(`Agents directory exists: ${agentsPath}`);
const { readdirSync } = await import('fs');
const files = readdirSync(agentsPath);
debug(`Found ${files.length} files in agents directory`);
} else if (cliOptions.debug) {
debug(`ERROR: Agents directory not found: ${agentsPath}`);
}
const projectAnalyzer = new ProjectAnalyzer();
const agentManager = new AgentManager(agentsPath, {
owner: 'baryonlabs',
repo: 'claude-sub-agent-contents',
branch: 'main',
path: 'claude/agents'
}, cliOptions.debug || false);
const aiAnalysisService = new AIAnalysisService();
// Function to setup tools for a server instance
function setupTools(server: Server, projectAnalyzer: ProjectAnalyzer, agentManager: AgentManager, aiAnalysisService: AIAnalysisService) {
// Define resources
server.setRequestHandler(ListResourcesRequestSchema, async () => {
return {
resources: [
{
uri: 'mcp://claude-agents-power/how-it-works',
name: 'MCP 동작 원리',
description: 'Claude Agents Power MCP 서버의 동작 원리와 구조 설명',
mimeType: 'text/markdown',
},
{
uri: 'mcp://claude-agents-power/tool-guide',
name: '도구 사용 가이드',
description: '통합된 3개 도구의 사용 방법과 예제',
mimeType: 'text/markdown',
},
{
uri: 'mcp://claude-agents-power/agent-structure',
name: '에이전트 구조',
description: '에이전트 파일 구조와 다국어 지원 설명',
mimeType: 'text/markdown',
},
{
uri: 'mcp://claude-agents-power/claude-flow-agents',
name: 'Claude-Flow Agent System',
description: 'Advanced 64-agent system overview with swarm patterns and coordination strategies',
mimeType: 'text/markdown',
},
{
uri: 'mcp://claude-agents-power/agent-swarm-patterns',
name: 'Agent Swarm Patterns',
description: 'Recommended agent swarm deployment patterns for different use cases',
mimeType: 'text/markdown',
},
],
};
});
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
const { uri } = request.params;
switch (uri) {
case 'mcp://claude-agents-power/how-it-works':
return {
contents: [
{
uri,
mimeType: 'text/markdown',
text: `# Claude Agents Power MCP 서버 동작 원리
## 개요
Claude Agents Power는 Model Context Protocol(MCP)을 사용하여 100개 이상의 전문 에이전트를 Claude에서 사용할 수 있게 해주는 서버입니다.
## MCP (Model Context Protocol) 란?
MCP는 Claude와 같은 LLM이 외부 도구와 리소스에 접근할 수 있게 해주는 표준 프로토콜입니다.
### 주요 구성 요소:
1. **Tools (도구)**: Claude가 실행할 수 있는 함수들
2. **Resources (리소스)**: Claude가 읽을 수 있는 문서나 데이터
3. **Prompts (프롬프트)**: 미리 정의된 프롬프트 템플릿
## 서버 아키텍처
### 1. 에이전트 매니저 (AgentManager)
- 에이전트 파일 로딩 및 캐싱
- 다국어 지원 (en, ko, ja, zh)
- GitHub에서 에이전트 동적 로딩
### 2. 프로젝트 분석기 (ProjectAnalyzer)
- 프로젝트 구조 분석
- 적합한 에이전트 추천
- 키워드 기반 매칭
### 3. 통합 도구 시스템
기존 8개 도구를 3개로 통합:
- \`analyze-project\`: 프로젝트 분석
- \`agents\`: 에이전트 검색/목록/상세/추천
- \`manage-agents\`: 설치/통계/새로고침
## 데이터 흐름
\`\`\`
Claude Desktop → MCP Protocol → Agent Manager → Local Files
↓
GitHub Repository (fallback)
\`\`\`
## 에이전트 로딩 과정
1. **시작시**: \`claude/agents/{언어}/\` 디렉토리에서 에이전트 로드
2. **요청시**: 캐시에서 빠른 검색
3. **미발견시**: GitHub에서 동적 다운로드
4. **설치**: 프로젝트 디렉토리에 에이전트 파일 복사
## 성능 최적화
- 메모리 캐싱으로 빠른 응답
- YAML frontmatter 파싱으로 메타데이터 추출
- 언어별 키 매핑으로 효율적인 검색
`,
},
],
};
case 'mcp://claude-agents-power/tool-guide':
return {
contents: [
{
uri,
mimeType: 'text/markdown',
text: `# 도구 사용 가이드
## 통합된 3개 도구 사용법
### 1. analyze-project
프로젝트 디렉토리를 분석하여 적합한 에이전트를 추천합니다.
**사용법:**
\`\`\`json
{
"tool": "analyze-project",
"arguments": {
"projectPath": "/path/to/project"
}
}
\`\`\`
### 2. agents
에이전트 관련 모든 작업을 처리하는 통합 도구입니다.
#### 2.1 검색 (search)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "search",
"query": "frontend",
"language": "en"
}
}
\`\`\`
#### 2.2 목록 조회 (list)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "list",
"language": "ko",
"category": "development"
}
}
\`\`\`
#### 2.3 상세 정보 (details)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "details",
"query": "frontend-developer",
"language": "en"
}
}
\`\`\`
#### 2.4 추천 (recommend)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "recommend",
"keywords": ["react", "typescript", "ui"]
}
}
\`\`\`
#### 2.5 검색 (자동 Issue 생성)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "search",
"query": "blockchain-architect",
"language": "en",
"autoCreateIssue": true,
"issueBody": "We need a blockchain architect for smart contract development"
}
}
\`\`\`
#### 2.6 요청 (request)
\`\`\`json
{
"tool": "agents",
"arguments": {
"action": "request",
"query": "ai-ethics-officer",
"language": "en",
"issueBody": "Need an AI ethics specialist for responsible AI development"
}
}
\`\`\`
### 3. manage-agents
에이전트 관리 작업을 처리합니다.
#### 3.1 설치 (install)
\`\`\`json
{
"tool": "manage-agents",
"arguments": {
"action": "install",
"agentNames": ["frontend-developer", "backend-engineer"],
"targetPath": "/path/to/project",
"language": "en"
}
}
\`\`\`
#### 3.2 통계 (stats)
\`\`\`json
{
"tool": "manage-agents",
"arguments": {
"action": "stats",
"limit": 10
}
}
\`\`\`
#### 3.3 새로고침 (refresh)
\`\`\`json
{
"tool": "manage-agents",
"arguments": {
"action": "refresh"
}
}
\`\`\`
## 언어 지원
- \`en\`: English
- \`ko\`: 한국어
- \`ja\`: 日本語
- \`zh\`: 中文
## 카테고리
- development, data, design, management
- marketing, operations, hr, finance
- legal, research, healthcare, education
- media, manufacturing, other
`,
},
],
};
case 'mcp://claude-agents-power/agent-structure':
return {
contents: [
{
uri,
mimeType: 'text/markdown',
text: `# 에이전트 구조
## 파일 구조
\`\`\`
claude/agents/
├── en/ # 영어 에이전트
│ ├── frontend-developer.md
│ ├── backend-engineer.md
│ └── ...
├── ko/ # 한국어 에이전트
│ ├── frontend-developer.md
│ ├── backend-engineer.md
│ └── ...
├── ja/ # 일본어 에이전트
└── zh/ # 중국어 에이전트
\`\`\`
## 에이전트 파일 형식
각 에이전트 파일은 YAML frontmatter와 Markdown 콘텐츠로 구성됩니다:
\`\`\`markdown
---
name: frontend-developer
description: UI/UX implementation specialist with React, Vue, and modern web technologies expertise.
tools: Read, Write, Edit, MultiEdit, Bash, WebSearch
---
You are a frontend engineer specializing in modern web applications.
Focus areas:
- Build responsive and accessible interfaces
- Implement state management solutions
- Optimize performance and bundle sizes
- Ensure cross-browser compatibility
- Write maintainable component architectures
Key practices:
- Follow semantic HTML standards
- Implement WCAG accessibility guidelines
- Use modern CSS features (Grid, Flexbox)
- Optimize for Core Web Vitals
- Write comprehensive tests
\`\`\`
## 메타데이터 필드
### name (필수)
에이전트의 고유 식별자입니다. 파일명과 일치해야 합니다.
### description (필수)
에이전트의 역할과 전문성을 설명합니다. 검색에 사용됩니다.
### tools (필수)
에이전트가 사용할 수 있는 도구 목록입니다.
**사용 가능한 도구:**
- Read, Write, Edit, MultiEdit
- Bash, Grep, Glob
- WebSearch, WebFetch
- TodoWrite, Task
- NotebookRead, NotebookEdit
## 다국어 지원
### 언어별 키 매핑
- 영어: \`agent-name\`
- 기타 언어: \`agent-name-{언어코드}\`
예:
- \`frontend-developer\` (영어)
- \`frontend-developer-ko\` (한국어)
- \`frontend-developer-ja\` (일본어)
### 언어 감지
1. 요청된 언어에 따른 에이전트 검색
2. 해당 언어가 없으면 영어 버전 사용
3. 모두 없으면 GitHub에서 다운로드 시도
## 에이전트 품질 기준
### 필수 요소
1. 명확한 역할 정의
2. 구체적인 책임 범위
3. 실용적인 가이드라인
4. 도구 적절한 선택
### 권장 구조
1. 역할 소개
2. 핵심 활동/책임
3. 주요 관행
4. 품질 기준
5. 협업 방식
## 에이전트 생성 가이드
새 에이전트를 만들 때:
1. 기존 에이전트 참고
2. 일관된 형식 유지
3. 언어별 번역 제공
4. 적절한 도구 선택
5. 구체적이고 실용적인 내용 작성
`,
},
],
};
case 'mcp://claude-agents-power/claude-flow-agents':
return {
contents: [
{
uri,
mimeType: 'text/markdown',
text: `# Claude-Flow Agent System Overview
## 🎯 Introduction
Claude Agents Power integrates insights from Claude-Flow v2 Alpha's sophisticated 64-agent system designed for enterprise-grade AI orchestration. These specialized agents work together to create intelligent swarms capable of handling complex development tasks through coordinated collaboration.
## 📊 Agent Categories and Specializations
### 1. Core Development Agents
Essential agents for basic development tasks:
- **coder**: Implementation specialist for clean, efficient code
- **reviewer**: Code quality assurance and review specialist
- **tester**: Test creation and validation expert
- **planner**: Strategic planning and task orchestration
- **researcher**: Information gathering and analysis specialist
### 2. Swarm Coordination Patterns
Advanced coordination patterns for distributed agent networks:
- **hierarchical-coordinator**: Queen-led coordination with specialized workers (Tree structure)
- **mesh-coordinator**: Peer-to-peer networks with fault tolerance (Mesh network)
- **adaptive-coordinator**: Dynamic topology switching based on workload (Adaptive hybrid)
### 3. Performance & Optimization Agents
- **load-balancer**: Work-stealing algorithms for task distribution
- **performance-monitor**: Real-time metrics collection and bottleneck analysis
- **topology-optimizer**: Dynamic swarm topology reconfiguration
- **resource-allocator**: Adaptive resource allocation with ML prediction
- **benchmark-suite**: Automated performance testing and regression detection
### 4. GitHub & Repository Management
Complete GitHub workflow automation:
- **pr-manager**: Pull request lifecycle management
- **code-review-swarm**: Multi-agent intelligent code reviews
- **issue-tracker**: Issue management and project coordination
- **release-manager**: Release coordination and deployment
- **workflow-automation**: CI/CD pipeline creation and optimization
### 5. Testing & Validation
- **tdd-london-swarm**: Mock-driven TDD with London School methodology
- **production-validator**: Real implementation validation for deployment
- **integration-tester**: End-to-end integration testing
- **performance-tester**: Load and stress testing
### 6. Security & Compliance
- **security-manager**: Cryptographic security and attack detection
- **compliance-auditor**: Regulatory compliance validation
- **vulnerability-scanner**: Security vulnerability detection
- **access-controller**: Role-based access control management
## 🎯 Recommended Swarm Patterns
### Full-Stack Development Swarm (8 agents)
\`\`\`
Task("System architecture", "...", "system-architect")
Task("Backend APIs", "...", "backend-dev")
Task("Frontend mobile", "...", "mobile-dev")
Task("Database design", "...", "coder")
Task("API documentation", "...", "api-docs")
Task("CI/CD pipeline", "...", "cicd-engineer")
Task("Performance testing", "...", "performance-benchmarker")
Task("Production validation", "...", "production-validator")
\`\`\`
### Distributed System Swarm (6 agents)
\`\`\`
Task("Byzantine consensus", "...", "byzantine-coordinator")
Task("Raft coordination", "...", "raft-manager")
Task("Gossip protocols", "...", "gossip-coordinator")
Task("CRDT synchronization", "...", "crdt-synchronizer")
Task("Security management", "...", "security-manager")
Task("Performance monitoring", "...", "performance-monitor")
\`\`\`
### GitHub Workflow Swarm (5 agents)
\`\`\`
Task("PR management", "...", "pr-manager")
Task("Code review", "...", "code-review-swarm")
Task("Issue tracking", "...", "issue-tracker")
Task("Release coordination", "...", "release-manager")
Task("Workflow automation", "...", "workflow-automation")
\`\`\`
### SPARC TDD Swarm (7 agents)
\`\`\`
Task("Requirements spec", "...", "specification")
Task("Algorithm design", "...", "pseudocode")
Task("System architecture", "...", "architecture")
Task("TDD implementation", "...", "sparc-coder")
Task("London school tests", "...", "tdd-london-swarm")
Task("Iterative refinement", "...", "refinement")
Task("Production validation", "...", "production-validator")
\`\`\`
## ⚡ Performance Guidelines
### Agent Selection Strategy
- **High Priority**: Use 3-5 agents max for critical path
- **Medium Priority**: Use 5-8 agents for complex features
- **Large Projects**: Use 8+ agents with proper coordination
### Memory Management
- Use memory-coordinator for cross-agent state
- Implement swarm-memory-manager for distributed coordination
- Apply collective-intelligence-coordinator for decision-making
### Coordination Patterns
- **Hierarchical**: Best for large-scale projects with clear structure
- **Mesh**: Ideal for fault-tolerant, high-availability systems
- **Adaptive**: Perfect for dynamic workloads and optimization
## 🔧 Integration Features
### Concurrent Agent Deployment
Claude Agents Power is optimized for concurrent agent deployment:
\`\`\`
// ✅ CORRECT: Concurrent deployment
[Single Message]:
- Task("Agent 1", "full instructions", "agent-type-1")
- Task("Agent 2", "full instructions", "agent-type-2")
- Task("Agent 3", "full instructions", "agent-type-3")
- Task("Agent 4", "full instructions", "agent-type-4")
- Task("Agent 5", "full instructions", "agent-type-5")
\`\`\`
## 📚 Best Practices
1. Always use concurrent agent deployment for maximum performance
2. Match agent specialization to task requirements for optimal results
3. Use coordination agents for complex multi-step workflows
4. Apply appropriate topology based on project scale and requirements
5. Leverage memory coordination for persistent state across agents
6. Monitor performance using dedicated monitoring agents
7. Validate production readiness with specialized validation agents
`,
},
],
};
case 'mcp://claude-agents-power/agent-swarm-patterns':
return {
contents: [
{
uri,
mimeType: 'text/markdown',
text: `# Agent Swarm Patterns for Claude Agents Power
## 🎯 Overview
This guide provides recommended agent swarm deployment patterns optimized for different project types and use cases.
## 🏗️ Pattern Categories
### 1. Development Patterns
#### Microservices Development Swarm
**Use Case**: Building distributed microservices architecture
**Agents**: 8-10 specialists
\`\`\`
- system-architect: Overall architecture design
- backend-engineer (x3): Service implementation
- api-designer: API contract design
- database-architect: Data model design
- devops-engineer: Container orchestration
- security-engineer: Service security
- performance-engineer: Service optimization
- qa-engineer: Integration testing
\`\`\`
#### Mobile App Development Swarm
**Use Case**: Cross-platform mobile application
**Agents**: 6-8 specialists
\`\`\`
- mobile-architect: App architecture
- frontend-developer: UI implementation
- backend-engineer: API development
- ux-designer: User experience
- performance-optimizer: App optimization
- qa-mobile: Mobile testing
- devops-mobile: App deployment
\`\`\`
### 2. Data & AI Patterns
#### Machine Learning Pipeline Swarm
**Use Case**: ML model development and deployment
**Agents**: 7-9 specialists
\`\`\`
- data-scientist: Model development
- ml-engineer: Pipeline implementation
- data-engineer: Data preprocessing
- feature-engineer: Feature extraction
- mlops-engineer: Model deployment
- performance-analyst: Model optimization
- qa-ml: Model validation
\`\`\`
#### Data Analytics Swarm
**Use Case**: Business intelligence and analytics
**Agents**: 5-6 specialists
\`\`\`
- data-analyst: Data exploration
- sql-developer: Query optimization
- visualization-expert: Dashboard creation
- etl-engineer: Data pipeline
- data-quality: Data validation
\`\`\`
### 3. Infrastructure Patterns
#### Cloud Migration Swarm
**Use Case**: Migrating applications to cloud
**Agents**: 8-10 specialists
\`\`\`
- cloud-architect: Cloud design
- migration-planner: Migration strategy
- infrastructure-engineer: IaC implementation
- security-engineer: Cloud security
- network-engineer: Network design
- database-migrator: Data migration
- performance-optimizer: Cloud optimization
- cost-optimizer: Cloud cost management
\`\`\`
#### Kubernetes Deployment Swarm
**Use Case**: Container orchestration setup
**Agents**: 6-7 specialists
\`\`\`
- k8s-architect: Cluster design
- devops-engineer: Pipeline setup
- helm-expert: Chart creation
- security-k8s: Security policies
- monitoring-engineer: Observability
- performance-k8s: Cluster optimization
\`\`\`
### 4. Security Patterns
#### Security Audit Swarm
**Use Case**: Comprehensive security assessment
**Agents**: 7-8 specialists
\`\`\`
- security-architect: Security design
- vulnerability-scanner: Vulnerability assessment
- penetration-tester: Security testing
- compliance-auditor: Compliance check
- crypto-engineer: Encryption implementation
- access-controller: IAM setup
- security-monitor: Security monitoring
\`\`\`
### 5. Quality Assurance Patterns
#### Comprehensive Testing Swarm
**Use Case**: Full test coverage implementation
**Agents**: 6-8 specialists
\`\`\`
- test-architect: Test strategy
- unit-tester: Unit test creation
- integration-tester: Integration tests
- e2e-tester: End-to-end tests
- performance-tester: Load testing
- security-tester: Security tests
- automation-engineer: Test automation
\`\`\`
## 📊 Swarm Size Recommendations
### Small Projects (3-5 agents)
- Simple features or bug fixes
- Prototype development
- Documentation updates
### Medium Projects (5-8 agents)
- New feature development
- API implementation
- Database design
- Testing implementation
### Large Projects (8-12 agents)
- System architecture redesign
- Full-stack application development
- Platform migration
- Enterprise integrations
### Enterprise Projects (12+ agents)
- Multi-team coordination
- Complex distributed systems
- Large-scale refactoring
- Production deployment
## ⚡ Optimization Strategies
### Concurrent Execution
- Deploy agents in parallel when possible
- Use coordination agents for dependencies
- Implement message queuing for communication
### Resource Management
- Monitor agent resource usage
- Implement agent pooling
- Use lazy loading for heavy agents
- Apply circuit breakers for failures
### Communication Patterns
- **Direct**: Agent-to-agent direct communication
- **Broadcast**: One-to-many communication
- **Pipeline**: Sequential processing chain
- **Hub-Spoke**: Centralized coordination
- **Mesh**: Fully connected network
## 🎯 Selection Criteria
### Choose Hierarchical Coordination When:
- Clear project structure exists
- Team roles are well-defined
- Sequential dependencies present
- Central decision-making required
### Choose Mesh Coordination When:
- High availability required
- Fault tolerance critical
- Distributed decision-making
- Peer collaboration needed
### Choose Adaptive Coordination When:
- Workload varies significantly
- Project requirements evolving
- Optimization is priority
- Mixed coordination needed
## 📚 Implementation Examples
### Example 1: E-commerce Platform
\`\`\`javascript
const swarm = [
{ agent: "system-architect", task: "Design microservices architecture" },
{ agent: "backend-engineer", task: "Implement order service" },
{ agent: "backend-engineer", task: "Implement payment service" },
{ agent: "frontend-developer", task: "Build React UI" },
{ agent: "database-architect", task: "Design data models" },
{ agent: "security-engineer", task: "Implement authentication" },
{ agent: "devops-engineer", task: "Setup CI/CD pipeline" },
{ agent: "qa-engineer", task: "Create test suites" }
];
\`\`\`
### Example 2: Real-time Analytics Dashboard
\`\`\`javascript
const swarm = [
{ agent: "data-engineer", task: "Build data pipeline" },
{ agent: "stream-processor", task: "Implement real-time processing" },
{ agent: "frontend-developer", task: "Create dashboard UI" },
{ agent: "websocket-expert", task: "Implement real-time updates" },
{ agent: "performance-optimizer", task: "Optimize queries" },
{ agent: "monitoring-engineer", task: "Setup monitoring" }
];
\`\`\`
## 🔗 Related Resources
- Agent Coordination Guide
- Performance Optimization
- Distributed Systems Patterns
- MCP Tool Integration
`,
},
],
};
default:
throw new Error(`Unknown resource: ${uri}`);
}
});
// Define tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: 'analyze-project',
description: 'Analyze a project directory and recommend suitable sub-agents',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory to analyze',
},
},
required: ['projectPath'],
},
},
{
name: 'ai-analyze-project',
description: 'Perform AI-powered comprehensive project analysis and agent recommendations',
inputSchema: {
type: 'object',
properties: {
claudeMdPath: {
type: 'string',
description: 'Path to CLAUDE.md file or project description',
},
projectPath: {
type: 'string',
description: 'Optional path to project root directory (defaults to CLAUDE.md directory)',
},
generateRecommendations: {
type: 'boolean',
description: 'Whether to generate agent recommendations',
default: true,
},
maxRecommendations: {
type: 'number',
description: 'Maximum number of agent recommendations to return',
default: 10,
},
},
required: ['claudeMdPath'],
},
},
{
name: 'agent-download',
description: 'AI-powered agent downloader - analyze project and download recommended agents',
inputSchema: {
type: 'object',
properties: {
targetDir: {
type: 'string',
description: 'Target directory for agent files',
default: './.claude/agents',
},
claudeMdPath: {
type: 'string',
description: 'Path to CLAUDE.md file',
default: './CLAUDE.md',
},
format: {
type: 'string',
enum: ['md', 'yaml', 'json'],
description: 'Agent file format',
default: 'md',
},
language: {
type: 'string',
enum: ['en', 'ko', 'ja', 'zh'],
description: 'Preferred language for agents',
default: 'en',
},
limit: {
type: 'number',
description: 'Maximum number of agents to download',
default: 10,
minimum: 1,
maximum: 20,
},
dryRun: {
type: 'boolean',
description: 'Preview recommendations without downloading',
default: false,
},
overwrite: {
type: 'boolean',
description: 'Overwrite existing agent files',
default: false,
},
},
},
},
{
name: 'agents',
description: 'Search, list, get details, recommend agents, or request new ones',
inputSchema: {
type: 'object',
properties: {
action: {
type: 'string',
description: 'Action to perform',
enum: ['search', 'list', 'details', 'recommend', 'request'],
},
query: {
type: 'string',
description: 'Search query (for search action) or agent name (for details action)',
},
keywords: {
type: 'array',
items: { type: 'string' },
description: 'Keywords for recommendation (for recommend action)',
},
language: {
type: 'string',
description: 'Language preference',
enum: ['en', 'ko', 'ja', 'zh'],
default: 'en',
},
category: {
type: 'string',
description: 'Filter by category (for list action)',
enum: ['development', 'data', 'design', 'management', 'marketing', 'operations', 'hr', 'finance', 'legal', 'research', 'healthcare', 'education', 'media', 'manufacturing', 'other'],
},
autoCreateIssue: {
type: 'boolean',
description: 'Auto-create GitHub issue if no agents found (for search action)',
default: false,
},
issueBody: {
type: 'string',
description: 'Additional details for the issue (when autoCreateIssue is true)',
},
},
required: ['action'],
},
},
{
name: 'manage-agents',
description: 'Install agents, get stats, or refresh from GitHub',
inputSchema: {
type: 'object',
properties: {
action: {
type: 'string',
description: 'Management action to perform',
enum: ['install', 'stats', 'refresh', 'version'],
},
agentNames: {
type: 'array',
items: { type: 'string' },
description: 'Agent names to install (for install action)',
},
targetPath: {
type: 'string',
description: 'Target directory for installation (for install action)',
},
language: {
type: 'string',
description: 'Language preference for agents',
enum: ['en', 'ko', 'ja', 'zh'],
default: 'en',
},
limit: {
type: 'number',
description: 'Number of top agents to show in stats',
default: 10,
},
},
required: ['action'],
},
},
],
};
});
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
// Track tool usage
trackEvent(AnalyticsEvents.TOOL_CALLED, {
tool_name: name,
args_provided: Object.keys(args || {}),
});
switch (name) {
case 'analyze-project': {
const { projectPath } = args as { projectPath: string };
const analysis = await projectAnalyzer.analyzeProject(projectPath);
// Track project analysis
trackEvent(AnalyticsEvents.PROJECT_ANALYZED, {
project_types: analysis.projectType,
technologies: analysis.technologies,
recommended_count: analysis.recommendedAgents.length,
confidence: analysis.confidence,
});
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
analysis,
message: `Analyzed project at ${projectPath}. Found ${analysis.projectType.length} project types and recommended ${analysis.recommendedAgents.length} agents.`,
}, null, 2),
},
],
};
}
case 'ai-analyze-project': {
const { claudeMdPath, projectPath, generateRecommendations = true, maxRecommendations = 10 } = args as {
claudeMdPath: string;
projectPath?: string;
generateRecommendations?: boolean;
maxRecommendations?: number;
};
try {
// Perform AI-powered project analysis
const analysis = await aiAnalysisService.analyzeProject(claudeMdPath, projectPath);
let recommendations: AIAgentRecommendation[] = [];
if (generateRecommendations) {
const allRecommendations = await aiAnalysisService.generateRecommendations(analysis);
recommendations = allRecommendations.slice(0, maxRecommendations);
}
// Track AI analysis event
trackEvent(AnalyticsEvents.PROJECT_ANALYZED, {
project_types: analysis.projectType,
technologies: analysis.technologies,
recommended_count: recommendations.length,
confidence: analysis.complexity / 10, // Normalize complexity as confidence
ai_powered: true,
});
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
analysis: {
projectType: analysis.projectType,
technologies: analysis.technologies,
frameworks: analysis.frameworks,
complexity: analysis.complexity,
phase: analysis.phase,
teamSize: analysis.teamSize,
description: analysis.description,
goals: analysis.goals,
requirements: analysis.requirements,
architecturalPatterns: analysis.architecturalPatterns,
developmentPractices: analysis.developmentPractices,
qualityIndicators: analysis.qualityIndicators,
},
recommendations: recommendations.map(rec => ({
name: rec.name,
description: rec.description,
relevanceScore: rec.relevanceScore,
reasoning: rec.reasoning,
category: rec.category,
priority: rec.priority,
tools: rec.tools,
specificTasks: rec.specificTasks,
integrationPoints: rec.integrationPoints,
})),
message: `AI analysis completed for ${path.basename(claudeMdPath)}. Project type: ${analysis.projectType}, Complexity: ${analysis.complexity}/10, Recommended ${recommendations.length} agents.`,
aiFeatures: {
intelligentAnalysis: 'Comprehensive project understanding using AI reasoning',
contextAwareRecommendations: 'Agent suggestions based on project context and requirements',
dynamicPrioritization: 'Smart priority assignment based on project needs',
taskSpecificMatching: 'Agents matched to specific tasks and integration points'
}
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `AI analysis failed: ${error instanceof Error ? error.message : String(error)}`,
suggestion: 'Please check the CLAUDE.md file path and project structure',
}, null, 2),
},
],
};
}
}
case 'agent-download': {
const {
targetDir = './.claude/agents',
claudeMdPath = './CLAUDE.md',
format = 'md',
language = 'en',
limit = 10,
dryRun = false,
overwrite = false
} = args as {
targetDir?: string;
claudeMdPath?: string;
format?: 'md' | 'yaml' | 'json';
language?: 'en' | 'ko' | 'ja' | 'zh';
limit?: number;
dryRun?: boolean;
overwrite?: boolean;
};
try {
const downloader = new AgentDownloader();
const options = {
targetDir,
claudeMdPath,
format,
language,
limit,
dryRun,
overwrite
};
const result = await downloader.downloadAgents(options);
// Track agent download event
trackEvent(AnalyticsEvents.PROJECT_ANALYZED, {
project_types: result.analysis.projectType,
technologies: result.analysis.technologies,
recommended_count: result.recommendations.length,
confidence: result.analysis.complexity / 10,
ai_powered: true,
dry_run: dryRun,
downloaded_count: result.downloaded?.length || 0,
});
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
dryRun,
analysis: {
projectType: result.analysis.projectType,
technologies: result.analysis.technologies,
frameworks: result.analysis.frameworks,
complexity: result.analysis.complexity,
phase: result.analysis.phase,
teamSize: result.analysis.teamSize,
description: result.analysis.description,
qualityIndicators: result.analysis.qualityIndicators,
architecturalPatterns: result.analysis.architecturalPatterns,
developmentPractices: result.analysis.developmentPractices,
},
recommendations: result.recommendations.map(rec => ({
name: rec.name,
description: rec.description,
relevanceScore: rec.relevanceScore,
reasoning: rec.reasoning,
category: rec.category,
priority: rec.priority,
tools: rec.tools,
specificTasks: rec.specificTasks,
integrationPoints: rec.integrationPoints,
})),
downloaded: result.downloaded || [],
message: dryRun
? `AI analysis preview completed. Found ${result.recommendations.length} recommended agents for your ${result.analysis.projectType} project.`
: `Successfully downloaded ${result.downloaded?.length || 0} AI-recommended agents to ${targetDir}.`,
aiFeatures: {
intelligentAnalysis: 'Comprehensive project understanding using AI reasoning',
contextAwareRecommendations: 'Agent suggestions based on project context and requirements',
dynamicPrioritization: 'Smart priority assignment based on project needs',
taskSpecificMatching: 'Agents matched to specific tasks and integration points',
automaticDownload: 'Seamless agent file creation with enhanced documentation'
}
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Agent download failed: ${error instanceof Error ? error.message : String(error)}`,
suggestion: 'Please check the CLAUDE.md file path and ensure write permissions for the target directory',
}, null, 2),
},
],
};
}
}
case 'agents': {
const { action, query, keywords, language = 'en', category, autoCreateIssue = false, issueBody } = args as {
action: 'search' | 'list' | 'details' | 'recommend' | 'request';
query?: string;
keywords?: string[];
language?: string;
category?: string;
autoCreateIssue?: boolean;
issueBody?: string;
};
switch (action) {
case 'search': {
if (!query) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'Query is required for search action',
}, null, 2),
},
],
};
}
const agents = agentManager.searchAgents(query);
const filteredAgents = agents.filter(
agent => !language || agent.language === language
);
// Track search event
trackEvent(AnalyticsEvents.AGENT_SEARCHED, {
query,
language,
found_count: filteredAgents.length,
auto_create_issue: autoCreateIssue,
});
// Auto-create issue if no agents found and autoCreateIssue is true
if (filteredAgents.length === 0 && autoCreateIssue) {
const githubToken = process.env.GITHUB_TOKEN;
if (!githubToken) {
// Generate GitHub issue creation URL with pre-filled content
const issueTitle = encodeURIComponent(`[Agent Request] ${query} - New agent needed`);
const issueBodyContent = encodeURIComponent(`## Agent Request
**Role Name**: ${query}
**Language**: ${language}
## Description
${issueBody || 'A new agent is needed for this role.'}
## Use Cases
- [Please describe specific use cases]
## Required Tools
- [List required tools like Read, Write, Edit, etc.]
## Additional Details
- No existing agents found matching: "${query}"
- Please consider adding this agent to help users with this use case.`);
const createIssueUrl = `https://github.com/hongsw/claude-agents-power-mcp-server/issues/new?title=${issueTitle}&body=${issueBodyContent}&labels=agent-request`;
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'No agents found. GitHub token not configured for auto-issue creation.',
suggestion: 'Click the link below to create an issue manually:',
createIssueUrl,
message: `🔍 No agents found for "${query}"\n\n📝 You can create an issue manually by clicking this link:\n${createIssueUrl}\n\n💡 Or set GITHUB_TOKEN environment variable for automatic issue creation.`,
}, null, 2),
},
],
};
}
try {
const issueTitle = `[Agent Request] ${query} - New agent needed`;
const issueBodyContent = `## Agent Request
**Role Name**: ${query}
**Language**: ${language}
## Description
${issueBody || 'A new agent is needed for this role.'}
## Use Cases
- [Please describe specific use cases]
## Required Tools
- [List required tools like Read, Write, Edit, etc.]
## Additional Details
- Requested via MCP server auto-issue creation
- No existing agents found matching: "${query}"
---
*This issue was automatically created by claude-agents-power MCP server*`;
const response = await fetch('https://api.github.com/repos/hongsw/claude-agents-power-mcp-server/issues', {
method: 'POST',
headers: {
'Authorization': `token ${githubToken}`,
'Accept': 'application/vnd.github+json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
title: issueTitle,
body: issueBodyContent,
labels: ['agent-request', 'auto-created'],
}),
});
if (!response.ok) {
throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
}
const issue = await response.json();
// Log to stderr for visibility
console.error(`[MCP Sub-Agents] ✅ GitHub issue created successfully!`);
console.error(`[MCP Sub-Agents] Issue #${issue.number}: ${issue.html_url}`);
// Track issue creation
trackEvent(AnalyticsEvents.AGENT_ISSUE_CREATED, {
query,
language,
issue_number: issue.number,
issue_url: issue.html_url,
});
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
count: 0,
message: `🔍 No agents found for "${query}"\n\n📝 GitHub issue automatically created!\n\n🔗 Issue #${issue.number}: ${issue.title}\n📎 ${issue.html_url}\n\n💡 The maintainers will review and potentially add this agent.\n📚 Meanwhile, you can create your own agent following the guide.`,
issueUrl: issue.html_url,
issueNumber: issue.number,
nextSteps: [
'Wait for maintainers to review the issue',
'Create your own agent following the documentation',
'Check back later for the new agent'
]
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
count: 0,
error: `Failed to create issue: ${error}`,
suggestion: 'Visit https://github.com/hongsw/claude-agents-power-mcp-server/issues to manually create an issue',
}, null, 2),
},
],
};
}
}
// If no agents found and autoCreateIssue is false, provide manual creation link
if (filteredAgents.length === 0) {
const issueTitle = encodeURIComponent(`[Agent Request] ${query} - New agent needed`);
const issueBodyContent = encodeURIComponent(`## Agent Request
**Role Name**: ${query}
**Language**: ${language}
## Description
A new agent is needed for this role.
## Use Cases
- [Please describe specific use cases]
## Required Tools
- [List required tools like Read, Write, Edit, etc.]
## Additional Details
- No existing agents found matching: "${query}"
- Please consider adding this agent to help users with this use case.`);
const createIssueUrl = `https://github.com/hongsw/claude-agents-power-mcp-server/issues/new?title=${issueTitle}&body=${issueBodyContent}&labels=agent-request`;
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
count: 0,
agents: [],
message: `🔍 No agents found for "${query}"`,
suggestion: '📝 You can request this agent by creating an issue:',
createIssueUrl,
tip: '💡 Set autoCreateIssue=true to automatically create issues when agents are not found.',
}, null, 2),
},
],
};
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
count: filteredAgents.length,
agents: filteredAgents.map(agent => ({
name: agent.name,
description: agent.description,
tools: agent.tools,
language: agent.language,
})),
}, null, 2),
},
],
};
}
case 'list': {
let agents = agentManager.getAllAgents(language);
if (category) {
agents = agents.filter(agent => {
const categoryKeywords: Record<string, string[]> = {
development: ['developer', 'engineer', 'architect'],
data: ['data', 'analyst', 'scientist'],
design: ['designer', 'ux', 'ui'],
management: ['manager', 'owner', 'master'],
};
const keywords = categoryKeywords[category] || [];
return keywords.some(keyword =>
agent.name.includes(keyword) ||
agent.description.toLowerCase().includes(keyword)
);
});
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
count: agents.length,
agents: agents.map(agent => ({
name: agent.name,
description: agent.description,
tools: agent.tools,
language: agent.language,
})),
}, null, 2),
},
],
};
}
case 'details': {
if (!query) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'Agent name is required for details action',
}, null, 2),
},
],
};
}
const agent = agentManager.getAgent(query, language);
if (!agent) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Agent '${query}' not found in language '${language}'`,
}, null, 2),
},
],
};
}
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
agent: {
name: agent.name,
description: agent.description,
tools: agent.tools,
language: agent.language,
content: agent.content,
},
}, null, 2),
},
],
};
}
case 'recommend': {
if (!keywords || keywords.length === 0) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'Keywords are required for recommend action',
}, null, 2),
},
],
};
}
const recommendedAgents = await projectAnalyzer.getAgentsByKeywords(keywords);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
keywords,
recommendedAgents,
count: recommendedAgents.length,
}, null, 2),
},
],
};
}
case 'request': {
if (!query) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'Agent name is required for request action',
}, null, 2),
},
],
};
}
const githubToken = process.env.GITHUB_TOKEN;
if (!githubToken) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'GitHub token not configured. Set GITHUB_TOKEN environment variable.',
suggestion: 'Visit https://github.com/hongsw/claude-agents-power-mcp-server/issues to manually create an issue',
}, null, 2),
},
],
};
}
try {
const issueTitle = `[Agent Request] ${query} - New agent needed`;
const issueBodyContent = `## Agent Request
**Role Name**: ${query}
**Language**: ${language}
## Description
${issueBody || 'A new agent is needed for this role.'}
## Use Cases
- [Please describe specific use cases]
## Required Tools
- [List required tools like Read, Write, Edit, etc.]
## Additional Details
- Requested via MCP server manual request
- Agent name: "${query}"
---
*This issue was created by claude-agents-power MCP server*`;
const response = await fetch('https://api.github.com/repos/hongsw/claude-agents-power-mcp-server/issues', {
method: 'POST',
headers: {
'Authorization': `token ${githubToken}`,
'Accept': 'application/vnd.github+json',
'Content-Type': 'application/json',
},
body: JSON.stringify({
title: issueTitle,
body: issueBodyContent,
labels: ['agent-request'],
}),
});
if (!response.ok) {
throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
}
const issue = await response.json();
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: `Created GitHub issue #${issue.number} for agent "${query}"`,
issueUrl: issue.html_url,
issueNumber: issue.number,
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Failed to create issue: ${error}`,
suggestion: 'Visit https://github.com/hongsw/claude-agents-power-mcp-server/issues to manually create an issue',
}, null, 2),
},
],
};
}
}
default:
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Unknown action: ${action}`,
}, null, 2),
},
],
};
}
}
case 'manage-agents': {
const { action, agentNames, targetPath, language = 'en', limit = 10 } = args as {
action: 'install' | 'stats' | 'refresh' | 'version';
agentNames?: string[];
targetPath?: string;
language?: string;
limit?: number;
};
switch (action) {
case 'install': {
if (!agentNames || !targetPath) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: 'Agent names and target path are required for install action',
}, null, 2),
},
],
};
}
try {
const installedPaths = await agentManager.installMultipleAgents(
agentNames,
targetPath,
language
);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
installedCount: installedPaths.length,
installedPaths,
message: `Successfully installed ${installedPaths.length} agents to ${targetPath}/claude/agents/`,
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Failed to install agents: ${error}`,
}, null, 2),
},
],
};
}
}
case 'stats': {
const stats = agentManager.getMostDownloadedAgents(limit);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
stats,
message: `Top ${limit} most downloaded agents`,
}, null, 2),
},
],
};
}
case 'refresh': {
try {
await agentManager.refreshAgentsFromGitHub();
const agents = agentManager.getAllAgents();
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
count: agents.length,
message: `Successfully refreshed agents from GitHub. Total agents: ${agents.length}`,
}, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Failed to refresh agents: ${error}`,
}, null, 2),
},
],
};
}
}
case 'version': {
const agents = agentManager.getAllAgents();
const agentsByLanguage = {
en: agentManager.getAllAgents('en').length,
ko: agentManager.getAllAgents('ko').length,
ja: agentManager.getAllAgents('ja').length,
zh: agentManager.getAllAgents('zh').length,
};
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
version: version,
serverName: 'claude-agents-power-mcp-server',
totalAgents: agents.length,
agentsByLanguage,
npmPackage: 'claude-agents-power',
repository: 'https://github.com/hongsw/claude-agents-power-mcp-server',
message: `Claude Agents Power MCP Server v${version} - ${agents.length} agents available`,
}, null, 2),
},
],
};
}
default:
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Unknown action: ${action}`,
}, null, 2),
},
],
};
}
}
default:
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
error: `Unknown tool: ${name}`,
}, null, 2),
},
],
};
}
});
}
async function main() {
// Load agents on startup
try {
await agentManager.loadAgents();
debug(`Agents loaded successfully`);
} catch (error) {
if (cliOptions.debug) {
console.error(`[MCP Sub-Agents] ERROR loading agents:`, error);
}
}
// Stdio transport - this is already stateless by nature
const server = createServerInstance();
setupTools(server, projectAnalyzer, agentManager, aiAnalysisService);
const transport = new StdioServerTransport();
await server.connect(transport);
if (cliOptions.debug) {
console.error('[MCP Sub-Agents] Server running on stdio');
}
}
// Handle graceful shutdown
process.on('SIGINT', () => {
console.error('[MCP Sub-Agents] Shutting down...');
shutdownAnalytics();
process.exit(0);
});
process.on('SIGTERM', () => {
console.error('[MCP Sub-Agents] Shutting down...');
shutdownAnalytics();
process.exit(0);
});
main().catch((error) => {
console.error('Fatal error in main():', error);
trackEvent(AnalyticsEvents.SERVER_ERROR, {
error: error.message,
stack: error.stack,
});
shutdownAnalytics();
process.exit(1);
});
```