refactor: first try with more interfaces

Signed-off-by: Thomas Schuetz <thomas.schuetz@t-sc.eu>
2026-03-19 03:23:47 +00:00 · 2023-04-02 13:55:06 +02:00
52 changed files with 612 additions and 3370 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -9,4 +9,4 @@
 # Unless a later match takes precedence, these owners will be requested for
 # review when someone opens a pull request.

-* @k8sgpt-ai/maintainers @k8sgpt-ai/k8sgpt-approvers
+* @k8sgpt-ai/maintainers
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -25,7 +25,7 @@ jobs:
      - name: Checkout
        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3

-      - uses: google-github-actions/release-please-action@c078ea33917ab8cfa5300e48f4b7e6b16606aede # v3
+      - uses: google-github-actions/release-please-action@ee9822ec2c397e8a364d634464339ac43a06e042 # v3
        id: release
        with:
          command: manifest
@@ -36,6 +36,7 @@ jobs:
    if: needs.release-please.outputs.releases_created == 'true'
    permissions:
      contents: write
+
    needs:
      - release-please
    runs-on: ubuntu-latest
@@ -48,8 +49,6 @@ jobs:
        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
        with:
          go-version: '1.20'
-      - name: Download Syft
-        uses: anchore/sbom-action/download-syft@422cb34a0f8b599678c41b21163ea6088edb2624 # v0.14.1
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@f82d6c1c344bcacabba2c841718984797f664a6b # v4
        with:
@@ -71,7 +70,6 @@ jobs:
      id-token: write
    env:
      IMAGE_TAG: ghcr.io/k8sgpt-ai/k8sgpt:${{ needs.release-please.outputs.tag_name }}
-      IMAGE_NAME: k8sgpt
    steps:
      - name: Checkout
        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
@@ -100,8 +98,8 @@ jobs:
            ${{ env.IMAGE_TAG }}
          builder: ${{ steps.buildx.outputs.name }}
          push: true
-          cache-from: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_TAG }}
-          cache-to: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_TAG }}
+          cache-from: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_NAME }}
+          cache-to: type=gha,scope=${{ github.ref_name }}-${{ env.IMAGE_NAME }}

      - name: Generate SBOM
        uses: anchore/sbom-action@422cb34a0f8b599678c41b21163ea6088edb2624 # v0.14.1
--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -1,27 +0,0 @@
-name: Run tests
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
-
-env:
-    GO_VERSION: "~1.20"
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
-
-      - name: Set up Go
-        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
-        with:
-          go-version: ${{ env.GO_VERSION }}
-
-      - name: Test
-        run: go test -v ./...
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -16,27 +16,6 @@ builds:
    ldflags:
          - -s -w -X main.version={{.Version}}

-nfpms:
-  - file_name_template: '{{ .ProjectName }}_{{ .Arch }}'
-    homepage: https://k8sgpt.ai
-    description: >-
-      K8sGPT is a tool for scanning your kubernetes clusters, diagnosing and triaging issues in simple english. It has SRE experience codified into it’s analyzers and helps to pull out the most relevant information to enrich it with AI.
-    license: "MIT"
-    formats:
-      - deb
-      - rpm
-      - apk
-    bindir: /usr/bin
-    section: utils
-    contents:
-      - src: ./LICENSE
-        dst: /usr/share/doc/nfpm/copyright
-        file_info:
-          mode: 0644
-
-sboms:
-  - artifacts: archive
-
 archives:
  - format: tar.gz
    # this name template makes the OS and Arch compatible with the results of uname.
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1 +1 @@
-{".":"0.2.1"}
+{".":"0.1.6"}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,167 +1,5 @@
 # Changelog

-## [0.2.1](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.2.0...v0.2.1) (2023-04-12)
-
-
-### Features
-
-* add anonymization example to README ([8a60b57](https://github.com/k8sgpt-ai/k8sgpt/commit/8a60b579409c67f092156ba1adf1be22cce37b8c))
-* add anonymization flag ([d2a84ea](https://github.com/k8sgpt-ai/k8sgpt/commit/d2a84ea2b5c800dd900aac3a48b1914bd9ddb917))
-* add more details on anonymize flag ([b687473](https://github.com/k8sgpt-ai/k8sgpt/commit/b687473e6169406002b0ee8be6ebb9ce43b46495))
-* add storage class names' check. ([c8ba7d6](https://github.com/k8sgpt-ai/k8sgpt/commit/c8ba7d62d2f1d262263d1dff8f980e91cdcd50e8))
-* improve documentation ([6f08654](https://github.com/k8sgpt-ai/k8sgpt/commit/6f0865413fc2854450d217225199cec199972490))
-* improve documentation & update hpa message ([11326c1](https://github.com/k8sgpt-ai/k8sgpt/commit/11326c1c5f307c718e8d1e56099537314ffedadd))
-* improve security of the MaskString function ([08f2a89](https://github.com/k8sgpt-ai/k8sgpt/commit/08f2a89e54a65544322814286977b2c05acce89d))
-* initial impl of integration ([b0e5170](https://github.com/k8sgpt-ai/k8sgpt/commit/b0e517006e65ac2b4e2d4e2696531d4bbf62c34b))
-* initial impl of integration ([61d6e52](https://github.com/k8sgpt-ai/k8sgpt/commit/61d6e524657272cf3a967c724f212677fcfe7d2b))
-* integration ready for first review ([3682f5c](https://github.com/k8sgpt-ai/k8sgpt/commit/3682f5c7ebb9590e92162eed214a8127f71bcd81))
-* introduce StatefulSet analyser. ([c041ce2](https://github.com/k8sgpt-ai/k8sgpt/commit/c041ce2bbb4ecbc6f5637207c9f3071eee022744))
-* refactor integration to use Failure object ([c0afc0f](https://github.com/k8sgpt-ai/k8sgpt/commit/c0afc0f5c91cfa50b1f7af901800ff0a2b492d18))
-* return errors if filter specified by flag does not exist. ([dd5824f](https://github.com/k8sgpt-ai/k8sgpt/commit/dd5824f4365b01e3c501d8b5cda914dff138e03d))
-
-
-### Bug Fixes
-
-* **deps:** update kubernetes packages to v0.27.0 ([7a97034](https://github.com/k8sgpt-ai/k8sgpt/commit/7a97034cf41cb265111c752ee3d54fd90524ef59))
-* **deps:** update module github.com/sashabaranov/go-openai to v1.7.0 ([#227](https://github.com/k8sgpt-ai/k8sgpt/issues/227)) ([5f3a5a5](https://github.com/k8sgpt-ai/k8sgpt/commit/5f3a5a54a02967acce40f8b4e9dd3a154c83f58c))
-* exit progressbar on error ([#99](https://github.com/k8sgpt-ai/k8sgpt/issues/99)) ([fe261b3](https://github.com/k8sgpt-ai/k8sgpt/commit/fe261b375f4d7990906620f53ac26e792a34731b))
-* exit progressbar on error ([#99](https://github.com/k8sgpt-ai/k8sgpt/issues/99)) ([ab55f15](https://github.com/k8sgpt-ai/k8sgpt/commit/ab55f157ef026502d29eadf5ad83e917fe085a6c))
-* improve ReplaceIfMatch regex ([fd936ce](https://github.com/k8sgpt-ai/k8sgpt/commit/fd936ceaf725d1c1ed1f53eaa2204455dcd1e2af))
-* pdb test ([705d2a0](https://github.com/k8sgpt-ai/k8sgpt/commit/705d2a0dcebb63783782e06b6b775393daf1efb7))
-* use hpa namespace instead analyzer namespace ([#230](https://github.com/k8sgpt-ai/k8sgpt/issues/230)) ([a582d44](https://github.com/k8sgpt-ai/k8sgpt/commit/a582d444c5c53f25d7172947c690b35cad2cc176))
-
-
-### Docs
-
-* add statefulSet analyzer in the docs. ([#233](https://github.com/k8sgpt-ai/k8sgpt/issues/233)) ([b45ff1a](https://github.com/k8sgpt-ai/k8sgpt/commit/b45ff1aa8ef447df2b74bb8c6225e2f3d7c5bd63))
-* add statefulSet analyzer in the docs. ([#233](https://github.com/k8sgpt-ai/k8sgpt/issues/233)) ([ba01bd4](https://github.com/k8sgpt-ai/k8sgpt/commit/ba01bd4b6ecd64fbe249be54f20471afc6339208))
-
-
-### Other
-
-* add fakeai provider ([#218](https://github.com/k8sgpt-ai/k8sgpt/issues/218)) ([e449cb6](https://github.com/k8sgpt-ai/k8sgpt/commit/e449cb60230d440d5b8e00062db63de5d6d413bf))
-* adding k8sgpt-approvers ([#238](https://github.com/k8sgpt-ai/k8sgpt/issues/238)) ([db1388f](https://github.com/k8sgpt-ai/k8sgpt/commit/db1388fd20dcf21069adcecd2796f2e1231162c8))
-* adding k8sgpt-approvers ([#238](https://github.com/k8sgpt-ai/k8sgpt/issues/238)) ([992b107](https://github.com/k8sgpt-ai/k8sgpt/commit/992b107c2d906663bb22998004a0859bccd45c77))
-* compiling successfully ([80ac51c](https://github.com/k8sgpt-ai/k8sgpt/commit/80ac51c804351226e1764e3e649ac56e22de3749))
-* **deps:** update anchore/sbom-action action to v0.14.1 ([#228](https://github.com/k8sgpt-ai/k8sgpt/issues/228)) ([9423b53](https://github.com/k8sgpt-ai/k8sgpt/commit/9423b53c1dbae3d0762420a0bacbdace9a2c18c9))
-* **deps:** update google-github-actions/release-please-action digest to c078ea3 ([a1d8012](https://github.com/k8sgpt-ai/k8sgpt/commit/a1d8012a5c748aee3f16621d6da9a0f0c8cba293))
-* **deps:** update google-github-actions/release-please-action digest to f7edb9e ([#241](https://github.com/k8sgpt-ai/k8sgpt/issues/241)) ([55dda43](https://github.com/k8sgpt-ai/k8sgpt/commit/55dda432ab89c4917bd28fceabcbe5569c0bf530))
-* **deps:** update google-github-actions/release-please-action digest to f7edb9e ([#241](https://github.com/k8sgpt-ai/k8sgpt/issues/241)) ([21dc61c](https://github.com/k8sgpt-ai/k8sgpt/commit/21dc61c04f4d772b5147b38a4d28e5dbddf5cdd8))
-* fix mistake introduced by ab55f157 ([#240](https://github.com/k8sgpt-ai/k8sgpt/issues/240)) ([428c348](https://github.com/k8sgpt-ai/k8sgpt/commit/428c3485868a7be95ea6776694e30b36badf4b5c))
-* fix mistake introduced by ab55f157 ([#240](https://github.com/k8sgpt-ai/k8sgpt/issues/240)) ([3845d47](https://github.com/k8sgpt-ai/k8sgpt/commit/3845d4747f4e0fc823d1bcf631d6ecdd5e4ccd03))
-* Fixing broken tests ([c809af3](https://github.com/k8sgpt-ai/k8sgpt/commit/c809af3f47388599fda3a88a4638feae1dc90492))
-* fixing filters ([258c69a](https://github.com/k8sgpt-ai/k8sgpt/commit/258c69a17c977867dfd0a7ad02727270b7c172e7))
-* fixing filters ([4d20f70](https://github.com/k8sgpt-ai/k8sgpt/commit/4d20f70fb40ff326ceb279f699068ec4956a2f10))
-* merged ([096321b](https://github.com/k8sgpt-ai/k8sgpt/commit/096321b31a6cf0d53b1861a3e4ad1efe84f697cc))
-* updated analysis_test.go ([825e9a4](https://github.com/k8sgpt-ai/k8sgpt/commit/825e9a43bd3ab7aa3ea52f315993cd778ea039e3))
-* updated link output ([1b7f4ce](https://github.com/k8sgpt-ai/k8sgpt/commit/1b7f4ce44a499e5389aec42fdee00bfa81ef0888))
-* updating based on feedback ([5e5d4b6](https://github.com/k8sgpt-ai/k8sgpt/commit/5e5d4b6de160dc7533067e1c0d8403c3faac1a9f))
-* weird new line after filter removed ([fabe01a](https://github.com/k8sgpt-ai/k8sgpt/commit/fabe01aa019f1db45ed2ff780f0d6d63297b230b))
-
-## [0.2.0](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.8...v0.2.0) (2023-04-05)
-
-
-### ⚠ BREAKING CHANGES
-
-* The format of the configuration file has changed. Users must update their configuration files to use the new format.
-
-### Features
-
-* add support for new configuration format ([9b243cd](https://github.com/k8sgpt-ai/k8sgpt/commit/9b243cdcaab1742fca2516bc1ae5710505e0eb65))
-* add tests for hpa analyzer ([5a59abb](https://github.com/k8sgpt-ai/k8sgpt/commit/5a59abb55d9e76f3095b903ea973138b1afdccf2))
-* add tests for ingress analyzer && Use t.Fatalf to report a fatal error if RunAnalysis returns an unexpected error ([e27e940](https://github.com/k8sgpt-ai/k8sgpt/commit/e27e9409dcaad78eefd79659e91364617407ae59))
-
-
-### Bug Fixes
-
-* **deps:** update module github.com/sashabaranov/go-openai to v1.6.1 ([#207](https://github.com/k8sgpt-ai/k8sgpt/issues/207)) ([eeac731](https://github.com/k8sgpt-ai/k8sgpt/commit/eeac731858999f6f462a7b6ccf210af603674b30))
-* **deps:** update module github.com/spf13/cobra to v1.7.0 ([5d5e082](https://github.com/k8sgpt-ai/k8sgpt/commit/5d5e082f417905954be33b3a620efef674f2588d))
-* **deps:** update module github.com/stretchr/testify to v1.8.2 ([f5e3ca0](https://github.com/k8sgpt-ai/k8sgpt/commit/f5e3ca0bcab9325145a2e1d8624f585ffee8e29f))
-* **deps:** update module golang.org/x/term to v0.7.0 ([8ab3573](https://github.com/k8sgpt-ai/k8sgpt/commit/8ab3573e13a3e3ab98e6f0aa76e429117c888f7f))
-* details in json output ([2f21002](https://github.com/k8sgpt-ai/k8sgpt/commit/2f2100289953af7820bbb01f2c980cf5492de079))
-* fixed hpa tests after rebase ([a24d1f1](https://github.com/k8sgpt-ai/k8sgpt/commit/a24d1f1b304e9448e63c1b7fc283b4cc8bc639aa))
-* regression on dynamic filters ([93bcc62](https://github.com/k8sgpt-ai/k8sgpt/commit/93bcc627ba64a9139e65290a8512e0a9b4bf1a69))
-* Spelling ([ba4d701](https://github.com/k8sgpt-ai/k8sgpt/commit/ba4d7016814ce97353e98658d5bbcd692007e4a9))
-
-
-### Docs
-
-* add curl command and release-please annoations ([1849209](https://github.com/k8sgpt-ai/k8sgpt/commit/184920988f7da928cca7fae4a676e4ee5f13cad1))
-* add guide to details block ([ddc120e](https://github.com/k8sgpt-ai/k8sgpt/commit/ddc120e7c2657385737d3490def28dbabdd2242d))
-* add installation guide via packages ([8e4ce6a](https://github.com/k8sgpt-ai/k8sgpt/commit/8e4ce6a974813258fb9cbeabbcaa3b8f6966a748))
-* minor change ([53c1330](https://github.com/k8sgpt-ai/k8sgpt/commit/53c13305383eb454fe45fefa3483cef4821d5d34))
-* modify README ([fc47c58](https://github.com/k8sgpt-ai/k8sgpt/commit/fc47c58ae1c2b5511ebbe0ed35714e4ecbb4bb7a))
-* modify README ([0f46ceb](https://github.com/k8sgpt-ai/k8sgpt/commit/0f46ceb4456a90e7e05aeff23d25d5775bbf9c2b))
-
-
-### Other
-
-* added initial tests for json output ([22e3166](https://github.com/k8sgpt-ai/k8sgpt/commit/22e31661bff27b28339898826a34ffdcfcff3583))
-* analyzer and ai interfacing ([#200](https://github.com/k8sgpt-ai/k8sgpt/issues/200)) ([0195bfa](https://github.com/k8sgpt-ai/k8sgpt/commit/0195bfab30ab748b3bb7f1b8c8f0e988b99ee54d))
-* **deps:** pin anchore/sbom-action action to 448520c ([#203](https://github.com/k8sgpt-ai/k8sgpt/issues/203)) ([9ff3fbc](https://github.com/k8sgpt-ai/k8sgpt/commit/9ff3fbc382ed78b55a7a1966ecdae186c03b2848))
-* **deps:** update golang docker tag to v1.20.3 ([e9994b8](https://github.com/k8sgpt-ai/k8sgpt/commit/e9994b8d167d4f1d9c0d0dabf8385ff22cfd16a4))
-* made json output prettier and improved output ([db40734](https://github.com/k8sgpt-ai/k8sgpt/commit/db40734a0db89850a2a685c9a7f5f5559875b7b3))
-
-## [0.1.8](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.7...v0.1.8) (2023-04-03)
-
-
-### Features
-
-* add password flag for backend authentication ([#199](https://github.com/k8sgpt-ai/k8sgpt/issues/199)) ([075a940](https://github.com/k8sgpt-ai/k8sgpt/commit/075a940d2c9bdd8aa9162940ed46abad47d46998))
-* adding shields to readme ([213ecd8](https://github.com/k8sgpt-ai/k8sgpt/commit/213ecd8e83933fabaa5d3d674c67958599dd72ce))
-* adding unit testing and example ([35b838b](https://github.com/k8sgpt-ai/k8sgpt/commit/35b838bfafa248dbf3932c7a3ee708b1a1539f18))
-* alias filter to filters ([dde4e83](https://github.com/k8sgpt-ai/k8sgpt/commit/dde4e833b0e87553dea4e5c1e17a14e303956bc1))
-* analyzer ifacing ([426f562](https://github.com/k8sgpt-ai/k8sgpt/commit/426f562be83ed0e708a07b9e1900ac06fa017c27))
-* service test ([44cc8f7](https://github.com/k8sgpt-ai/k8sgpt/commit/44cc8f7ad68d152ec577e57cab7d8d9ab9613378))
-* test workflow ([5f30a4d](https://github.com/k8sgpt-ai/k8sgpt/commit/5f30a4ddf44ebff949bb0573f261667539a2dcfb))
-
-
-### Bug Fixes
-
-* **deps:** update module github.com/sashabaranov/go-openai to v1.5.8 ([91fb065](https://github.com/k8sgpt-ai/k8sgpt/commit/91fb06530a21259da6e72c28342e743d2b481294))
-
-
-### Other
-
-* create linux packages ([#201](https://github.com/k8sgpt-ai/k8sgpt/issues/201)) ([67753be](https://github.com/k8sgpt-ai/k8sgpt/commit/67753be6f317c462ebe1d9a316f2b0c9684ca4e5))
-* **deps:** pin dependencies ([#198](https://github.com/k8sgpt-ai/k8sgpt/issues/198)) ([f8291aa](https://github.com/k8sgpt-ai/k8sgpt/commit/f8291aab085209f9fee13a6c92c96076163e2e90))
-
-## [0.1.7](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.6...v0.1.7) (2023-04-02)
-
-
-### Features
-
-* add hpa analyzer and init additionalAnalyzers ([3603872](https://github.com/k8sgpt-ai/k8sgpt/commit/360387249feb9a999286aaa874a13007986219a5))
-* add pda analyzer ([532a5ce](https://github.com/k8sgpt-ai/k8sgpt/commit/532a5ce0332a8466df42bc944800e6668e349801))
-* check if ScaleTargetRef is possible option ([5dad75f](https://github.com/k8sgpt-ai/k8sgpt/commit/5dad75fbe9fd15cfa7bfa69c046b851ea905876f))
-
-
-### Bug Fixes
-
-* hpaAnalyzer analysis result is using wrong parent ([1190fe6](https://github.com/k8sgpt-ai/k8sgpt/commit/1190fe60fdd6e66ce435874628039df7047a52b9))
-* spelling of PodDisruptionBudget ([ceff008](https://github.com/k8sgpt-ai/k8sgpt/commit/ceff0084df1b6de16f1ed503ee8a4b3c1a9f8648))
-* update client API call to use StatefulSet instead of Deployment ([4916fef](https://github.com/k8sgpt-ai/k8sgpt/commit/4916fef9d6b75c54bcfbc5d136550018e96e3632))
-
-
-### Refactoring
-
-* merged main into branch ([3e836d8](https://github.com/k8sgpt-ai/k8sgpt/commit/3e836d81b7c33ce5c0c133c2e1ca3b0c8d3eeeb0)), closes [#101](https://github.com/k8sgpt-ai/k8sgpt/issues/101)
-
-
-### Other
-
-* **deps:** update anchore/sbom-action action to v0.14.1 ([80f29da](https://github.com/k8sgpt-ai/k8sgpt/commit/80f29dae4fd6f6348967192ce2f51f0e0fb5dea0))
-* merge branch 'chetanguptaa-some-fixes' ([071ee56](https://github.com/k8sgpt-ai/k8sgpt/commit/071ee560f36b64b4c65274181e2d13bb14d5b914))
-* refine renovate config ([#172](https://github.com/k8sgpt-ai/k8sgpt/issues/172)) ([d23da9a](https://github.com/k8sgpt-ai/k8sgpt/commit/d23da9ae836a07f0fd59c20a1c3c71d6b7f75277))
-* removes bar on normal analyze events ([e1d8992](https://github.com/k8sgpt-ai/k8sgpt/commit/e1d89920b097db4417c55b020fb23dd8cbaf19ed))
-* removes bar on normal analyze events ([96d0d75](https://github.com/k8sgpt-ai/k8sgpt/commit/96d0d754eab67c0742d3a36a1eefb9c28df59e96))
-* update dependencies ([#174](https://github.com/k8sgpt-ai/k8sgpt/issues/174)) ([9d9c262](https://github.com/k8sgpt-ai/k8sgpt/commit/9d9c26214fbb4c4faba7ef85f2204bc961396de8))
-
-
-### Docs
-
-* add pdbAnalyzer as optional analyzer ([f6974d0](https://github.com/k8sgpt-ai/k8sgpt/commit/f6974d07581384e260059f121242854320dfc58b))
-
 ## [0.1.6](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.1.5...v0.1.6) (2023-03-31)


--- a/README.md
+++ b/README.md
@@ -2,87 +2,20 @@
  <source media="(prefers-color-scheme: dark)" srcset="./images/banner-white.png" width="600px;">
  <img alt="Text changing depending on mode. Light: 'So light!' Dark: 'So dark!'" src="./images/banner-black.png" width="600px;">
 </picture>
-<br/>
-
-![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/k8sgpt-ai/k8sgpt)
-![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/k8sgpt-ai/k8sgpt/release.yaml)
-![GitHub release (latest by date)](https://img.shields.io/github/v/release/k8sgpt-ai/k8sgpt)

 `k8sgpt` is a tool for scanning your Kubernetes clusters, diagnosing, and triaging issues in simple English.

 It has SRE experience codified into its analyzers and helps to pull out the most relevant information to enrich it with AI.

-# Installation
+## Installation

-
-## Linux/Mac via brew
+### Linux/Mac via brew

 ```
 brew tap k8sgpt-ai/k8sgpt
 brew install k8sgpt
 ```

-<details>
-  <summary>RPM-based installation (RedHat/CentOS/Fedora)</summary>
-
-  **32 bit:**
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_386.rpm
-  sudo rpm -ivh k8sgpt_386.rpm
-  ```
-  <!---x-release-please-end-->
-
-  **64 bit:**
- 
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_amd64.rpm
-  sudo rpm -ivh -i k8sgpt_amd64.rpm
-  ```
-  <!---x-release-please-end-->
-</details>
-
-<details>
-  <summary>DEB-based installation (Ubuntu/Debian)</summary>
-
-  **32 bit:**
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_386.deb
-  sudo dpkg -i k8sgpt_386.deb
-  ```
-  <!---x-release-please-end-->
-  **64 bit:**
- 
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_amd64.deb
-  sudo dpkg -i k8sgpt_amd64.deb
-  ```
-  <!---x-release-please-end-->
-</details>
-
-<details>
-
-  <summary>APK-based installation (Alpine)</summary>
-
-  **32 bit:**
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_386.apk
-  apk add k8sgpt_386.apk
-  ```
-  <!---x-release-please-end-->
-  **64 bit:**
-  <!---x-release-please-start-version-->
-  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.1/k8sgpt_amd64.apk
-  apk add k8sgpt_amd64.apk
-  ```
-  <!---x-release-please-end-->x
-</details>
-
 <details>
  <summary>Failing Installation on WSL or Linux (missing gcc)</summary>
  When installing Homebrew on WSL or Linux, you may encounter the following error:
@@ -99,26 +32,21 @@ If you install gcc as suggested, the problem will persist. Therefore, you need t
  ```
 </details>

-
-## Windows
+### Windows

 * Download the latest Windows binaries of **k8sgpt** from the [Release](https://github.com/k8sgpt-ai/k8sgpt/releases) 
  tab based on your system architecture.
 * Extract the downloaded package to your desired location. Configure the system *path* variable with the binary location

-
-## Verify installation
+### Verify installation

 * Run `k8sgpt version`

-<hr>
-
 ## Quick Start

 * Currently the default AI provider is OpenAI, you will need to generate an API key from [OpenAI](https://openai.com)
  * You can do this by running `k8sgpt generate` to open a browser link to generate it
-* Run `k8sgpt auth` to set it in k8sgpt. 
-  * You can provide the password directly using the `--password` flag.
+* Run `k8sgpt auth` to set it in k8sgpt.
 * Run `k8sgpt filters` to manage the active filters used by the analyzer. By default, all filters are executed during analysis.
 * Run `k8sgpt analyze` to run a scan.
 * And use `k8sgpt analyze --explain` to get a more detailed explanation of the issues.
@@ -140,12 +68,10 @@ you will be able to write your own analyzers.
 - [x] serviceAnalyzer
 - [x] eventAnalyzer
 - [x] ingressAnalyzer
- [x] statefulSetAnalyzer

 #### Optional

 - [x] hpaAnalyzer
- [x] pdbAnalyzer

 ## Usage

@@ -227,40 +153,6 @@ _Output to JSON_
 k8sgpt analyze --explain --filter=Service --output=json
 ```

-_Anonymize during explain_
-
-```
-k8sgpt analyze --explain --filter=Service --output=json --anonymize
-```
-
-### How does anonymization work?
-
-With this option, the data is anonymized before being sent to the AI Backend. During the analysis execution, `k8sgpt` retrieves sensitive data (Kubernetes object names, labels, etc.). This data is masked when sent to the AI backend and replaced by a key that can be used to de-anonymize the data when the solution is returned to the user.
-
-<details>
-
-1. Error reported during analysis:
-```bash
-Error: HorizontalPodAutoscaler uses StatefulSet/fake-deployment as ScaleTargetRef which does not exist.
-```
-
-2. Payload sent to the AI backend:
-```bash
-Error: HorizontalPodAutoscaler uses StatefulSet/tGLcCRcHa1Ce5Rs as ScaleTargetRef which does not exist.
-```
-
-3. Payload returned by the AI:
-```bash
-The Kubernetes system is trying to scale a StatefulSet named tGLcCRcHa1Ce5Rs using the HorizontalPodAutoscaler, but it cannot find the StatefulSet. The solution is to verify that the StatefulSet name is spelled correctly and exists in the same namespace as the HorizontalPodAutoscaler.
-```
-
-4. Payload returned to the user:
-```bash
-The Kubernetes system is trying to scale a StatefulSet named fake-deployment using the HorizontalPodAutoscaler, but it cannot find the StatefulSet. The solution is to verify that the StatefulSet name is spelled correctly and exists in the same namespace as the HorizontalPodAutoscaler.
-```
-
-**Anonymization does not currently apply to events.**
-
 ## Upcoming major milestones

 - [ ] Multiple AI backend support
@@ -285,8 +177,4 @@ the root cause of an issue.

 Please read our [contributing guide](./CONTRIBUTING.md).
 ## Community
-Find us on [Slack](https://k8sgpt.slack.com/)
-
-<a href="https://github.com/k8sgpt-ai/k8sgpt/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=k8sgpt-ai/k8sgpt" />
-</a>
+* Find us on [Slack](https://k8sgpt.slack.com/)
--- a/cmd/analyze/analyze.go
+++ b/cmd/analyze/analyze.go
@@ -3,14 +3,13 @@ package analyze
 import (
 	"context"
 	"fmt"
-	"os"
-
 	"github.com/fatih/color"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/analysis"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"os"
 )

 var (
@@ -21,7 +20,6 @@ var (
 	language  string
 	nocache   bool
 	namespace string
-	anonymize bool
 )

 // AnalyzeCmd represents the problems command
@@ -33,97 +31,64 @@ var AnalyzeCmd = &cobra.Command{
 	provide you with a list of issues that need to be resolved`,
 	Run: func(cmd *cobra.Command, args []string) {

-		// get ai configuration
-		var configAI ai.AIConfiguration
-		err := viper.UnmarshalKey("ai", &configAI)
-		if err != nil {
-			color.Red("Error: %v", err)
+		// get backend from file
+		backendType := viper.GetString("backend_type")
+		if backendType == "" {
+			color.Red("No backend set. Please run k8sgpt auth")
+			os.Exit(1)
+		}
+		// override the default backend if a flag is provided
+		if backend != "" {
+			backendType = backend
+		}
+		// get the token with viper
+		token := viper.GetString(fmt.Sprintf("%s_key", backendType))
+		// check if nil
+		if token == "" {
+			color.Red("No %s key set. Please run k8sgpt auth", backendType)
 			os.Exit(1)
 		}

-		if len(configAI.Providers) == 0 {
-			color.Red("Error: AI provider not specified in configuration. Please run k8sgpt auth")
-			os.Exit(1)
-		}
-
-		var aiProvider ai.AIProvider
-		for _, provider := range configAI.Providers {
-			if backend == provider.Name {
-				aiProvider = provider
-				break
+		var aiClient ai.IAI
+		switch backendType {
+		case "openai":
+			aiClient = &ai.OpenAIClient{}
+			if err := aiClient.Configure(token, language); err != nil {
+				color.Red("Error: %v", err)
+				os.Exit(1)
 			}
-		}
-
-		if aiProvider.Name == "" {
-			color.Red("Error: AI provider %s not specified in configuration. Please run k8sgpt auth", backend)
-			os.Exit(1)
-		}
-
-		aiClient := ai.NewClient(aiProvider.Name)
-		if err := aiClient.Configure(aiProvider.Password, aiProvider.Model, language); err != nil {
-			color.Red("Error: %v", err)
+		default:
+			color.Red("Backend not supported")
 			os.Exit(1)
 		}

 		ctx := context.Background()
 		// Get kubernetes client from viper
-
-		kubecontext := viper.GetString("kubecontext")
-		kubeconfig := viper.GetString("kubeconfig")
-		client, err := kubernetes.NewClient(kubecontext, kubeconfig)
-		if err != nil {
-			color.Red("Error initialising kubernetes client: %v", err)
-			os.Exit(1)
-		}
-
+		client := viper.Get("kubernetesClient").(*kubernetes.Client)
 		// AnalysisResult configuration
-		config := &analysis.Analysis{
+
+		analysis := &analysis.Analysis{
+			Context:   ctx,
 			Namespace: namespace,
 			NoCache:   nocache,
-			Filters:   filters,
 			Explain:   explain,
 			AIClient:  aiClient,
+			Filters:   filters,
 			Client:    client,
-			Context:   ctx,
 		}

-		err = config.RunAnalysis()
-		if err != nil {
-			color.Red("Error: %v", err)
-			os.Exit(1)
-		}
+		// Run analysis
+		_ = analysis.RunAnalysis()

-		if explain {
-			err := config.GetAIResults(output, anonymize)
-			if err != nil {
-				color.Red("Error: %v", err)
-				os.Exit(1)
-			}
-		}
-
-		// print results
-		switch output {
-		case "json":
-			output, err := config.JsonOutput()
-			if err != nil {
-				color.Red("Error: %v", err)
-				os.Exit(1)
-			}
-			fmt.Println(string(output))
-		default:
-			config.PrintOutput()
-		}
+		analysis.PrintAnalysisResult()
 	},
 }

 func init() {
-
 	// namespace flag
 	AnalyzeCmd.Flags().StringVarP(&namespace, "namespace", "n", "", "Namespace to analyze")
 	// no cache flag
 	AnalyzeCmd.Flags().BoolVarP(&nocache, "no-cache", "c", false, "Do not use cached data")
-	// anonymize flag
-	AnalyzeCmd.Flags().BoolVarP(&anonymize, "anonymize", "a", false, "Anonymize data before sending it to the AI backend. This flag masks sensitive data, such as Kubernetes object names and labels, by replacing it with a key. However, please note that this flag does not currently apply to events.")
 	// array of strings flag
 	AnalyzeCmd.Flags().StringSliceVarP(&filters, "filter", "f", []string{}, "Filter for these analyzers (e.g. Pod, PersistentVolumeClaim, Service, ReplicaSet)")
 	// explain flag
--- a/cmd/auth/auth.go
+++ b/cmd/auth/auth.go
@@ -7,16 +7,13 @@ import (
 	"syscall"

 	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"golang.org/x/term"
 )

 var (
-	backend  string
-	password string
-	model    string
+	backend string
 )

 // authCmd represents the auth command
@@ -26,65 +23,31 @@ var AuthCmd = &cobra.Command{
 	Long:  `Provide the necessary credentials to authenticate with your chosen backend.`,
 	Run: func(cmd *cobra.Command, args []string) {

-		// get ai configuration
-		var configAI ai.AIConfiguration
-		err := viper.UnmarshalKey("ai", &configAI)
-		if err != nil {
-			color.Red("Error: %v", err)
-			os.Exit(1)
-		}
-
-		// search for provider with same name
-		providerIndex := -1
-		for i, provider := range configAI.Providers {
-			if backend == provider.Name {
-				providerIndex = i
-				break
-			}
-		}
-
-		// check if backend is not empty
-		if backend == "" {
-			color.Red("Error: Backend AI cannot be empty.")
-			os.Exit(1)
-		}
-
-		color.Green("Using %s as backend AI provider", backend)
-
-		// check if model is not empty
-		if model == "" {
-			color.Red("Error: Model cannot be empty.")
-			os.Exit(1)
-		}
-
-		if password == "" {
-			fmt.Printf("Enter %s Key: ", backend)
-			bytePassword, err := term.ReadPassword(int(syscall.Stdin))
-			if err != nil {
-				color.Red("Error reading %s Key from stdin: %s", backend,
-					err.Error())
+		backendType := viper.GetString("backend_type")
+		if backendType == "" {
+			// Set the default backend
+			viper.Set("backend_type", "openai")
+			if err := viper.WriteConfig(); err != nil {
+				color.Red("Error writing config file: %s", err.Error())
 				os.Exit(1)
 			}
-			password = strings.TrimSpace(string(bytePassword))
+		}
+		// override the default backend if a flag is provided
+		if backend != "" {
+			backendType = backend
+			color.Green("Using %s as backend AI provider", backendType)
 		}

-		// create new provider object
-		newProvider := ai.AIProvider{
-			Name:     backend,
-			Model:    model,
-			Password: password,
+		fmt.Printf("Enter %s Key: ", backendType)
+		bytePassword, err := term.ReadPassword(int(syscall.Stdin))
+		if err != nil {
+			color.Red("Error reading %s Key from stdin: %s", backendType,
+				err.Error())
+			os.Exit(1)
 		}
+		password := strings.TrimSpace(string(bytePassword))

-		if providerIndex == -1 {
-			// provider with same name does not exist, add new provider to list
-			configAI.Providers = append(configAI.Providers, newProvider)
-			color.Green("New provider added")
-		} else {
-			// provider with same name exists, update provider info
-			configAI.Providers[providerIndex] = newProvider
-			color.Green("Provider updated")
-		}
-		viper.Set("ai", configAI)
+		viper.Set(fmt.Sprintf("%s_key", backendType), password)
 		if err := viper.WriteConfig(); err != nil {
 			color.Red("Error writing config file: %s", err.Error())
 			os.Exit(1)
@@ -96,8 +59,4 @@ var AuthCmd = &cobra.Command{
 func init() {
 	// add flag for backend
 	AuthCmd.Flags().StringVarP(&backend, "backend", "b", "openai", "Backend AI provider")
-	// add flag for model
-	AuthCmd.Flags().StringVarP(&model, "model", "m", "gpt-3.5-turbo", "Backend AI model")
-	// add flag for password
-	AuthCmd.Flags().StringVarP(&password, "password", "p", "", "Backend AI password")
 }
--- a/cmd/filters/add.go
+++ b/cmd/filters/add.go
@@ -18,9 +18,10 @@ var addCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		inputFilters := strings.Split(args[0], ",")
-		coreFilters, additionalFilters, integrationFilters := analyzer.ListFilters()
+		coreFilters, additionalFilters := analyzer.ListFilters()
+
+		availableFilters := append(coreFilters, additionalFilters...)

-		availableFilters := append(append(coreFilters, additionalFilters...), integrationFilters...)
 		// Verify filter exist
 		invalidFilters := []string{}
 		for _, f := range inputFilters {
--- a/cmd/filters/filters.go
+++ b/cmd/filters/filters.go
@@ -6,7 +6,7 @@ import (

 var FiltersCmd = &cobra.Command{
 	Use:     "filters",
-	Aliases: []string{"filter"},
+	Aliases: []string{"filters"},
 	Short:   "Manage filters for analyzing Kubernetes resources",
 	Long: `The filters command allows you to manage filters that are used to analyze Kubernetes resources.
 	You can list available filters to analyze resources.`,
--- a/cmd/filters/list.go
+++ b/cmd/filters/list.go
@@ -16,35 +16,23 @@ var listCmd = &cobra.Command{
 	Long:  `The list command displays a list of available filters that can be used to analyze Kubernetes resources.`,
 	Run: func(cmd *cobra.Command, args []string) {
 		activeFilters := viper.GetStringSlice("active_filters")
-		coreFilters, additionalFilters, integrationFilters := analyzer.ListFilters()
-
-		availableFilters := append(append(coreFilters, additionalFilters...), integrationFilters...)
+		coreFilters, additionalFilters := analyzer.ListFilters()

+		availableFilters := append(coreFilters, additionalFilters...)
 		if len(activeFilters) == 0 {
 			activeFilters = coreFilters
 		}
+
 		inactiveFilters := util.SliceDiff(availableFilters, activeFilters)
 		fmt.Printf(color.YellowString("Active: \n"))
 		for _, filter := range activeFilters {
-
-			// if the filter is an integration, mark this differently
-			if util.SliceContainsString(integrationFilters, filter) {
-				fmt.Printf("> %s\n", color.BlueString("%s (integration)", filter))
-			} else {
-				fmt.Printf("> %s\n", color.GreenString(filter))
-			}
+			fmt.Printf("> %s\n", color.GreenString(filter))
 		}
-
 		// display inactive filters
 		if len(inactiveFilters) != 0 {
 			fmt.Printf(color.YellowString("Unused: \n"))
 			for _, filter := range inactiveFilters {
-				// if the filter is an integration, mark this differently
-				if util.SliceContainsString(integrationFilters, filter) {
-					fmt.Printf("> %s\n", color.BlueString("%s (integration)", filter))
-				} else {
-					fmt.Printf("> %s\n", color.RedString(filter))
-				}
+				fmt.Printf("> %s\n", color.RedString(filter))
 			}
 		}

--- a/cmd/filters/remove.go
+++ b/cmd/filters/remove.go
@@ -21,7 +21,7 @@ var removeCmd = &cobra.Command{

 		// Get defined active_filters
 		activeFilters := viper.GetStringSlice("active_filters")
-		coreFilters, _, _ := analyzer.ListFilters()
+		coreFilters, _ := analyzer.ListFilters()

 		if len(activeFilters) == 0 {
 			activeFilters = coreFilters
--- a/cmd/generate/generate.go
+++ b/cmd/generate/generate.go
@@ -7,6 +7,7 @@ import (
 	"github.com/spf13/viper"
 	"os/exec"
 	"runtime"
+	"time"
 )

 var (
@@ -30,6 +31,10 @@ var GenerateCmd = &cobra.Command{
 			backendType = backend
 		}
 		fmt.Println("")
+		color.Green("Opening: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
+		color.Green("Please copy the generated key and run `k8sgpt auth` to add it to your config file")
+		fmt.Println("")
+		time.Sleep(5 * time.Second)
 		openbrowser("https://beta.openai.com/account/api-keys")
 	},
 }
@@ -41,15 +46,9 @@ func init() {

 func openbrowser(url string) {
 	var err error
-	isGui := true
 	switch runtime.GOOS {
 	case "linux":
-		_, err = exec.LookPath("xdg-open")
-		if err != nil {
-			isGui = false
-		} else {
-			err = exec.Command("xdg-open", url).Start()
-		}
+		err = exec.Command("xdg-open", url).Start()
 	case "windows":
 		err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
 	case "darwin":
@@ -57,21 +56,7 @@ func openbrowser(url string) {
 	default:
 		err = fmt.Errorf("unsupported platform")
 	}
-	printInstructions(isGui, backend)
 	if err != nil {
 		fmt.Println(err)
 	}
 }
-
-func printInstructions(isGui bool, backendType string) {
-	fmt.Println("")
-	if isGui {
-		color.Green("Opening: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
-		fmt.Println("")
-	} else {
-		color.Green("Please open: https://beta.openai.com/account/api-keys to generate a key for %s", backendType)
-		fmt.Println("")
-	}
-	color.Green("Please copy the generated key and run `k8sgpt auth` to add it to your config file")
-	fmt.Println("")
-}
--- a/cmd/integration/activate.go
+++ b/cmd/integration/activate.go
@@ -1,33 +0,0 @@
-package integration
-
-import (
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration"
-	"github.com/spf13/cobra"
-)
-
-// activateCmd represents the activate command
-var activateCmd = &cobra.Command{
-	Use:   "activate [integration]",
-	Short: "Activate an integration",
-	Long:  ``,
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		integrationName := args[0]
-
-		integration := integration.NewIntegration()
-		// Check if the integation exists
-		err := integration.Activate(integrationName, namespace)
-		if err != nil {
-			color.Red("Error: %v", err)
-			return
-		}
-
-		color.Green("Activated integration %s", integrationName)
-	},
-}
-
-func init() {
-	IntegrationCmd.AddCommand(activateCmd)
-
-}
--- a/cmd/integration/deactivate.go
+++ b/cmd/integration/deactivate.go
@@ -1,35 +0,0 @@
-/*
-Copyright © 2023 NAME HERE <EMAIL ADDRESS>
-*/
-package integration
-
-import (
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration"
-	"github.com/spf13/cobra"
-)
-
-// deactivateCmd represents the deactivate command
-var deactivateCmd = &cobra.Command{
-	Use:   "deactivate [integration]",
-	Short: "Deactivate an integration",
-	Args:  cobra.ExactArgs(1),
-	Long:  `For example e.g. k8sgpt integration deactivate trivy`,
-	Run: func(cmd *cobra.Command, args []string) {
-		integrationName := args[0]
-
-		integration := integration.NewIntegration()
-
-		if err := integration.Deactivate(integrationName, namespace); err != nil {
-			color.Red("Error: %v", err)
-			return
-		}
-
-		color.Green("Deactivated integration %s", integrationName)
-
-	},
-}
-
-func init() {
-	IntegrationCmd.AddCommand(deactivateCmd)
-}
--- a/cmd/integration/integration.go
+++ b/cmd/integration/integration.go
@@ -1,28 +0,0 @@
-package integration
-
-import (
-	"github.com/spf13/cobra"
-)
-
-var (
-	namespace string
-)
-
-// IntegrationCmd represents the integrate command
-var IntegrationCmd = &cobra.Command{
-	Use:     "integration",
-	Aliases: []string{"integrations"},
-	Short:   "Intergrate another tool into K8sGPT",
-	Long: `Intergrate another tool into K8sGPT. For example:
-	
-	k8sgpt integration activate trivy
-	
-	This would allow you to deploy trivy into your cluster and use a K8sGPT analyzer to parse trivy results.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		cmd.Help()
-	},
-}
-
-func init() {
-	IntegrationCmd.PersistentFlags().StringVarP(&namespace, "namespace", "n", "default", "The namespace to use for the integration")
-}
--- a/cmd/integration/list.go
+++ b/cmd/integration/list.go
@@ -1,50 +0,0 @@
-package integration
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration"
-	"github.com/spf13/cobra"
-)
-
-// listCmd represents the list command
-var listCmd = &cobra.Command{
-	Use:   "list",
-	Short: "Lists built-in integrations",
-	Long:  ``,
-	Run: func(cmd *cobra.Command, args []string) {
-		integrationProvider := integration.NewIntegration()
-		integrations := integrationProvider.List()
-
-		fmt.Println(color.YellowString("Active:"))
-		for _, i := range integrations {
-			b, err := integrationProvider.IsActivate(i)
-			if err != nil {
-				fmt.Println(err)
-				os.Exit(1)
-			}
-			if b {
-				fmt.Printf("> %s\n", color.GreenString(i))
-			}
-		}
-
-		fmt.Println(color.YellowString("Unused: "))
-		for _, i := range integrations {
-			b, err := integrationProvider.IsActivate(i)
-			if err != nil {
-				fmt.Println(err)
-				os.Exit(1)
-			}
-			if !b {
-				fmt.Printf("> %s\n", color.GreenString(i))
-			}
-		}
-	},
-}
-
-func init() {
-	IntegrationCmd.AddCommand(listCmd)
-
-}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -4,14 +4,16 @@ import (
 	"os"
 	"path/filepath"

-	"github.com/k8sgpt-ai/k8sgpt/cmd/analyze"
-	"github.com/k8sgpt-ai/k8sgpt/cmd/auth"
 	"github.com/k8sgpt-ai/k8sgpt/cmd/filters"
 	"github.com/k8sgpt-ai/k8sgpt/cmd/generate"
-	"github.com/k8sgpt-ai/k8sgpt/cmd/integration"
+	"k8s.io/client-go/util/homedir"
+
+	"github.com/fatih/color"
+	"github.com/k8sgpt-ai/k8sgpt/cmd/analyze"
+	"github.com/k8sgpt-ai/k8sgpt/cmd/auth"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"k8s.io/client-go/util/homedir"
 )

 var (
@@ -52,10 +54,13 @@ func init() {
 	rootCmd.AddCommand(analyze.AnalyzeCmd)
 	rootCmd.AddCommand(filters.FiltersCmd)
 	rootCmd.AddCommand(generate.GenerateCmd)
-	rootCmd.AddCommand(integration.IntegrationCmd)
 	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.k8sgpt.yaml)")
 	rootCmd.PersistentFlags().StringVar(&kubecontext, "kubecontext", "", "Kubernetes context to use. Only required if out-of-cluster.")
 	rootCmd.PersistentFlags().StringVar(&kubeconfig, "kubeconfig", kubeconfigPath, "Path to a kubeconfig. Only required if out-of-cluster.")
+	// Cobra also supports local flags, which will only run
+	// when this action is called directly.
+	// rootCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+
 }

 // initConfig reads in config file and ENV variables if set.
@@ -76,8 +81,14 @@ func initConfig() {
 		viper.SafeWriteConfig()
 	}

-	viper.Set("kubecontext", kubecontext)
-	viper.Set("kubeconfig", kubeconfig)
+	//Initialise the kubeconfig
+	kubernetesClient, err := kubernetes.NewClient(kubecontext, kubeconfig)
+	if err != nil {
+		color.Red("Error initialising kubernetes client: %v", err)
+		os.Exit(1)
+	}
+
+	viper.Set("kubernetesClient", kubernetesClient)

 	viper.AutomaticEnv() // read in environment variables that match

--- a/container/Dockerfile
+++ b/container/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.20.3-alpine3.16 AS builder
+FROM golang:1.20.2-alpine3.16 AS builder

 ENV CGO_ENABLED=0

--- a/go.mod
+++ b/go.mod
@@ -3,172 +3,64 @@ module github.com/k8sgpt-ai/k8sgpt
 go 1.20

 require (
-	github.com/aquasecurity/trivy-operator v0.13.0
 	github.com/fatih/color v1.15.0
-	github.com/magiconair/properties v1.8.7
-	github.com/mittwald/go-helm-client v0.12.1
-	github.com/sashabaranov/go-openai v1.7.0
-	github.com/schollz/progressbar/v3 v3.13.1
-	github.com/spf13/cobra v1.7.0
+	github.com/sashabaranov/go-openai v1.5.7
+	github.com/spf13/cobra v1.6.1
 	github.com/spf13/viper v1.15.0
-	github.com/stretchr/testify v1.8.2
-	golang.org/x/term v0.7.0
-	helm.sh/helm/v3 v3.11.2
+	golang.org/x/term v0.6.0
 	k8s.io/api v0.26.3
 	k8s.io/apimachinery v0.26.3
 	k8s.io/client-go v0.26.3
-	k8s.io/kubectl v0.26.3
-
 )

 require (
-	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
-	github.com/BurntSushi/toml v1.2.1 // indirect
-	github.com/MakeNowJust/heredoc v1.0.0 // indirect
-	github.com/Masterminds/goutils v1.1.1 // indirect
-	github.com/Masterminds/semver/v3 v3.2.0 // indirect
-	github.com/Masterminds/sprig/v3 v3.2.3 // indirect
-	github.com/Masterminds/squirrel v1.5.3 // indirect
-	github.com/aquasecurity/defsec v0.85.0 // indirect
-	github.com/aquasecurity/go-dep-parser v0.0.0-20230324043952-2172dc218241 // indirect
-	github.com/aquasecurity/table v1.8.0 // indirect
-	github.com/aquasecurity/tml v0.6.1 // indirect
-	github.com/aquasecurity/trivy v0.39.0 // indirect
-	github.com/aquasecurity/trivy-db v0.0.0-20230116084806-4bcdf1c414d0 // indirect
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d // indirect
-	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/chai2010/gettext-go v1.0.2 // indirect
-	github.com/containerd/containerd v1.6.19 // indirect
-	github.com/cyphar/filepath-securejoin v0.2.3 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/docker/cli v23.0.1+incompatible // indirect
-	github.com/docker/distribution v2.8.1+incompatible // indirect
-	github.com/docker/docker v23.0.1+incompatible // indirect
-	github.com/docker/docker-credential-helpers v0.7.0 // indirect
-	github.com/docker/go-connections v0.4.0 // indirect
-	github.com/docker/go-metrics v0.0.1 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
 	github.com/emicklei/go-restful/v3 v3.10.2 // indirect
-	github.com/evanphx/json-patch v5.6.0+incompatible // indirect
-	github.com/exponent-io/jsonpath v0.0.0-20210407135951-1de76d718b3f // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/go-errors/errors v1.4.2 // indirect
-	github.com/go-gorp/gorp/v3 v3.1.0 // indirect
 	github.com/go-logr/logr v1.2.4 // indirect
 	github.com/go-openapi/jsonpointer v0.19.6 // indirect
 	github.com/go-openapi/jsonreference v0.20.2 // indirect
 	github.com/go-openapi/swag v0.22.3 // indirect
-	github.com/gobwas/glob v0.2.3 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/google/btree v1.1.2 // indirect
 	github.com/google/gnostic v0.6.9 // indirect
 	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/google/go-containerregistry v0.14.0 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
 	github.com/google/uuid v1.3.0 // indirect
-	github.com/gorilla/mux v1.8.0 // indirect
-	github.com/gosuri/uitable v0.0.4 // indirect
-	github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/huandu/xstrings v1.4.0 // indirect
 	github.com/imdario/mergo v0.3.15 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jmoiron/sqlx v1.3.5 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.16.0 // indirect
-	github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 // indirect
-	github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 // indirect
-	github.com/lib/pq v1.10.7 // indirect
-	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/masahiro331/go-xfs-filesystem v0.0.0-20221225060805-c02764233454 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.18 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
-	github.com/mitchellh/copystructure v1.2.0 // indirect
-	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/mitchellh/reflectwalk v1.0.2 // indirect
-	github.com/moby/locker v1.0.1 // indirect
-	github.com/moby/spdystream v0.2.0 // indirect
-	github.com/moby/term v0.0.0-20221205130635-1aeaba878587 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.0-rc2.0.20221020182949-4df8887994e8 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.7 // indirect
-	github.com/peterbourgon/diskv v2.0.1+incompatible // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_golang v1.14.0 // indirect
-	github.com/prometheus/client_model v0.3.0 // indirect
-	github.com/prometheus/common v0.37.0 // indirect
-	github.com/prometheus/procfs v0.8.0 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
-	github.com/rubenv/sql-migrate v1.3.1 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/samber/lo v1.37.0 // indirect
-	github.com/shopspring/decimal v1.3.1 // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
-	github.com/spdx/tools-golang v0.5.0 // indirect
 	github.com/spf13/afero v1.9.5 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.2 // indirect
-	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
-	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
-	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
-	github.com/xlab/treeprint v1.1.0 // indirect
-	go.starlark.net v0.0.0-20221020143700-22309ac47eac // indirect
-	go.uber.org/atomic v1.10.0 // indirect
-	go.uber.org/multierr v1.10.0 // indirect
-	go.uber.org/zap v1.24.0 // indirect
-	golang.org/x/crypto v0.5.0 // indirect
-	golang.org/x/exp v0.0.0-20221109205753-fc8884afc316 // indirect
 	golang.org/x/net v0.8.0 // indirect
 	golang.org/x/oauth2 v0.6.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/sys v0.6.0 // indirect
 	golang.org/x/text v0.8.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
-	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2 // indirect
-	google.golang.org/grpc v1.53.0 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	k8s.io/apiextensions-apiserver v0.26.3 // indirect
-	k8s.io/apiserver v0.26.3 // indirect
-	k8s.io/cli-runtime v0.26.3 // indirect
-	k8s.io/component-base v0.26.3 // indirect
 	k8s.io/klog/v2 v2.90.1 // indirect
 	k8s.io/kube-openapi v0.0.0-20230327201221-f5883ff37f0c // indirect
 	k8s.io/utils v0.0.0-20230313181309-38a27ef9d749 // indirect
-	oras.land/oras-go v1.2.2 // indirect
 	sigs.k8s.io/json v0.0.0-20221116044647-bc3834ca7abd // indirect
-	sigs.k8s.io/kustomize/api v0.12.1 // indirect
-	sigs.k8s.io/kustomize/kyaml v0.13.9 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.3 // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
 )
-
-// v1.2.0 is taken from github.com/open-policy-agent/opa v0.42.0
-// v1.2.0 incompatible with github.com/docker/docker v23.0.0-rc.1+incompatible
-replace oras.land/oras-go => oras.land/oras-go v1.1.1
-
-// v0.3.1-0.20230104082527-d6f58551be3f is taken from github.com/moby/buildkit v0.11.0
-// spdx logic write on v0.3.0 and incompatible with v0.3.1-0.20230104082527-d6f58551be3f
-replace github.com/spdx/tools-golang => github.com/spdx/tools-golang v0.3.0
--- a/go.sum
+++ b/go.sum
--- a/pkg/ai/openai.go
+++ b/pkg/ai/openai.go
@@ -2,13 +2,8 @@ package ai

 import (
 	"context"
-	"encoding/base64"
 	"errors"
 	"fmt"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/spf13/viper"

 	"github.com/sashabaranov/go-openai"
 )
@@ -23,24 +18,22 @@ const (
 type OpenAIClient struct {
 	client   *openai.Client
 	language string
-	model    string
 }

-func (c *OpenAIClient) Configure(token string, model string, language string) error {
+func (c *OpenAIClient) Configure(token string, language string) error {
 	client := openai.NewClient(token)
 	if client == nil {
 		return errors.New("error creating OpenAI client")
 	}
 	c.language = language
 	c.client = client
-	c.model = model
 	return nil
 }

 func (c *OpenAIClient) GetCompletion(ctx context.Context, prompt string) (string, error) {
 	// Create a completion request
 	resp, err := c.client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
-		Model: c.model,
+		Model: openai.GPT3Dot5Turbo,
 		Messages: []openai.ChatCompletionMessage{
 			{
 				Role:    "user",
@@ -53,42 +46,3 @@ func (c *OpenAIClient) GetCompletion(ctx context.Context, prompt string) (string
 	}
 	return resp.Choices[0].Message.Content, nil
 }
-
-func (a *OpenAIClient) Parse(ctx context.Context, prompt []string, nocache bool) (string, error) {
-	inputKey := strings.Join(prompt, " ")
-	// Check for cached data
-	sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
-	// find in viper cache
-	if viper.IsSet(sEnc) && !nocache {
-		// retrieve data from cache
-		response := viper.GetString(sEnc)
-		if response == "" {
-			color.Red("error retrieving cached data")
-			return "", nil
-		}
-		output, err := base64.StdEncoding.DecodeString(response)
-		if err != nil {
-			color.Red("error decoding cached data: %v", err)
-			return "", nil
-		}
-		return string(output), nil
-	}
-
-	response, err := a.GetCompletion(ctx, inputKey)
-	if err != nil {
-		return "", err
-	}
-
-	if !viper.IsSet(sEnc) {
-		viper.Set(sEnc, base64.StdEncoding.EncodeToString([]byte(response)))
-		if err := viper.WriteConfig(); err != nil {
-			color.Red("error writing config: %v", err)
-			return "", nil
-		}
-	}
-	return response, nil
-}
-
-func (a *OpenAIClient) GetName() string {
-	return "openai"
-}
--- a/pkg/ai/iai.go
+++ b/pkg/ai/iai.go
@@ -1,33 +1,8 @@
 package ai

-import (
-	"context"
-)
+import "context"

 type IAI interface {
-	Configure(token string, model string, language string) error
+	Configure(token string, language string) error
 	GetCompletion(ctx context.Context, prompt string) (string, error)
-	Parse(ctx context.Context, prompt []string, nocache bool) (string, error)
-	GetName() string
-}
-
-func NewClient(provider string) IAI {
-	switch provider {
-	case "openai":
-		return &OpenAIClient{}
-	case "noopai":
-		return &NoOpAIClient{}
-	default:
-		return &OpenAIClient{}
-	}
-}
-
-type AIConfiguration struct {
-	Providers []AIProvider `mapstructure:"providers"`
-}
-
-type AIProvider struct {
-	Name     string `mapstructure:"name"`
-	Model    string `mapstructure:"model"`
-	Password string `mapstructure:"password"`
 }
--- a/pkg/ai/noopai.go
+++ b/pkg/ai/noopai.go
@@ -1,55 +0,0 @@
-package ai
-
-import (
-	"context"
-	"encoding/base64"
-	"fmt"
-	"github.com/fatih/color"
-	"github.com/spf13/viper"
-	"strings"
-)
-
-type NoOpAIClient struct {
-	client   string
-	language string
-	model    string
-}
-
-func (c *NoOpAIClient) Configure(token string, model string, language string) error {
-	c.language = language
-	c.client = fmt.Sprintf("I am a noop client with the token %s ", token)
-	c.model = model
-	return nil
-}
-
-func (c *NoOpAIClient) GetCompletion(ctx context.Context, prompt string) (string, error) {
-	// Create a completion request
-	response := "I am a noop response to the prompt " + prompt
-	return response, nil
-}
-
-func (a *NoOpAIClient) Parse(ctx context.Context, prompt []string, nocache bool) (string, error) {
-	// parse the text with the AI backend
-	inputKey := strings.Join(prompt, " ")
-	// Check for cached data
-	sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
-
-	response, err := a.GetCompletion(ctx, inputKey)
-	if err != nil {
-		color.Red("error getting completion: %v", err)
-		return "", err
-	}
-
-	if !viper.IsSet(sEnc) {
-		viper.Set(sEnc, base64.StdEncoding.EncodeToString([]byte(response)))
-		if err := viper.WriteConfig(); err != nil {
-			color.Red("error writing config: %v", err)
-			return "", nil
-		}
-	}
-	return response, nil
-}
-
-func (a *NoOpAIClient) GetName() string {
-	return "noopai"
-}
--- a/pkg/analysis/analysis.go
+++ b/pkg/analysis/analysis.go
@@ -2,66 +2,39 @@ package analysis

 import (
 	"context"
-	"encoding/json"
-	"errors"
 	"fmt"
-	"strings"
-
-	"github.com/fatih/color"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	"github.com/schollz/progressbar/v3"
 	"github.com/spf13/viper"
 )

 type Analysis struct {
-	Context   context.Context
-	Filters   []string
-	Client    *kubernetes.Client
-	AIClient  ai.IAI
-	Results   []common.Result
-	Namespace string
-	NoCache   bool
-	Explain   bool
-}
-
-type AnalysisStatus string
-
-const (
-	StateOK              AnalysisStatus = "OK"
-	StateProblemDetected AnalysisStatus = "ProblemDetected"
-)
-
-type JsonOutput struct {
-	Status   AnalysisStatus  `json:"status"`
-	Problems int             `json:"problems"`
-	Results  []common.Result `json:"results"`
+	Context         context.Context
+	Namespace       string
+	NoCache         bool
+	Explain         bool
+	AIClient        ai.IAI
+	Filters         []string
+	Client          *kubernetes.Client
+	analysisResults []common.Result
 }

 func (a *Analysis) RunAnalysis() error {

 	activeFilters := viper.GetStringSlice("active_filters")
-
-	analyzerMap := analyzer.GetAnalyzerMap()
-
-	analyzerConfig := common.Analyzer{
-		Client:    a.Client,
-		Context:   a.Context,
-		Namespace: a.Namespace,
-		AIClient:  a.AIClient,
-	}
+	analyzerList := analyzer.GetAnalyzerList()

 	// if there are no filters selected and no active_filters then run all of them
 	if len(a.Filters) == 0 && len(activeFilters) == 0 {
-		for _, analyzer := range analyzerMap {
-			results, err := analyzer.Analyze(analyzerConfig)
+		for _, al := range analyzerList {
+			thisanalysis, _ := analyzer.NewAnalyzer(al, a.Client, a.Context, a.Namespace)
+			err := thisanalysis.Analyze()
 			if err != nil {
-				return err
+				fmt.Println("Error running analysis: ", err)
 			}
-			a.Results = append(a.Results, results...)
+			a.analysisResults = append(a.analysisResults, thisanalysis.GetResult()...)
 		}
 		return nil
 	}
@@ -69,121 +42,24 @@ func (a *Analysis) RunAnalysis() error {
 	// if the filters flag is specified
 	if len(a.Filters) != 0 {
 		for _, filter := range a.Filters {
-			if analyzer, ok := analyzerMap[filter]; ok {
-				results, err := analyzer.Analyze(analyzerConfig)
-				if err != nil {
-					return err
+			for _, ali := range analyzerList {
+				if filter == ali {
+					thisanalysis, _ := analyzer.NewAnalyzer(ali, a.Client, a.Context, a.Namespace)
+					err := thisanalysis.Analyze()
+					if err != nil {
+						fmt.Println("Error running analysis: ", err)
+					}
+					a.analysisResults = append(a.analysisResults, thisanalysis.GetResult()...)
 				}
-				a.Results = append(a.Results, results...)
-			} else {
-				return errors.New(fmt.Sprintf("\"%s\" filter does not exist. Please run k8sgpt filters list.", filter))
 			}
 		}
 		return nil
 	}
-
-	// use active_filters
-	for _, filter := range activeFilters {
-		if analyzer, ok := analyzerMap[filter]; ok {
-			results, err := analyzer.Analyze(analyzerConfig)
-			if err != nil {
-				return err
-			}
-			a.Results = append(a.Results, results...)
-		}
-	}
 	return nil
 }

-func (a *Analysis) JsonOutput() ([]byte, error) {
-	var problems int
-	var status AnalysisStatus
-	for _, result := range a.Results {
-		problems += len(result.Error)
-	}
-	if problems > 0 {
-		status = StateProblemDetected
-	} else {
-		status = StateOK
-	}
-
-	result := JsonOutput{
-		Problems: problems,
-		Results:  a.Results,
-		Status:   status,
-	}
-	output, err := json.MarshalIndent(result, "", "  ")
-	if err != nil {
-		return nil, fmt.Errorf("error marshalling json: %v", err)
-	}
-	return output, nil
-}
-
-func (a *Analysis) PrintOutput() {
-	fmt.Println("")
-	if len(a.Results) == 0 {
-		fmt.Println(color.GreenString("No problems detected"))
-	}
-	for n, result := range a.Results {
-		fmt.Printf("%s %s(%s)\n", color.CyanString("%d", n),
-			color.YellowString(result.Name), color.CyanString(result.ParentObject))
-		for _, err := range result.Error {
-			fmt.Printf("- %s %s\n", color.RedString("Error:"), color.RedString(err.Text))
-		}
-		fmt.Println(color.GreenString(result.Details + "\n"))
+func (a *Analysis) PrintAnalysisResult() {
+	for _, result := range a.analysisResults {
+		fmt.Println(result)
 	}
 }
-
-func (a *Analysis) GetAIResults(output string, anonymize bool) error {
-	if len(a.Results) == 0 {
-		return nil
-	}
-
-	var bar *progressbar.ProgressBar
-	if output != "json" {
-		bar = progressbar.Default(int64(len(a.Results)))
-	}
-
-	for index, analysis := range a.Results {
-		var texts []string
-
-		for _, failure := range analysis.Error {
-			if anonymize {
-				for _, s := range failure.Sensitive {
-					failure.Text = util.ReplaceIfMatch(failure.Text, s.Unmasked, s.Masked)
-				}
-			}
-			texts = append(texts, failure.Text)
-		}
-		parsedText, err := a.AIClient.Parse(a.Context, texts, a.NoCache)
-		if err != nil {
-			// FIXME: can we avoid checking if output is json multiple times?
-			//   maybe implement the progress bar better?
-			if output != "json" {
-				bar.Exit()
-			}
-
-			// Check for exhaustion
-			if strings.Contains(err.Error(), "status code: 429") {
-				return fmt.Errorf("exhausted API quota for AI provider %s: %v", a.AIClient.GetName(), err)
-			} else {
-				return fmt.Errorf("failed while calling AI provider %s: %v", a.AIClient.GetName(), err)
-			}
-		}
-
-		if anonymize {
-			for _, failure := range analysis.Error {
-				for _, s := range failure.Sensitive {
-					parsedText = strings.ReplaceAll(parsedText, s.Masked, s.Unmasked)
-				}
-			}
-		}
-
-		analysis.Details = parsedText
-		if output != "json" {
-			bar.Add(1)
-		}
-		a.Results[index] = analysis
-	}
-	return nil
-}
--- a/pkg/analysis/analysis_test.go
+++ b/pkg/analysis/analysis_test.go
@@ -1,154 +0,0 @@
-package analysis
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/stretchr/testify/require"
-)
-
-func TestAnalysis_NoProblemJsonOutput(t *testing.T) {
-
-	analysis := Analysis{
-		Results:   []common.Result{},
-		Namespace: "default",
-	}
-
-	expected := JsonOutput{
-		Status:   StateOK,
-		Problems: 0,
-		Results:  []common.Result{},
-	}
-
-	gotJson, err := analysis.JsonOutput()
-	if err != nil {
-		t.Error(err)
-	}
-
-	got := JsonOutput{}
-	err = json.Unmarshal(gotJson, &got)
-	if err != nil {
-		t.Error(err)
-	}
-
-	fmt.Println(got)
-	fmt.Println(expected)
-
-	require.Equal(t, got, expected)
-}
-
-func TestAnalysis_ProblemJsonOutput(t *testing.T) {
-	analysis := Analysis{
-		Results: []common.Result{
-			{
-				Kind: "Deployment",
-				Name: "test-deployment",
-				Error: []common.Failure{
-					{
-						Text:      "test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-				},
-				Details:      "test-solution",
-				ParentObject: "parent-resource"},
-		},
-		Namespace: "default",
-	}
-
-	expected := JsonOutput{
-		Status:   StateProblemDetected,
-		Problems: 1,
-		Results: []common.Result{
-			{
-				Kind: "Deployment",
-				Name: "test-deployment",
-				Error: []common.Failure{
-					{
-						Text:      "test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-				},
-				Details:      "test-solution",
-				ParentObject: "parent-resource"},
-		},
-	}
-
-	gotJson, err := analysis.JsonOutput()
-	if err != nil {
-		t.Error(err)
-	}
-
-	got := JsonOutput{}
-	err = json.Unmarshal(gotJson, &got)
-	if err != nil {
-		t.Error(err)
-	}
-
-	fmt.Println(got)
-	fmt.Println(expected)
-
-	require.Equal(t, got, expected)
-}
-
-func TestAnalysis_MultipleProblemJsonOutput(t *testing.T) {
-	analysis := Analysis{
-		Results: []common.Result{
-			{
-				Kind: "Deployment",
-				Name: "test-deployment",
-				Error: []common.Failure{
-					{
-						Text:      "test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-					{
-						Text:      "another-test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-				},
-				Details:      "test-solution",
-				ParentObject: "parent-resource"},
-		},
-		Namespace: "default",
-	}
-
-	expected := JsonOutput{
-		Status:   StateProblemDetected,
-		Problems: 2,
-		Results: []common.Result{
-			{
-				Kind: "Deployment",
-				Name: "test-deployment",
-				Error: []common.Failure{
-					{
-						Text:      "test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-					{
-						Text:      "another-test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-				},
-				Details:      "test-solution",
-				ParentObject: "parent-resource"},
-		},
-	}
-
-	gotJson, err := analysis.JsonOutput()
-	if err != nil {
-		t.Error(err)
-	}
-
-	got := JsonOutput{}
-	err = json.Unmarshal(gotJson, &got)
-	if err != nil {
-		t.Error(err)
-	}
-
-	fmt.Println(got)
-	fmt.Println(expected)
-
-	require.Equal(t, got, expected)
-}
--- a/pkg/analyzer/analyzer.go
+++ b/pkg/analyzer/analyzer.go
@@ -1,88 +1,158 @@
 package analyzer

 import (
+	"context"
 	"fmt"
-	"os"
-
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/hpa"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/ingress"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/pod"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/pvc"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/rs"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/service"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 )

-var coreAnalyzerMap = map[string]common.IAnalyzer{
-	"Pod":                   PodAnalyzer{},
-	"ReplicaSet":            ReplicaSetAnalyzer{},
-	"PersistentVolumeClaim": PvcAnalyzer{},
-	"Service":               ServiceAnalyzer{},
-	"Ingress":               IngressAnalyzer{},
-	"StatefulSet":           StatefulSetAnalyzer{},
+type IAnalyzer interface {
+	Analyze() error
+	GetResult() []common.Result
 }

-var additionalAnalyzerMap = map[string]common.IAnalyzer{
-	"HorizontalPodAutoScaler": HpaAnalyzer{},
-	"PodDisruptionBudget":     PdbAnalyzer{},
+const (
+	PodAnalyzerName                   = "Pod"
+	ReplicaSetAnalyzerName            = "ReplicaSet"
+	PersistentVolumeClaimAnalyzerName = "PersistentVolumeClaim"
+	ServiceAnalyzerName               = "Service"
+	IngressAnalyzerName               = "Ingress"
+	HPAAnalyzerName                   = "HorizontalPodAutoScaler"
+)
+
+var (
+	coreAnalyzerList = []string{
+		PodAnalyzerName,
+		ReplicaSetAnalyzerName,
+		PersistentVolumeClaimAnalyzerName,
+		ServiceAnalyzerName,
+		IngressAnalyzerName,
+		HPAAnalyzerName,
+	}
+
+	additionalAnalyzers = []string{
+		HPAAnalyzerName,
+	}
+)
+
+func NewAnalyzer(analyzer string, client *kubernetes.Client, context context.Context, namespace string) (IAnalyzer, error) {
+	analyzerConfig := common.Analyzer{
+		Namespace: namespace,
+		Context:   context,
+		Client:    client,
+	}
+
+	analyzerConfig.PreAnalysis = make(map[string]common.PreAnalysis)
+
+	switch analyzer {
+	case PodAnalyzerName:
+		return &pod.PodAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	case ReplicaSetAnalyzerName:
+		return &rs.ReplicaSetAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	case IngressAnalyzerName:
+		return &ingress.IngressAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	case HPAAnalyzerName:
+		return &hpa.HPAAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	case PersistentVolumeClaimAnalyzerName:
+		return &pvc.PvcAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	case ServiceAnalyzerName:
+		return &service.ServiceAnalyzer{
+			Analyzer: analyzerConfig,
+		}, nil
+	default:
+		return nil, fmt.Errorf("Analyzer %s not supported", analyzer)
+	}
 }

-func ListFilters() ([]string, []string, []string) {
-	coreKeys := make([]string, 0, len(coreAnalyzerMap))
-	for k := range coreAnalyzerMap {
-		coreKeys = append(coreKeys, k)
-	}
+/*
+func ParseViaAI(ctx context.Context, config *analysis.Analysis,

-	additionalKeys := make([]string, 0, len(additionalAnalyzerMap))
-	for k := range additionalAnalyzerMap {
-		additionalKeys = append(additionalKeys, k)
-	}
-
-	integrationProvider := integration.NewIntegration()
-	var integrationAnalyzers []string
-
-	for _, i := range integrationProvider.List() {
-		b, _ := integrationProvider.IsActivate(i)
-		if b {
-			in, err := integrationProvider.Get(i)
-			if err != nil {
-				fmt.Println(color.RedString(err.Error()))
-				os.Exit(1)
+		aiClient ai.IAI, prompt []string) (string, error) {
+		// parse the text with the AI backend
+		inputKey := strings.Join(prompt, " ")
+		// Check for cached data
+		sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
+		// find in viper cache
+		if viper.IsSet(sEnc) && !config.NoCache {
+			// retrieve data from cache
+			response := viper.GetString(sEnc)
+			if response == "" {
+				color.Red("error retrieving cached data")
+				return "", nil
 			}
-			integrationAnalyzers = append(integrationAnalyzers, in.GetAnalyzerName())
+			output, err := base64.StdEncoding.DecodeString(response)
+			if err != nil {
+				color.Red("error decoding cached data: %v", err)
+				return "", nil
+			}
+			return string(output), nil
 		}
-	}

-	return coreKeys, additionalKeys, integrationAnalyzers
-}
-
-func GetAnalyzerMap() map[string]common.IAnalyzer {
-
-	mergedMap := make(map[string]common.IAnalyzer)
-
-	// add core analyzer
-	for key, value := range coreAnalyzerMap {
-		mergedMap[key] = value
-	}
-
-	// add additional analyzer
-	for key, value := range additionalAnalyzerMap {
-		mergedMap[key] = value
-	}
-
-	integrationProvider := integration.NewIntegration()
-
-	for _, i := range integrationProvider.List() {
-		b, err := integrationProvider.IsActivate(i)
+		response, err := aiClient.GetCompletion(ctx, inputKey)
 		if err != nil {
-			fmt.Println(color.RedString(err.Error()))
-			os.Exit(1)
+			color.Red("error getting completion: %v", err)
+			return "", err
 		}
-		if b {
-			in, err := integrationProvider.Get(i)
-			if err != nil {
-				fmt.Println(color.RedString(err.Error()))
-				os.Exit(1)
+
+		if !viper.IsSet(sEnc) {
+			viper.Set(sEnc, base64.StdEncoding.EncodeToString([]byte(response)))
+			if err := viper.WriteConfig(); err != nil {
+				color.Red("error writing config: %v", err)
+				return "", nil
 			}
-			in.AddAnalyzer(&mergedMap)
 		}
+		return response, nil
+	}
+*/
+func ListFilters() ([]string, []string) {
+	coreKeys := []string{}
+	for _, filter := range coreAnalyzerList {
+		coreKeys = append(coreKeys, filter)
 	}

-	return mergedMap
+	additionalKeys := []string{}
+	for _, filter := range additionalAnalyzers {
+		coreKeys = append(additionalKeys, filter)
+	}
+	return coreKeys, additionalKeys
+}
+
+func GetAnalyzerList() []string {
+	list := []string{}
+
+	list = append(list, coreAnalyzerList...)
+	list = append(list, additionalAnalyzers...)
+
+	list = removeDuplicateStr(list)
+
+	return list
+}
+
+func removeDuplicateStr(strSlice []string) []string {
+	allKeys := make(map[string]bool)
+	list := []string{}
+	for _, item := range strSlice {
+		if _, value := allKeys[item]; !value {
+			allKeys[item] = true
+			list = append(list, item)
+		}
+	}
+	return list
 }
--- a/pkg/analyzer/common/events.go
+++ b/pkg/analyzer/common/events.go
@@ -0,0 +1,57 @@
+package common
+
+import (
+	"context"
+
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func FetchLatestPodEvent(ctx context.Context, kubernetesClient *kubernetes.Client, pod *v1.Pod) (*v1.Event, error) {
+
+	// get the list of events
+	events, err := kubernetesClient.GetClient().CoreV1().Events(pod.Namespace).List(ctx,
+		metav1.ListOptions{
+			FieldSelector: "involvedObject.name=" + pod.Name,
+		})
+
+	if err != nil {
+		return nil, err
+	}
+	// find most recent event
+	var latestEvent *v1.Event
+	for _, event := range events.Items {
+		if latestEvent == nil {
+			latestEvent = &event
+		}
+		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
+			latestEvent = &event
+		}
+	}
+	return latestEvent, nil
+}
+
+func FetchLatestPvcEvent(ctx context.Context, kubernetesClient *kubernetes.Client, pvc *v1.PersistentVolumeClaim) (*v1.Event, error) {
+
+	// get the list of events
+	events, err := kubernetesClient.GetClient().CoreV1().Events(pvc.Namespace).List(ctx,
+		metav1.ListOptions{
+			FieldSelector: "involvedObject.name=" + pvc.Name,
+		})
+
+	if err != nil {
+		return nil, err
+	}
+	// find most recent event
+	var latestEvent *v1.Event
+	for _, event := range events.Items {
+		if latestEvent == nil {
+			latestEvent = &event
+		}
+		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
+			latestEvent = &event
+		}
+	}
+	return latestEvent, nil
+}
--- a/pkg/analyzer/common/types.go
+++ b/pkg/analyzer/common/types.go
@@ -0,0 +1,36 @@
+package common
+
+import (
+	"context"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
+	appsv1 "k8s.io/api/apps/v1"
+	autov1 "k8s.io/api/autoscaling/v1"
+	v1 "k8s.io/api/core/v1"
+	networkv1 "k8s.io/api/networking/v1"
+)
+
+type Analyzer struct {
+	Client      *kubernetes.Client
+	Context     context.Context
+	Namespace   string
+	PreAnalysis map[string]PreAnalysis
+	Result      []Result
+}
+
+type Result struct {
+	Kind         string   `json:"kind"`
+	Name         string   `json:"name"`
+	Error        []string `json:"error"`
+	Details      string   `json:"details"`
+	ParentObject string   `json:"parentObject"`
+}
+
+type PreAnalysis struct {
+	Pod                      v1.Pod
+	FailureDetails           []string
+	ReplicaSet               appsv1.ReplicaSet
+	PersistentVolumeClaim    v1.PersistentVolumeClaim
+	Endpoint                 v1.Endpoints
+	Ingress                  networkv1.Ingress
+	HorizontalPodAutoscalers autov1.HorizontalPodAutoscaler
+}
--- a/pkg/analyzer/events.go
+++ b/pkg/analyzer/events.go
@@ -1,33 +0,0 @@
-package analyzer
-
-import (
-	"context"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func FetchLatestEvent(ctx context.Context, kubernetesClient *kubernetes.Client, namespace string, name string) (*v1.Event, error) {
-
-	// get the list of events
-	events, err := kubernetesClient.GetClient().CoreV1().Events(namespace).List(ctx,
-		metav1.ListOptions{
-			FieldSelector: "involvedObject.name=" + name,
-		})
-
-	if err != nil {
-		return nil, err
-	}
-	// find most recent event
-	var latestEvent *v1.Event
-	for _, event := range events.Items {
-		if latestEvent == nil {
-			latestEvent = &event
-		}
-		if event.LastTimestamp.After(latestEvent.LastTimestamp.Time) {
-			latestEvent = &event
-		}
-	}
-	return latestEvent, nil
-}
--- a/pkg/analyzer/hpa.go
+++ b/pkg/analyzer/hpa.go
@@ -1,91 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type HpaAnalyzer struct{}
-
-func (HpaAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	list, err := a.Client.GetClient().AutoscalingV1().HorizontalPodAutoscalers(a.Namespace).List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, hpa := range list.Items {
-		var failures []common.Failure
-
-		// check ScaleTargetRef exist
-		scaleTargetRef := hpa.Spec.ScaleTargetRef
-		scaleTargetRefNotFound := false
-
-		switch scaleTargetRef.Kind {
-		case "Deployment":
-			_, err := a.Client.GetClient().AppsV1().Deployments(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
-			if err != nil {
-				scaleTargetRefNotFound = true
-			}
-		case "ReplicationController":
-			_, err := a.Client.GetClient().CoreV1().ReplicationControllers(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
-			if err != nil {
-				scaleTargetRefNotFound = true
-			}
-		case "ReplicaSet":
-			_, err := a.Client.GetClient().AppsV1().ReplicaSets(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
-			if err != nil {
-				scaleTargetRefNotFound = true
-			}
-		case "StatefulSet":
-			_, err := a.Client.GetClient().AppsV1().StatefulSets(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
-			if err != nil {
-				scaleTargetRefNotFound = true
-			}
-		default:
-			failures = append(failures, common.Failure{
-				Text:      fmt.Sprintf("HorizontalPodAutoscaler uses %s as ScaleTargetRef which is not an option.", scaleTargetRef.Kind),
-				Sensitive: []common.Sensitive{},
-			})
-		}
-
-		if scaleTargetRefNotFound {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("HorizontalPodAutoscaler uses %s/%s as ScaleTargetRef which does not exist.", scaleTargetRef.Kind, scaleTargetRef.Name),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: scaleTargetRef.Name,
-						Masked:   util.MaskString(scaleTargetRef.Name),
-					},
-				},
-			})
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = common.PreAnalysis{
-				HorizontalPodAutoscalers: hpa,
-				FailureDetails:           failures,
-			}
-		}
-
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  "HorizontalPodAutoscaler",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.HorizontalPodAutoscalers.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/analyzer/hpa/hpaAnalyzer.go
+++ b/pkg/analyzer/hpa/hpaAnalyzer.go
@@ -0,0 +1,81 @@
+package hpa
+
+import (
+	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type HPAAnalyzer struct {
+	common.Analyzer
+}
+
+func (a *HPAAnalyzer) Analyze() error {
+	list, err := a.Client.GetClient().AutoscalingV1().HorizontalPodAutoscalers(a.Namespace).List(a.Context, metav1.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	for _, hpa := range list.Items {
+		var failures []string
+
+		// check ScaleTargetRef exist
+		scaleTargetRef := hpa.Spec.ScaleTargetRef
+		scaleTargetRefNotFound := false
+
+		switch scaleTargetRef.Kind {
+		case "Deployment":
+			_, err := a.Client.GetClient().AppsV1().Deployments(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			if err != nil {
+				scaleTargetRefNotFound = true
+			}
+		case "ReplicationController":
+			_, err := a.Client.GetClient().CoreV1().ReplicationControllers(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			if err != nil {
+				scaleTargetRefNotFound = true
+			}
+		case "ReplicaSet":
+			_, err := a.Client.GetClient().AppsV1().ReplicaSets(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			if err != nil {
+				scaleTargetRefNotFound = true
+			}
+		case "StatefulSet":
+			_, err := a.Client.GetClient().AppsV1().StatefulSets(a.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			if err != nil {
+				scaleTargetRefNotFound = true
+			}
+		default:
+			failures = append(failures, fmt.Sprintf("HorizontalPodAutoscaler uses %s as ScaleTargetRef which does not possible option.", scaleTargetRef.Kind))
+		}
+
+		if scaleTargetRefNotFound {
+			failures = append(failures, fmt.Sprintf("HorizontalPodAutoscaler uses %s/%s as ScaleTargetRef which does not exist.", scaleTargetRef.Kind, scaleTargetRef.Name))
+		}
+
+		if len(failures) > 0 {
+			a.PreAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = common.PreAnalysis{
+				HorizontalPodAutoscalers: hpa,
+				FailureDetails:           failures,
+			}
+		}
+
+	}
+
+	for key, value := range a.PreAnalysis {
+		var currentAnalysis = common.Result{
+			Kind:  "HorizontalPodAutoscaler",
+			Name:  key,
+			Error: value.FailureDetails,
+		}
+
+		parent, _ := util.GetParent(a.Client, value.Ingress.ObjectMeta)
+		currentAnalysis.ParentObject = parent
+		a.Result = append(a.Result, currentAnalysis)
+	}
+	return nil
+}
+
+func (a *HPAAnalyzer) GetResult() []common.Result {
+	return a.Result
+}
--- a/pkg/analyzer/hpaAnalyzer_test.go
+++ b/pkg/analyzer/hpaAnalyzer_test.go
@@ -1,206 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	appsv1 "k8s.io/api/apps/v1"
-	autoscalingv1 "k8s.io/api/autoscaling/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestHPAAnalyzer(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		})
-	hpaAnalyzer := HpaAnalyzer{}
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := hpaAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
-
-func TestHPAAnalyzerWithMultipleHPA(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		},
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example-2",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		},
-	)
-	hpaAnalyzer := HpaAnalyzer{}
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := hpaAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 2)
-}
-
-func TestHPAAnalyzerWithUnsuportedScaleTargetRef(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-			Spec: autoscalingv1.HorizontalPodAutoscalerSpec{
-				ScaleTargetRef: autoscalingv1.CrossVersionObjectReference{
-					Kind: "unsupported",
-				},
-			},
-		})
-	hpaAnalyzer := HpaAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := hpaAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	var errorFound bool
-	for _, analysis := range analysisResults {
-		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "which is not an option.") {
-				errorFound = true
-				break
-			}
-		}
-		if errorFound {
-			break
-		}
-	}
-	if !errorFound {
-		t.Error("expected error 'does not possible option.' not found in analysis results")
-	}
-}
-
-func TestHPAAnalyzerWithNonExistentScaleTargetRef(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-			Spec: autoscalingv1.HorizontalPodAutoscalerSpec{
-				ScaleTargetRef: autoscalingv1.CrossVersionObjectReference{
-					Kind: "Deployment",
-					Name: "non-existent",
-				},
-			},
-		})
-	hpaAnalyzer := HpaAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := hpaAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	var errorFound bool
-	for _, analysis := range analysisResults {
-		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "does not exist.") {
-				errorFound = true
-				break
-			}
-		}
-		if errorFound {
-			break
-		}
-	}
-	if !errorFound {
-		t.Error("expected error 'does not exist.' not found in analysis results")
-	}
-}
-
-func TestHPAAnalyzerWithExistingScaleTargetRef(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(
-		&autoscalingv1.HorizontalPodAutoscaler{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-			Spec: autoscalingv1.HorizontalPodAutoscalerSpec{
-				ScaleTargetRef: autoscalingv1.CrossVersionObjectReference{
-					Kind: "Deployment",
-					Name: "example",
-				},
-			},
-		},
-		&appsv1.Deployment{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		},
-	)
-	hpaAnalyzer := HpaAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := hpaAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	for _, analysis := range analysisResults {
-		assert.Equal(t, len(analysis.Error), 0)
-	}
-}
--- a/pkg/analyzer/ingress.go
+++ b/pkg/analyzer/ingress.go
@@ -1,127 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type IngressAnalyzer struct{}
-
-func (IngressAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	list, err := a.Client.GetClient().NetworkingV1().Ingresses(a.Namespace).List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, ing := range list.Items {
-		var failures []common.Failure
-
-		// get ingressClassName
-		ingressClassName := ing.Spec.IngressClassName
-		if ingressClassName == nil {
-			ingClassValue := ing.Annotations["kubernetes.io/ingress.class"]
-			if ingClassValue == "" {
-				failures = append(failures, common.Failure{
-					Text: fmt.Sprintf("Ingress %s/%s does not specify an Ingress class.", ing.Namespace, ing.Name),
-					Sensitive: []common.Sensitive{
-						{
-							Unmasked: ing.Namespace,
-							Masked:   util.MaskString(ing.Namespace),
-						},
-						{
-							Unmasked: ing.Name,
-							Masked:   util.MaskString(ing.Name),
-						},
-					},
-				})
-			} else {
-				ingressClassName = &ingClassValue
-			}
-		}
-
-		// check if ingressclass exist
-		if ingressClassName != nil {
-			_, err := a.Client.GetClient().NetworkingV1().IngressClasses().Get(a.Context, *ingressClassName, metav1.GetOptions{})
-			if err != nil {
-				failures = append(failures, common.Failure{
-					Text: fmt.Sprintf("Ingress uses the ingress class %s which does not exist.", *ingressClassName),
-					Sensitive: []common.Sensitive{
-						{
-							Unmasked: *ingressClassName,
-							Masked:   util.MaskString(*ingressClassName),
-						},
-					},
-				})
-			}
-		}
-
-		// loop over rules
-		for _, rule := range ing.Spec.Rules {
-			// loop over paths
-			for _, path := range rule.HTTP.Paths {
-				_, err := a.Client.GetClient().CoreV1().Services(ing.Namespace).Get(a.Context, path.Backend.Service.Name, metav1.GetOptions{})
-				if err != nil {
-					failures = append(failures, common.Failure{
-						Text: fmt.Sprintf("Ingress uses the service %s/%s which does not exist.", ing.Namespace, path.Backend.Service.Name),
-						Sensitive: []common.Sensitive{
-							{
-								Unmasked: ing.Namespace,
-								Masked:   util.MaskString(ing.Namespace),
-							},
-							{
-								Unmasked: path.Backend.Service.Name,
-								Masked:   util.MaskString(path.Backend.Service.Name),
-							},
-						},
-					})
-				}
-			}
-		}
-
-		for _, tls := range ing.Spec.TLS {
-			_, err := a.Client.GetClient().CoreV1().Secrets(ing.Namespace).Get(a.Context, tls.SecretName, metav1.GetOptions{})
-			if err != nil {
-				failures = append(failures, common.Failure{
-					Text: fmt.Sprintf("Ingress uses the secret %s/%s as a TLS certificate which does not exist.", ing.Namespace, tls.SecretName),
-					Sensitive: []common.Sensitive{
-						{
-							Unmasked: ing.Namespace,
-							Masked:   util.MaskString(ing.Namespace),
-						},
-						{
-							Unmasked: tls.SecretName,
-							Masked:   util.MaskString(tls.SecretName),
-						},
-					},
-				})
-			}
-		}
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = common.PreAnalysis{
-				Ingress:        ing,
-				FailureDetails: failures,
-			}
-		}
-
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  "Ingress",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.Ingress.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/analyzer/ingress/ingressAnalyzer.go
+++ b/pkg/analyzer/ingress/ingressAnalyzer.go
@@ -0,0 +1,85 @@
+package ingress
+
+import (
+	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
+
+	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+type IngressAnalyzer struct {
+	common.Analyzer
+}
+
+func (a *IngressAnalyzer) Analyze() error {
+	list, err := a.Client.GetClient().NetworkingV1().Ingresses(a.Namespace).List(a.Context, metav1.ListOptions{})
+	if err != nil {
+		return err
+	}
+
+	for _, ing := range list.Items {
+		var failures []string
+
+		// get ingressClassName
+		ingressClassName := ing.Spec.IngressClassName
+		if ingressClassName == nil {
+			ingClassValue := ing.Annotations["kubernetes.io/ingress.class"]
+			if ingClassValue == "" {
+				failures = append(failures, fmt.Sprintf("Ingress %s/%s does not specify an Ingress class.", ing.Namespace, ing.Name))
+			} else {
+				ingressClassName = &ingClassValue
+			}
+		}
+
+		// check if ingressclass exist
+		if ingressClassName != nil {
+			_, err := a.Client.GetClient().NetworkingV1().IngressClasses().Get(a.Context, *ingressClassName, metav1.GetOptions{})
+			if err != nil {
+				failures = append(failures, fmt.Sprintf("Ingress uses the ingress class %s which does not exist.", *ingressClassName))
+			}
+		}
+
+		// loop over rules
+		for _, rule := range ing.Spec.Rules {
+			// loop over paths
+			for _, path := range rule.HTTP.Paths {
+				_, err := a.Client.GetClient().CoreV1().Services(ing.Namespace).Get(a.Context, path.Backend.Service.Name, metav1.GetOptions{})
+				if err != nil {
+					failures = append(failures, fmt.Sprintf("Ingress uses the service %s/%s which does not exist.", ing.Namespace, path.Backend.Service.Name))
+				}
+			}
+		}
+
+		for _, tls := range ing.Spec.TLS {
+			_, err := a.Client.GetClient().CoreV1().Secrets(ing.Namespace).Get(a.Context, tls.SecretName, metav1.GetOptions{})
+			if err != nil {
+				failures = append(failures, fmt.Sprintf("Ingress uses the secret %s/%s as a TLS certificate which does not exist.", ing.Namespace, tls.SecretName))
+			}
+		}
+		if len(failures) > 0 {
+			a.PreAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = common.PreAnalysis{
+				Ingress:        ing,
+				FailureDetails: failures,
+			}
+		}
+
+	}
+
+	for key, value := range a.PreAnalysis {
+		var currentAnalysis = common.Result{
+			Kind:  "Ingress",
+			Name:  key,
+			Error: value.FailureDetails,
+		}
+
+		parent, _ := util.GetParent(a.Client, value.Ingress.ObjectMeta)
+		currentAnalysis.ParentObject = parent
+		a.Result = append(a.Result, currentAnalysis)
+	}
+	return nil
+}
+
+func (a *IngressAnalyzer) GetResult() []common.Result {
+	return a.Result
+}
--- a/pkg/analyzer/ingress_test.go
+++ b/pkg/analyzer/ingress_test.go
@@ -1,115 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	networkingv1 "k8s.io/api/networking/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestIngressAnalyzer(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&networkingv1.Ingress{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		})
-	ingressAnalyzer := IngressAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := ingressAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
-
-func TestIngressAnalyzerWithMultipleIngresses(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&networkingv1.Ingress{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		},
-		&networkingv1.Ingress{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example-2",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		},
-	)
-	ingressAnalyzer := IngressAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analysisResults, err := ingressAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 2)
-}
-
-func TestIngressAnalyzerWithoutIngressClassAnnotation(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(
-		&networkingv1.Ingress{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-		})
-	ingressAnalyzer := IngressAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analysisResults, err := ingressAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	var errorFound bool
-	for _, analysis := range analysisResults {
-		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "does not specify an Ingress class") {
-				errorFound = true
-				break
-			}
-		}
-		if errorFound {
-			break
-		}
-	}
-	if !errorFound {
-		t.Error("expected error 'does not specify an Ingress class' not found in analysis results")
-	}
-}
--- a/pkg/analyzer/pdb.go
+++ b/pkg/analyzer/pdb.go
@@ -1,82 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type PdbAnalyzer struct{}
-
-func (PdbAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	list, err := a.Client.GetClient().PolicyV1().PodDisruptionBudgets(a.Namespace).List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, pdb := range list.Items {
-		var failures []common.Failure
-
-		evt, err := FetchLatestEvent(a.Context, a.Client, pdb.Namespace, pdb.Name)
-		if err != nil || evt == nil {
-			continue
-		}
-
-		if evt.Reason == "NoPods" && evt.Message != "" {
-			if pdb.Spec.Selector != nil {
-				for k, v := range pdb.Spec.Selector.MatchLabels {
-					failures = append(failures, common.Failure{
-						Text: fmt.Sprintf("%s, expected label %s=%s", evt.Message, k, v),
-						Sensitive: []common.Sensitive{
-							{
-								Unmasked: k,
-								Masked:   util.MaskString(k),
-							},
-							{
-								Unmasked: v,
-								Masked:   util.MaskString(v),
-							},
-						},
-					})
-				}
-				for _, v := range pdb.Spec.Selector.MatchExpressions {
-					failures = append(failures, common.Failure{
-						Text:      fmt.Sprintf("%s, expected expression %s", evt.Message, v),
-						Sensitive: []common.Sensitive{},
-					})
-				}
-			} else {
-				failures = append(failures, common.Failure{
-					Text:      fmt.Sprintf("%s, selector is nil", evt.Message),
-					Sensitive: []common.Sensitive{},
-				})
-			}
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pdb.Namespace, pdb.Name)] = common.PreAnalysis{
-				PodDisruptionBudget: pdb,
-				FailureDetails:      failures,
-			}
-		}
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  "PodDisruptionBudget",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.PodDisruptionBudget.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, err
-}
--- a/pkg/analyzer/pod/podAnalyzer.go
+++ b/pkg/analyzer/pod/podAnalyzer.go
@@ -1,26 +1,24 @@
-package analyzer
+package pod

 import (
 	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

 type PodAnalyzer struct {
+	common.Analyzer ", inline"
 }

-func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
+func (a *PodAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().CoreV1().Pods(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
-		return nil, err
+		return err
 	}
-	var preAnalysis = map[string]common.PreAnalysis{}
-
 	for _, pod := range list.Items {
-		var failures []common.Failure
+		var failures []string
 		// Check for pending pods
 		if pod.Status.Phase == "Pending" {

@@ -28,10 +26,7 @@ func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 			for _, containerStatus := range pod.Status.Conditions {
 				if containerStatus.Type == "PodScheduled" && containerStatus.Reason == "Unschedulable" {
 					if containerStatus.Message != "" {
-						failures = append(failures, common.Failure{
-							Text:      containerStatus.Message,
-							Sensitive: []common.Sensitive{},
-						})
+						failures = []string{containerStatus.Message}
 					}
 				}
 			}
@@ -42,38 +37,32 @@ func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 			if containerStatus.State.Waiting != nil {
 				if containerStatus.State.Waiting.Reason == "CrashLoopBackOff" || containerStatus.State.Waiting.Reason == "ImagePullBackOff" {
 					if containerStatus.State.Waiting.Message != "" {
-						failures = append(failures, common.Failure{
-							Text:      containerStatus.State.Waiting.Message,
-							Sensitive: []common.Sensitive{},
-						})
+						failures = append(failures, containerStatus.State.Waiting.Message)
 					}
 				}
 				// This represents a container that is still being created or blocked due to conditions such as OOMKilled
 				if containerStatus.State.Waiting.Reason == "ContainerCreating" && pod.Status.Phase == "Pending" {

 					// parse the event log and append details
-					evt, err := FetchLatestEvent(a.Context, a.Client, pod.Namespace, pod.Name)
+					evt, err := common.FetchLatestPodEvent(a.Context, a.Client, &pod)
 					if err != nil || evt == nil {
 						continue
 					}
 					if evt.Reason == "FailedCreatePodSandBox" && evt.Message != "" {
-						failures = append(failures, common.Failure{
-							Text:      evt.Message,
-							Sensitive: []common.Sensitive{},
-						})
+						failures = append(failures, evt.Message)
 					}
 				}
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pod.Namespace, pod.Name)] = common.PreAnalysis{
+			a.PreAnalysis[fmt.Sprintf("%s/%s", pod.Namespace, pod.Name)] = common.PreAnalysis{
 				Pod:            pod,
 				FailureDetails: failures,
 			}
 		}
 	}

-	for key, value := range preAnalysis {
+	for key, value := range a.PreAnalysis {
 		var currentAnalysis = common.Result{
 			Kind:  "Pod",
 			Name:  key,
@@ -82,8 +71,11 @@ func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {

 		parent, _ := util.GetParent(a.Client, value.Pod.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
-	return a.Results, nil
+	return nil
+}
+
+func (a *PodAnalyzer) GetResult() []common.Result {
+	return a.Result
 }
--- a/pkg/analyzer/pod_test.go
+++ b/pkg/analyzer/pod_test.go
@@ -1,49 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestPodAnalyzer(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(&v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:        "example",
-			Namespace:   "default",
-			Annotations: map[string]string{},
-		},
-		Status: v1.PodStatus{
-			Phase: v1.PodPending,
-			Conditions: []v1.PodCondition{
-				{
-					Type:    v1.PodScheduled,
-					Reason:  "Unschedulable",
-					Message: "0/1 nodes are available: 1 node(s) had taint {node-role.kubernetes.io/master: }, that the pod didn't tolerate.",
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	podAnalyzer := PodAnalyzer{}
-	var analysisResults []common.Result
-	analysisResults, err := podAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
--- a/pkg/analyzer/pvc/pvcAnalyzer.go
+++ b/pkg/analyzer/pvc/pvcAnalyzer.go
@@ -1,41 +1,39 @@
-package analyzer
+package pvc

 import (
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"

-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

-type PvcAnalyzer struct{}
-
-func (PvcAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
+type PvcAnalyzer struct {
+	common.Analyzer
+}

+func (a *PvcAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().CoreV1().PersistentVolumeClaims(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
-		return nil, err
+		return err
 	}

 	var preAnalysis = map[string]common.PreAnalysis{}

 	for _, pvc := range list.Items {
-		var failures []common.Failure
+		var failures []string

 		// Check for empty rs
 		if pvc.Status.Phase == "Pending" {

 			// parse the event log and append details
-			evt, err := FetchLatestEvent(a.Context, a.Client, pvc.Namespace, pvc.Name)
+			evt, err := common.FetchLatestPvcEvent(a.Context, a.Client, &pvc)
 			if err != nil || evt == nil {
 				continue
 			}
 			if evt.Reason == "ProvisioningFailed" && evt.Message != "" {
-				failures = append(failures, common.Failure{
-					Text:      evt.Message,
-					Sensitive: []common.Sensitive{},
-				})
+				failures = append(failures, evt.Message)
 			}
 		}
 		if len(failures) > 0 {
@@ -55,8 +53,11 @@ func (PvcAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {

 		parent, _ := util.GetParent(a.Client, value.PersistentVolumeClaim.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-
-	return a.Results, nil
+	return nil
+}
+
+func (a *PvcAnalyzer) GetResult() []common.Result {
+	return a.Result
 }
--- a/pkg/analyzer/rs/rsAnalyzer.go
+++ b/pkg/analyzer/rs/rsAnalyzer.go
@@ -1,27 +1,28 @@
-package analyzer
+package rs

 import (
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"

-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

-type ReplicaSetAnalyzer struct{}
-
-func (ReplicaSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
+type ReplicaSetAnalyzer struct {
+	common.Analyzer
+}

+func (a *ReplicaSetAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().AppsV1().ReplicaSets(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
-		return nil, err
+		return err
 	}

 	var preAnalysis = map[string]common.PreAnalysis{}

 	for _, rs := range list.Items {
-		var failures []common.Failure
+		var failures []string

 		// Check for empty rs
 		if rs.Status.Replicas == 0 {
@@ -29,11 +30,7 @@ func (ReplicaSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 			// Check through container status to check for crashes
 			for _, rsStatus := range rs.Status.Conditions {
 				if rsStatus.Type == "ReplicaFailure" && rsStatus.Reason == "FailedCreate" {
-					failures = append(failures, common.Failure{
-						Text:      rsStatus.Message,
-						Sensitive: []common.Sensitive{},
-					})
-
+					failures = []string{rsStatus.Message}
 				}
 			}
 		}
@@ -54,7 +51,11 @@ func (ReplicaSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {

 		parent, _ := util.GetParent(a.Client, value.ReplicaSet.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-	return a.Results, nil
+	return nil
+}
+
+func (a *ReplicaSetAnalyzer) GetResult() []common.Result {
+	return a.Result
 }
--- a/pkg/analyzer/service/serviceAnalyzer.go
+++ b/pkg/analyzer/service/serviceAnalyzer.go
@@ -1,28 +1,29 @@
-package analyzer
+package service

 import (
 	"fmt"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer/common"

 	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
 	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

-type ServiceAnalyzer struct{}
-
-func (ServiceAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
+type ServiceAnalyzer struct {
+	common.Analyzer
+}

+func (a *ServiceAnalyzer) Analyze() error {
 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().CoreV1().Endpoints(a.Namespace).List(a.Context, metav1.ListOptions{})
 	if err != nil {
-		return nil, err
+		return err
 	}

 	var preAnalysis = map[string]common.PreAnalysis{}

 	for _, ep := range list.Items {
-		var failures []common.Failure
+		var failures []string

 		// Check for empty service
 		if len(ep.Subsets) == 0 {
@@ -33,19 +34,7 @@ func (ServiceAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 			}

 			for k, v := range svc.Spec.Selector {
-				failures = append(failures, common.Failure{
-					Text: fmt.Sprintf("Service has no endpoints, expected label %s=%s", k, v),
-					Sensitive: []common.Sensitive{
-						{
-							Unmasked: k,
-							Masked:   util.MaskString(k),
-						},
-						{
-							Unmasked: v,
-							Masked:   util.MaskString(v),
-						},
-					},
-				})
+				failures = append(failures, fmt.Sprintf("Service has no endpoints, expected label %s=%s", k, v))
 			}
 		} else {
 			count := 0
@@ -58,10 +47,7 @@ func (ServiceAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 						count++
 						pods = append(pods, addresses.TargetRef.Kind+"/"+addresses.TargetRef.Name)
 					}
-					failures = append(failures, common.Failure{
-						Text:      fmt.Sprintf("Service has not ready endpoints, pods: %s, expected %d", pods, count),
-						Sensitive: []common.Sensitive{},
-					})
+					failures = append(failures, fmt.Sprintf("Service has not ready endpoints, pods: %s, expected %d", pods, count))
 				}
 			}
 		}
@@ -83,7 +69,11 @@ func (ServiceAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {

 		parent, _ := util.GetParent(a.Client, value.Endpoint.ObjectMeta)
 		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
+		a.Result = append(a.Result, currentAnalysis)
 	}
-	return a.Results, nil
+	return nil
+}
+
+func (a *ServiceAnalyzer) GetResult() []common.Result {
+	return a.Result
 }
--- a/pkg/analyzer/service_test.go
+++ b/pkg/analyzer/service_test.go
@@ -1,50 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestServiceAnalyzer(t *testing.T) {
-
-	clientset := fake.NewSimpleClientset(&v1.Endpoints{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:        "example",
-			Namespace:   "default",
-			Annotations: map[string]string{},
-		},
-	},
-		&v1.Service{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:        "example",
-				Namespace:   "default",
-				Annotations: map[string]string{},
-			},
-			Spec: v1.ServiceSpec{
-				Selector: map[string]string{
-					"app": "example",
-				},
-			}})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	serviceAnalyzer := ServiceAnalyzer{}
-	analysisResults, err := serviceAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
--- a/pkg/analyzer/statefulset.go
+++ b/pkg/analyzer/statefulset.go
@@ -1,80 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type StatefulSetAnalyzer struct{}
-
-func (StatefulSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-	list, err := a.Client.GetClient().AppsV1().StatefulSets(a.Namespace).List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, sts := range list.Items {
-		var failures []common.Failure
-
-		// get serviceName
-		serviceName := sts.Spec.ServiceName
-		_, err := a.Client.GetClient().CoreV1().Services(sts.Namespace).Get(a.Context, serviceName, metav1.GetOptions{})
-		if err != nil {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("StatefulSet uses the service %s/%s which does not exist.", sts.Namespace, serviceName),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: sts.Namespace,
-						Masked:   util.MaskString(sts.Namespace),
-					},
-					{
-						Unmasked: serviceName,
-						Masked:   util.MaskString(serviceName),
-					},
-				},
-			})
-		}
-		if len(sts.Spec.VolumeClaimTemplates) > 0 {
-			for _, volumeClaimTemplate := range sts.Spec.VolumeClaimTemplates {
-				if volumeClaimTemplate.Spec.StorageClassName != nil {
-					_, err := a.Client.GetClient().StorageV1().StorageClasses().Get(a.Context, *volumeClaimTemplate.Spec.StorageClassName, metav1.GetOptions{})
-					if err != nil {
-						failures = append(failures, common.Failure{
-							Text: fmt.Sprintf("StatefulSet uses the storage class %s which does not exist.", *volumeClaimTemplate.Spec.StorageClassName),
-							Sensitive: []common.Sensitive{
-								{
-									Unmasked: *volumeClaimTemplate.Spec.StorageClassName,
-									Masked:   util.MaskString(*volumeClaimTemplate.Spec.StorageClassName),
-								},
-							},
-						})
-					}
-				}
-			}
-		}
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", sts.Namespace, sts.Name)] = common.PreAnalysis{
-				StatefulSet:    sts,
-				FailureDetails: failures,
-			}
-		}
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  "StatefulSet",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.StatefulSet.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/analyzer/statefulset_test.go
+++ b/pkg/analyzer/statefulset_test.go
@@ -1,147 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	"github.com/magiconair/properties/assert"
-	appsv1 "k8s.io/api/apps/v1"
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestStatefulSetAnalyzer(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&appsv1.StatefulSet{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      "example",
-				Namespace: "default",
-			},
-		})
-	statefulSetAnalyzer := StatefulSetAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := statefulSetAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
-
-func TestStatefulSetAnalyzerWithoutService(t *testing.T) {
-	clientset := fake.NewSimpleClientset(
-		&appsv1.StatefulSet{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      "example",
-				Namespace: "default",
-			},
-			Spec: appsv1.StatefulSetSpec{
-				ServiceName: "example-svc",
-			},
-		})
-	statefulSetAnalyzer := StatefulSetAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := statefulSetAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	var errorFound bool
-	want := "StatefulSet uses the service default/example-svc which does not exist."
-
-	for _, analysis := range analysisResults {
-		for _, got := range analysis.Error {
-			if want == got.Text {
-				errorFound = true
-			}
-		}
-		if errorFound {
-			break
-		}
-	}
-	if !errorFound {
-		t.Errorf("Error expected: '%v', not found in StatefulSet's analysis results", want)
-	}
-}
-
-func TestStatefulSetAnalyzerMissingStorageClass(t *testing.T) {
-	storageClassName := "example-sc"
-	clientset := fake.NewSimpleClientset(
-		&appsv1.StatefulSet{
-			ObjectMeta: metav1.ObjectMeta{
-				Name:      "example",
-				Namespace: "default",
-			},
-			Spec: appsv1.StatefulSetSpec{
-				ServiceName: "example-svc",
-				VolumeClaimTemplates: []corev1.PersistentVolumeClaim{
-					{
-						TypeMeta: metav1.TypeMeta{
-							Kind:       "PersistentVolumeClaim",
-							APIVersion: "v1",
-						},
-						ObjectMeta: metav1.ObjectMeta{
-							Name: "pvc-example",
-						},
-						Spec: corev1.PersistentVolumeClaimSpec{
-							StorageClassName: &storageClassName,
-							AccessModes: []corev1.PersistentVolumeAccessMode{
-								"ReadWriteOnce",
-							},
-							Resources: corev1.ResourceRequirements{
-								Requests: corev1.ResourceList{
-									corev1.ResourceStorage: resource.MustParse("1Gi"),
-								},
-							},
-						},
-					},
-				},
-			},
-		})
-	statefulSetAnalyzer := StatefulSetAnalyzer{}
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-	analysisResults, err := statefulSetAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	var errorFound bool
-	want := "StatefulSet uses the storage class example-sc which does not exist."
-
-	for _, analysis := range analysisResults {
-		for _, got := range analysis.Error {
-			if want == got.Text {
-				errorFound = true
-			}
-		}
-		if errorFound {
-			break
-		}
-	}
-	if !errorFound {
-		t.Errorf("Error expected: '%v', not found in StatefulSet's analysis results", want)
-	}
-
-}
--- a/pkg/common/types.go
+++ b/pkg/common/types.go
@@ -1,59 +0,0 @@
-package common
-
-import (
-	"context"
-
-	trivy "github.com/aquasecurity/trivy-operator/pkg/apis/aquasecurity/v1alpha1"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	appsv1 "k8s.io/api/apps/v1"
-	autov1 "k8s.io/api/autoscaling/v1"
-	v1 "k8s.io/api/core/v1"
-	networkv1 "k8s.io/api/networking/v1"
-	policyv1 "k8s.io/api/policy/v1"
-)
-
-type IAnalyzer interface {
-	Analyze(analysis Analyzer) ([]Result, error)
-}
-
-type Analyzer struct {
-	Client      *kubernetes.Client
-	Context     context.Context
-	Namespace   string
-	AIClient    ai.IAI
-	PreAnalysis map[string]PreAnalysis
-	Results     []Result
-}
-
-type PreAnalysis struct {
-	Pod                      v1.Pod
-	FailureDetails           []Failure
-	ReplicaSet               appsv1.ReplicaSet
-	PersistentVolumeClaim    v1.PersistentVolumeClaim
-	Endpoint                 v1.Endpoints
-	Ingress                  networkv1.Ingress
-	HorizontalPodAutoscalers autov1.HorizontalPodAutoscaler
-	PodDisruptionBudget      policyv1.PodDisruptionBudget
-	StatefulSet              appsv1.StatefulSet
-	// Integrations
-	TrivyVulnerabilityReport trivy.VulnerabilityReport
-}
-
-type Result struct {
-	Kind         string    `json:"kind"`
-	Name         string    `json:"name"`
-	Error        []Failure `json:"error"`
-	Details      string    `json:"details"`
-	ParentObject string    `json:"parentObject"`
-}
-
-type Failure struct {
-	Text      string
-	Sensitive []Sensitive
-}
-
-type Sensitive struct {
-	Unmasked string
-	Masked   string
-}
--- a/pkg/integration/integration.go
+++ b/pkg/integration/integration.go
@@ -1,113 +0,0 @@
-package integration
-
-import (
-	"errors"
-	"os"
-
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration/trivy"
-	"github.com/spf13/viper"
-)
-
-type IIntegration interface {
-	// Add adds an integration to the cluster
-	Deploy(namespace string) error
-	// Remove removes an integration from the cluster
-	UnDeploy(namespace string) error
-	//
-	AddAnalyzer(*map[string]common.IAnalyzer)
-	// RemoveAnalyzer removes an analyzer from the cluster
-	RemoveAnalyzer() error
-
-	GetAnalyzerName() string
-
-	IsActivate() bool
-}
-
-type Integration struct {
-}
-
-var integrations = map[string]IIntegration{
-	"trivy": trivy.NewTrivy(),
-}
-
-func NewIntegration() *Integration {
-	return &Integration{}
-}
-
-func (*Integration) List() []string {
-	keys := make([]string, 0, len(integrations))
-	for k := range integrations {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-func (*Integration) Get(name string) (IIntegration, error) {
-	if _, ok := integrations[name]; !ok {
-		return nil, errors.New("integration not found")
-	}
-	return integrations[name], nil
-}
-
-func (*Integration) Activate(name string, namespace string) error {
-	if _, ok := integrations[name]; !ok {
-		return errors.New("integration not found")
-	}
-
-	if err := integrations[name].Deploy(namespace); err != nil {
-		return err
-	}
-
-	// Update filters
-	activeFilters := viper.GetStringSlice("active_filters")
-
-	activeFilters = append(activeFilters, integrations[name].GetAnalyzerName())
-
-	viper.Set("active_filters", activeFilters)
-
-	if err := viper.WriteConfig(); err != nil {
-		color.Red("Error writing config file: %s", err.Error())
-		os.Exit(1)
-	}
-
-	return nil
-}
-
-func (*Integration) Deactivate(name string, namespace string) error {
-	if _, ok := integrations[name]; !ok {
-		return errors.New("integration not found")
-	}
-
-	if err := integrations[name].UnDeploy(namespace); err != nil {
-		return err
-	}
-
-	// Update filters
-	// This might be a bad idea, but we cannot reference analyzer here
-	activeFilters := viper.GetStringSlice("active_filters")
-
-	// Remove filter
-	for i, v := range activeFilters {
-		if v == integrations[name].GetAnalyzerName() {
-			activeFilters = append(activeFilters[:i], activeFilters[i+1:]...)
-			break
-		}
-	}
-	viper.Set("active_filters", activeFilters)
-
-	if err := viper.WriteConfig(); err != nil {
-		color.Red("Error writing config file: %s", err.Error())
-		os.Exit(1)
-	}
-
-	return nil
-}
-
-func (*Integration) IsActivate(name string) (bool, error) {
-	if _, ok := integrations[name]; !ok {
-		return false, errors.New("integration not found")
-	}
-	return integrations[name].IsActivate(), nil
-}
--- a/pkg/integration/trivy/analyzer.go
+++ b/pkg/integration/trivy/analyzer.go
@@ -1,74 +0,0 @@
-package trivy
-
-import (
-	"fmt"
-
-	"github.com/aquasecurity/trivy-operator/pkg/apis/aquasecurity/v1alpha1"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	"k8s.io/client-go/rest"
-)
-
-type TrivyAnalyzer struct {
-}
-
-func (TrivyAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	// Get all trivy VulnerabilityReports
-	result := &v1alpha1.VulnerabilityReportList{}
-
-	config := a.Client.GetConfig()
-	// Add group version to sceheme
-	config.ContentConfig.GroupVersion = &v1alpha1.SchemeGroupVersion
-	config.UserAgent = rest.DefaultKubernetesUserAgent()
-	config.APIPath = "/apis"
-
-	restClient, err := rest.UnversionedRESTClientFor(config)
-	if err != nil {
-		return nil, err
-	}
-	err = restClient.Get().Resource("vulnerabilityreports").Do(a.Context).Into(result)
-	if err != nil {
-		return nil, err
-	}
-
-	// Find criticals and get CVE
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, report := range result.Items {
-
-		// For each pod there may be multiple vulnerabilities
-		var failures []common.Failure
-		for _, vuln := range report.Report.Vulnerabilities {
-			if vuln.Severity == "CRITICAL" {
-				// get the vulnerability ID
-				// get the vulnerability description
-				failures = append(failures, common.Failure{
-					Text:      fmt.Sprintf("critical Vulnerability found ID: %s (learn more at: %s)", vuln.VulnerabilityID, vuln.PrimaryLink),
-					Sensitive: []common.Sensitive{},
-				})
-			}
-		}
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", report.Labels["trivy-operator.resource.namespace"],
-				report.Labels["trivy-operator.resource.name"])] = common.PreAnalysis{
-				TrivyVulnerabilityReport: report,
-				FailureDetails:           failures,
-			}
-		}
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  "VulnerabilityReport",
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.TrivyVulnerabilityReport.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/integration/trivy/trivy.go
+++ b/pkg/integration/trivy/trivy.go
@@ -1,103 +0,0 @@
-package trivy
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	helmclient "github.com/mittwald/go-helm-client"
-	"helm.sh/helm/v3/pkg/repo"
-)
-
-const (
-	Repo          = "https://aquasecurity.github.io/helm-charts/"
-	Version       = "0.13.0"
-	ChartName     = "trivy-operator"
-	RepoShortName = "aqua"
-	ReleaseName   = "trivy-operator-k8sgpt"
-)
-
-type Trivy struct {
-	helm helmclient.Client
-}
-
-func NewTrivy() *Trivy {
-	helmClient, err := helmclient.New(&helmclient.Options{})
-	if err != nil {
-		panic(err)
-	}
-	return &Trivy{
-		helm: helmClient,
-	}
-}
-
-func (t *Trivy) GetAnalyzerName() string {
-	return "VulnerabilityReport"
-}
-
-func (t *Trivy) Deploy(namespace string) error {
-
-	// Add the repository
-	chartRepo := repo.Entry{
-		Name: RepoShortName,
-		URL:  Repo,
-	}
-
-	// Add a chart-repository to the client.
-	if err := t.helm.AddOrUpdateChartRepo(chartRepo); err != nil {
-		panic(err)
-	}
-
-	chartSpec := helmclient.ChartSpec{
-		ReleaseName: ReleaseName,
-		ChartName:   fmt.Sprintf("%s/%s", RepoShortName, ChartName),
-		Namespace:   namespace,
-		UpgradeCRDs: true,
-		Wait:        false,
-		Timeout:     300,
-	}
-
-	// Install a chart release.
-	// Note that helmclient.Options.Namespace should ideally match the namespace in chartSpec.Namespace.
-	if _, err := t.helm.InstallOrUpgradeChart(context.Background(), &chartSpec, nil); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (t *Trivy) UnDeploy(namespace string) error {
-	chartSpec := helmclient.ChartSpec{
-		ReleaseName: ReleaseName,
-		ChartName:   fmt.Sprintf("%s/%s", RepoShortName, ChartName),
-		Namespace:   namespace,
-		UpgradeCRDs: true,
-		Wait:        false,
-		Timeout:     300,
-	}
-	// Uninstall the chart release.
-	// Note that helmclient.Options.Namespace should ideally match the namespace in chartSpec.Namespace.
-	if err := t.helm.UninstallRelease(&chartSpec); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Trivy) IsActivate() bool {
-
-	if _, err := t.helm.GetRelease(ReleaseName); err != nil {
-		return false
-	}
-
-	return true
-}
-
-func (t *Trivy) AddAnalyzer(mergedMap *map[string]common.IAnalyzer) {
-
-	(*mergedMap)["VulnerabilityReport"] = &TrivyAnalyzer{}
-
-}
-
-func (t *Trivy) RemoveAnalyzer() error {
-	return nil
-}
--- a/pkg/kubernetes/kubernetes.go
+++ b/pkg/kubernetes/kubernetes.go
@@ -1,29 +1,16 @@
 package kubernetes

 import (
-	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
-	"k8s.io/kubectl/pkg/scheme"
 )

 type Client struct {
-	Client     kubernetes.Interface
-	RestClient rest.Interface
-	Config     *rest.Config
+	client *kubernetes.Clientset
 }

-func (c *Client) GetConfig() *rest.Config {
-	return c.Config
-}
-
-func (c *Client) GetClient() kubernetes.Interface {
-	return c.Client
-}
-
-func (c *Client) GetRestClient() rest.Interface {
-	return c.RestClient
+func (c *Client) GetClient() *kubernetes.Clientset {
+	return c.client
 }

 func NewClient(kubecontext string, kubeconfig string) (*Client, error) {
@@ -42,18 +29,8 @@ func NewClient(kubecontext string, kubeconfig string) (*Client, error) {
 	if err != nil {
 		return nil, err
 	}
-	c.APIPath = "/api"
-	c.GroupVersion = &scheme.Scheme.PrioritizedVersionsForGroup("")[0]
-	c.NegotiatedSerializer = serializer.WithoutConversionCodecFactory{CodecFactory: scheme.Codecs}
-
-	restClient, err := rest.RESTClientFor(c)
-	if err != nil {
-		return nil, err
-	}

 	return &Client{
-		Client:     clientSet,
-		RestClient: restClient,
-		Config:     c,
+		client: clientSet,
 	}, nil
 }
--- a/pkg/util/util.go
+++ b/pkg/util/util.go
@@ -2,26 +2,11 @@ package util

 import (
 	"context"
-	"encoding/base64"
-	"fmt"
-	"math/rand"
-	"regexp"

 	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

-var anonymizePattern = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_=+[]{}|;':\",./<>?")
-
-func SliceContainsString(slice []string, s string) bool {
-	for _, item := range slice {
-		if item == s {
-			return true
-		}
-	}
-	return false
-}
-
 func GetParent(client *kubernetes.Client, meta metav1.ObjectMeta) (string, bool) {
 	if meta.OwnerReferences != nil {
 		for _, owner := range meta.OwnerReferences {
@@ -111,21 +96,3 @@ func SliceDiff(source, dest []string) []string {
 	}
 	return diff
 }
-
-func MaskString(input string) string {
-	key := make([]byte, len(input))
-	result := make([]rune, len(input))
-	rand.Read(key)
-	for i := range result {
-		result[i] = anonymizePattern[int(key[i])%len(anonymizePattern)]
-	}
-	return base64.StdEncoding.EncodeToString([]byte(string(result)))
-}
-
-func ReplaceIfMatch(text string, pattern string, replacement string) string {
-	re := regexp.MustCompile(fmt.Sprintf(`%s(\b)`, pattern))
-	if re.MatchString(text) {
-		text = re.ReplaceAllString(text, replacement)
-	}
-	return text
-}