chore: removed file

Signed-off-by: AlexsJones <alexsimonjones@gmail.com>
feat: http server
2026-03-19 11:33:08 +00:00 · 2023-04-06 21:40:38 +01:00 · 2023-04-06 21:35:47 +01:00
65 changed files with 375 additions and 3367 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/build_container.yaml
+++ b/.github/workflows/build_container.yaml
@@ -33,7 +33,7 @@ jobs:

    steps:
      - name: Check out code
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3

      - name: Extract branch name
        id: extract_branch
@@ -70,7 +70,7 @@ jobs:
      RELEASE_REGISTRY: "localhost:5000/k8sgpt"
    steps:
      - name: Check out code
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3

      - name: Set up Docker Buildx
        id: buildx
@@ -115,7 +115,7 @@ jobs:
      contents: read # Needed for checking out the repository
    steps:
      - name: Check out code
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3

      - name: Login to GitHub Container Registry
        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a # v2
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -23,9 +23,9 @@ jobs:
    # Release-please creates a PR that tracks all changes
    steps:
      - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        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
@@ -41,7 +41,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
        with:
          fetch-depth: 0
      - name: Set up Go
@@ -49,7 +49,7 @@ jobs:
        with:
          go-version: '1.20'
      - name: Download Syft
-        uses: anchore/sbom-action/download-syft@422cb34a0f8b599678c41b21163ea6088edb2624 # v0.14.1
+        uses: anchore/sbom-action/download-syft@448520c4f19577ffce70a8317e619089054687e3 # v0.13.4
      - name: Run GoReleaser
        uses: goreleaser/goreleaser-action@f82d6c1c344bcacabba2c841718984797f664a6b # v4
        with:
@@ -74,7 +74,7 @@ jobs:
      IMAGE_NAME: k8sgpt
    steps:
      - name: Checkout
-        uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+        uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3
        with:
          submodules: recursive

--- a/.github/workflows/test.yaml
+++ b/.github/workflows/test.yaml
@@ -1,12 +1,6 @@
 name: Run tests

-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches:
-      - main
+on: [push]

 env:
    GO_VERSION: "~1.20"
@@ -16,7 +10,7 @@ jobs:

    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v3
+      - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3 # v3

      - name: Set up Go
        uses: actions/setup-go@4d34df0c2316fe8122ab82dc22947d607c0c91f9 # v4
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1 +1 @@
-{".":"0.2.3"}
+{".":"0.2.0"}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,131 +1,5 @@
 # Changelog

-## [0.2.3](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.2.2...v0.2.3) (2023-04-16)
-
-
-### Features
-
-* add node analyzer ([#272](https://github.com/k8sgpt-ai/k8sgpt/issues/272)) ([6247a1c](https://github.com/k8sgpt-ai/k8sgpt/commit/6247a1c0f3c2ead6a59661afed06973c29e57eca))
-* add output query param on serve mode & refactor output logic ([9642202](https://github.com/k8sgpt-ai/k8sgpt/commit/9642202ed1b09c06a687651b7818c2a4df8a0c06))
-* add server metrics ([#273](https://github.com/k8sgpt-ai/k8sgpt/issues/273)) ([a3becc9](https://github.com/k8sgpt-ai/k8sgpt/commit/a3becc9906515d0567808fee9a4e322451d6dc3f))
-* envs to initialise server ([0071e25](https://github.com/k8sgpt-ai/k8sgpt/commit/0071e25992fc86c3882c2066873a2b04b43fe476))
-* rename server/main.go to server/server.go ([9121a98](https://github.com/k8sgpt-ai/k8sgpt/commit/9121a983e52fa15c07bcc3bb361df97b8085c24c))
-* running in cluster ([842f08c](https://github.com/k8sgpt-ai/k8sgpt/commit/842f08c655fde66b6b628192490e50be2ac3dcef))
-* running in cluster ([3988eb2](https://github.com/k8sgpt-ai/k8sgpt/commit/3988eb2fd0a7d29ffa7b7bbc59960ca91e50466e))
-* switch config file to XDG conform location ([dee4355](https://github.com/k8sgpt-ai/k8sgpt/commit/dee435514d7f717e4eb63b15a9d9fdb0722330ac))
-* wip blocked until we have envs ([fe2c08c](https://github.com/k8sgpt-ai/k8sgpt/commit/fe2c08cf72a6ca271d1b431be66653f1396f304d))
-
-
-### Bug Fixes
-
-* add new line after version cmd output ([92e7b3d](https://github.com/k8sgpt-ai/k8sgpt/commit/92e7b3d3fb00c33ac48230caac34f45729e2f6b2))
-* **deps:** update module github.com/sashabaranov/go-openai to v1.8.0 ([#277](https://github.com/k8sgpt-ai/k8sgpt/issues/277)) ([51b1b35](https://github.com/k8sgpt-ai/k8sgpt/commit/51b1b352acd24ebdc4cf9d9121f25c90e8f76ba7))
-* resolve issue with duplicated integration filters. ([960ba56](https://github.com/k8sgpt-ai/k8sgpt/commit/960ba568d0dcc2ace722dc5c9b7c846366a98070))
-* use the aiProvider object when launching the server instead of the deprecated configuration keys ([e7076ed](https://github.com/k8sgpt-ai/k8sgpt/commit/e7076ed6093aa9609d8c884b7a03e295057aaa8e))
-
-
-### Other
-
-* updated ([f0a0c9a](https://github.com/k8sgpt-ai/k8sgpt/commit/f0a0c9aebf627d65b0192ba3d0786cefd81e1fef))
-
-## [0.2.2](https://github.com/k8sgpt-ai/k8sgpt/compare/v0.2.1...v0.2.2) (2023-04-14)
-
-
-### Features
-
-* add simple health endpoint ([26c0cb2](https://github.com/k8sgpt-ai/k8sgpt/commit/26c0cb2eed75695220007e6d6f7b492c2641a149))
-* anoymization based on pr feedback ([19e1b94](https://github.com/k8sgpt-ai/k8sgpt/commit/19e1b94e7c9ce4092f1dabd659023a193b2c4a92))
-* anoymization based on pr feedback ([fe52951](https://github.com/k8sgpt-ai/k8sgpt/commit/fe529510b68ac5fbd39c147c7719abe2e7d20894))
-* check for auth only in case of --explain ([57790e5](https://github.com/k8sgpt-ai/k8sgpt/commit/57790e5bc7037f57a4f73248fe05cac192511470))
-* first version of serve ([b2e8add](https://github.com/k8sgpt-ai/k8sgpt/commit/b2e8adda333fbd508f0f01f2afcabc57bf9948c2))
-* unified cmd and api ([9157d4d](https://github.com/k8sgpt-ai/k8sgpt/commit/9157d4dd1312bf75b336beb0e097422b303d22f1))
-* updated api ([adae2ef](https://github.com/k8sgpt-ai/k8sgpt/commit/adae2ef71d81431711c552159362336e496b21ee))
-
-
-### Bug Fixes
-
-* bool conversion ([336ec2a](https://github.com/k8sgpt-ai/k8sgpt/commit/336ec2a42693d0df325b95cbebd9545b19e27725))
-* **deps:** update module helm.sh/helm/v3 to v3.11.3 ([4dd91ed](https://github.com/k8sgpt-ai/k8sgpt/commit/4dd91ed8263292476054bc70d3d6a3149f88f1b3))
-* naming ([159b385](https://github.com/k8sgpt-ai/k8sgpt/commit/159b3851ec54e93a447b0f13aa4ceb7b8b8f62db))
-* start message ([6b63027](https://github.com/k8sgpt-ai/k8sgpt/commit/6b630275eb64b799c50e3074cb22a3b41bb893de))
-
-
-### Docs
-
-* fix Slack link ([1dccaea](https://github.com/k8sgpt-ai/k8sgpt/commit/1dccaea3f4f96b2da52999eed5031f02a89c0b6e))
-
-
-### Other
-
-* added oidc ([bffad41](https://github.com/k8sgpt-ai/k8sgpt/commit/bffad41134d231b16f136a619174ff3bee61765a))
-* additional analyzers ([23071fd](https://github.com/k8sgpt-ai/k8sgpt/commit/23071fd2e6b421f0f5fcd6e7e4985c6900e5405c))
-* **deps:** bump github.com/docker/docker ([#268](https://github.com/k8sgpt-ai/k8sgpt/issues/268)) ([7d1e2ac](https://github.com/k8sgpt-ai/k8sgpt/commit/7d1e2acaf3eaf00929ff43b9373df6a4be100795))
-* **deps:** update actions/checkout digest to 83b7061 ([cbe6f27](https://github.com/k8sgpt-ai/k8sgpt/commit/cbe6f27c05e82f55f41b648b01972ba2c43f1534))
-* **deps:** update actions/checkout digest to 8e5e7e5 ([#266](https://github.com/k8sgpt-ai/k8sgpt/issues/266)) ([0af34a1](https://github.com/k8sgpt-ai/k8sgpt/commit/0af34a1a95502dc26d7e08bac896f691e4969090))
-* **deps:** update module oras.land/oras-go to v1.2.3 ([#249](https://github.com/k8sgpt-ai/k8sgpt/issues/249)) ([13c9231](https://github.com/k8sgpt-ai/k8sgpt/commit/13c9231aafef3a259fd678a80063ad2e968d6e95))
-* fixing up tests ([f9b25d9](https://github.com/k8sgpt-ai/k8sgpt/commit/f9b25d9e85a8faaf1aae59d7bedc4c0f3538181e))
-* fixing up tests ([498d454](https://github.com/k8sgpt-ai/k8sgpt/commit/498d454c174c7d39da1ca63b2a201e797d7e5e1c))
-* Merge branch 'main' into feat/additional-analyzers ([4d36248](https://github.com/k8sgpt-ai/k8sgpt/commit/4d3624830ff840f9ccf11d7da20953bdf4c7c7fc))
-* removing field ([ddb51c7](https://github.com/k8sgpt-ai/k8sgpt/commit/ddb51c7af470044a8514ed013b44cc135e4c0f10))
-
-## [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)


--- a/16
+++ b/16
@@ -1,16 +0,0 @@
-.PHONY: docker-build
-IMG ?= ghcr.io/k8sgpt-ai/k8sgpt:latest
-
-deploy:
-ifndef SECRET
-	$(error SECRET environment variable is not set)
-endif
-	kubectl create ns k8sgpt || true
-	kubectl create secret generic ai-backend-secret --from-literal=secret-key=$(SECRET) --namespace=k8sgpt || true
-	kubectl apply -f container/manifests
-undeploy:
-	kubectl delete secret ai-backend-secret --namespace=k8sgpt
-	kubectl delete -f container/manifests
-	kubectl delete ns k8sgpt
-docker-build:
-	docker buildx build --build-arg=VERSION="$$(git describe --tags --abbrev=0)" --build-arg=COMMIT="$$(git rev-parse --short HEAD)" --build-arg DATE="$$(date +%FT%TZ)" --platform="linux/amd64,linux/arm64" -t ${IMG} -f container/Dockerfile . --push
--- a/README.md
+++ b/README.md
@@ -28,16 +28,16 @@ brew install k8sgpt
  **32 bit:**
  <!---x-release-please-start-version-->
  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.3/k8sgpt_386.rpm
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/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.3/k8sgpt_amd64.rpm
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/k8sgpt_amd64.rpm
  sudo rpm -ivh -i k8sgpt_amd64.rpm
  ```
  <!---x-release-please-end-->
@@ -49,15 +49,15 @@ brew install k8sgpt
  **32 bit:**
  <!---x-release-please-start-version-->
  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.3/k8sgpt_386.deb
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/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.3/k8sgpt_amd64.deb
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/k8sgpt_amd64.deb
  sudo dpkg -i k8sgpt_amd64.deb
  ```
  <!---x-release-please-end-->
@@ -70,14 +70,14 @@ brew install k8sgpt
  **32 bit:**
  <!---x-release-please-start-version-->
  ```
-  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.3/k8sgpt_386.apk
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/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.3/k8sgpt_amd64.apk
+  curl -LO https://github.com/k8sgpt-ai/k8sgpt/releases/download/v0.2.0/k8sgpt_amd64.apk
  apk add k8sgpt_amd64.apk
  ```
  <!---x-release-please-end-->x
@@ -88,7 +88,7 @@ brew install k8sgpt
  When installing Homebrew on WSL or Linux, you may encounter the following error:

  ```
-  ==> Installing k8sgpt from k8sgpt-ai/k8sgpt Error: The following formula cannot be installed from a bottle and must be
+  ==> Installing k8sgpt from k8sgpt-ai/k8sgpt Error: The following formula cannot be installed from a bottle and must be 
  built from the source. k8sgpt Install Clang or run brew install gcc.
  ```

@@ -102,7 +102,7 @@ If you install gcc as suggested, the problem will persist. Therefore, you need t

 ## Windows

-* Download the latest Windows binaries of **k8sgpt** from the [Release](https://github.com/k8sgpt-ai/k8sgpt/releases)
+* 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

@@ -117,7 +117,7 @@ If you install gcc as suggested, the problem will persist. Therefore, you need t

 * 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.
+* Run `k8sgpt auth` to set it in k8sgpt. 
  * You can provide the password directly using the `--password` flag.
 * 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.
@@ -127,7 +127,7 @@ If you install gcc as suggested, the problem will persist. Therefore, you need t

 ## Analyzers

-K8sGPT uses analyzers to triage and diagnose issues in your cluster. It has a set of analyzers that are built in, but
+K8sGPT uses analyzers to triage and diagnose issues in your cluster. It has a set of analyzers that are built in, but 
 you will be able to write your own analyzers.

 ### Built in analyzers
@@ -140,16 +140,11 @@ you will be able to write your own analyzers.
 - [x] serviceAnalyzer
 - [x] eventAnalyzer
 - [x] ingressAnalyzer
- [x] statefulSetAnalyzer
- [x] deploymentAnalyzer
- [x] cronJobAnalyzer
- [x] nodeAnalyzer

 #### Optional

 - [x] hpaAnalyzer
 - [x] pdbAnalyzer
- [x] networkPolicyAnalyzer

 ## Usage

@@ -231,42 +226,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.**
-
-</details>
-
 ## Upcoming major milestones

 - [ ] Multiple AI backend support
@@ -275,32 +234,24 @@ The Kubernetes system is trying to scale a StatefulSet named fake-deployment usi

 ## What about kubectl-ai?

-The kubectl-ai [project](https://github.com/sozercan/kubectl-ai) uses AI to create manifests and apply them to the
+The kubectl-ai [project](https://github.com/sozercan/kubectl-ai) uses AI to create manifests and apply them to the 
 cluster. It is not what we are trying to do here, it is focusing on writing YAML manifests.

-K8sgpt is focused on triaging and diagnosing issues in your cluster. It is a tool for SRE, Platform & DevOps engineers
-to help them understand what is going on in their cluster. Cutting through the noise of logs and multiple tools to find
+K8sgpt is focused on triaging and diagnosing issues in your cluster. It is a tool for SRE, Platform & DevOps engineers 
+to help them understand what is going on in their cluster. Cutting through the noise of logs and multiple tools to find 
 the root cause of an issue.


 ## Configuration

-`k8sgpt` stores config data in the `$XDG_CONFIG_HOME/k8sgpt/k8sgpt.yaml` file. The data is stored in plain text, including your OpenAI key.
-
-Config file locations:
-| OS      | Path                                             |
-|---------|--------------------------------------------------|
-| MacOS   | ~/Library/Application Support/k8sgpt/k8sgpt.yaml |
-| Linux   | ~/.config/k8sgpt/k8sgpt.yaml                     |
-| Windows | %LOCALAPPDATA%/k8sgpt/k8sgpt.yaml                |
-
+`k8sgpt` stores config data in `~/.k8sgpt.yaml` the data is stored in plain text, including your OpenAI key.

 ## Contributing

 Please read our [contributing guide](./CONTRIBUTING.md).
 ## Community
-Find us on [Slack](https://join.slack.com/t/k8sgpt/shared_invite/zt-1rwe5fpzq-VNtJK8DmYbbm~iWL1H34nw)
+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>
+</a>
--- a/cmd/analyze/analyze.go
+++ b/cmd/analyze/analyze.go
@@ -1,12 +1,16 @@
 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"
 )

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

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

-		// AnalysisResult configuration
-		config, err := analysis.NewAnalysis(backend, language, filters, namespace, nocache, explain)
+		// get ai configuration
+		var configAI ai.AIConfiguration
+		err := viper.UnmarshalKey("ai", &configAI)
 		if err != nil {
 			color.Red("Error: %v", err)
 			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
+			}
+		}
+
+		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)
+			os.Exit(1)
+		}
+
+		ctx := context.Background()
+		// Get kubernetes client from viper
+		client := viper.Get("kubernetesClient").(*kubernetes.Client)
+		// AnalysisResult configuration
+		config := &analysis.Analysis{
+			Namespace: namespace,
+			NoCache:   nocache,
+			Filters:   filters,
+			Explain:   explain,
+			AIClient:  aiClient,
+			Client:    client,
+			Context:   ctx,
+		}
+
 		err = config.RunAnalysis()
 		if err != nil {
 			color.Red("Error: %v", err)
@@ -43,7 +85,7 @@ var AnalyzeCmd = &cobra.Command{
 		}

 		if explain {
-			err := config.GetAIResults(output, anonymize)
+			err := config.GetAIResults(output)
 			if err != nil {
 				color.Red("Error: %v", err)
 				os.Exit(1)
@@ -51,12 +93,17 @@ var AnalyzeCmd = &cobra.Command{
 		}

 		// print results
-		output, err := config.PrintOutput(output)
-		if err != nil {
-			color.Red("Error: %v", err)
-			os.Exit(1)
+		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()
 		}
-		fmt.Println(string(output))
 	},
 }

@@ -66,8 +113,6 @@ func init() {
 	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/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/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/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
@@ -1,21 +1,20 @@
 package cmd

 import (
-	"fmt"
 	"os"
 	"path/filepath"
-	"github.com/adrg/xdg"
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/cmd/serve"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	"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"
+	"github.com/k8sgpt-ai/k8sgpt/cmd/serve"
+	"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 (
@@ -46,8 +45,6 @@ func Execute(v string) {
 }

 func init() {
-	performConfigMigrationIfNeeded()
-
 	cobra.OnInitialize(initConfig)

 	var kubeconfigPath string
@@ -58,11 +55,14 @@ func init() {
 	rootCmd.AddCommand(analyze.AnalyzeCmd)
 	rootCmd.AddCommand(filters.FiltersCmd)
 	rootCmd.AddCommand(generate.GenerateCmd)
-	rootCmd.AddCommand(integration.IntegrationCmd)
 	rootCmd.AddCommand(serve.ServeCmd)
 	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")
+	viper.Set("rootCmd", rootCmd)
 }

 // initConfig reads in config file and ENV variables if set.
@@ -71,20 +71,27 @@ func initConfig() {
 		// Use config file from the flag.
 		viper.SetConfigFile(cfgFile)
 	} else {
-		// the config will belocated under `~/.config/k8sgpt/k8sgpt.yaml` on linux
-		configDir := filepath.Join(xdg.ConfigHome, "k8sgpt")
+		// Find home directory.
+		home, err := os.UserHomeDir()
+		cobra.CheckErr(err)

-		viper.AddConfigPath(configDir)
+		// Search config in home directory with name ".k8sgpt.git" (without extension).
+		viper.AddConfigPath(home)
 		viper.SetConfigType("yaml")
-		viper.SetConfigName("k8sgpt")
+		viper.SetConfigName(".k8sgpt")

 		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.SetEnvPrefix("K8SGPT")
 	viper.AutomaticEnv() // read in environment variables that match

 	// If a config file is found, read it in.
@@ -92,44 +99,3 @@ func initConfig() {
 		//	fmt.Fprintln(os.Stderr, "Using config file:", viper.ConfigFileUsed())
 	}
 }
-
-func performConfigMigrationIfNeeded() {
-	oldConfig, err := getLegacyConfigFilePath()
-	cobra.CheckErr(err)
-	oldConfigExists, err := util.FileExists(oldConfig)
-	cobra.CheckErr(err)
-
-	newConfig := getConfigFilePath()
-	newConfigExists, err := util.FileExists(newConfig)
-	cobra.CheckErr(err)
-
-	configDir := filepath.Dir(newConfig)
-	err = util.EnsureDirExists(configDir)
-	cobra.CheckErr(err)
-
-	if oldConfigExists && newConfigExists {
-		fmt.Fprintln(os.Stderr, color.RedString("Warning: Legacy config file at `%s` detected! This file will be ignored!", oldConfig))
-		return
-	}
-
-	if oldConfigExists && !newConfigExists {
-		fmt.Fprintln(os.Stderr, color.RedString("Performing config file migration from `%s` to `%s`", oldConfig, newConfig))
-
-		err = os.Rename(oldConfig, newConfig)
-		cobra.CheckErr(err)
-	}
-}
-
-func getConfigFilePath() string {
-	return filepath.Join(xdg.ConfigHome, "k8sgpt", "k8sgpt.yaml")
-}
-
-func getLegacyConfigFilePath() (string, error) {
-	home, err := os.UserHomeDir()
-
-	if err != nil {
-		return "", err
-	}
-
-	return filepath.Join(home, ".k8sgpt.yaml"), nil
-}
--- a/cmd/serve/serve.go
+++ b/cmd/serve/serve.go
@@ -1,91 +1,54 @@
 package serve

 import (
+	"io/ioutil"
+	"log"
+	"net/http"
 	"os"

-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/ai"
-	k8sgptserver "github.com/k8sgpt-ai/k8sgpt/pkg/server"
+	"github.com/julienschmidt/httprouter"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )

 var (
-	port    string
-	backend string
-	token   string
+	port string
 )

+// generateCmd represents the auth command
 var ServeCmd = &cobra.Command{
 	Use:   "serve",
-	Short: "Runs k8sgpt as a server",
-	Long:  `Runs k8sgpt as a server to allow for easy integration with other applications.`,
+	Short: "",
+	Long:  ``,
 	Run: func(cmd *cobra.Command, args []string) {

-		var configAI ai.AIConfiguration
-		err := viper.UnmarshalKey("ai", &configAI)
-		if err != nil {
-			color.Red("Error: %v", err)
-			os.Exit(1)
-		}
-		var aiProvider *ai.AIProvider
-		if len(configAI.Providers) == 0 {
-			// Check for env injection
-			backend = os.Getenv("K8SGPT_BACKEND")
-			password := os.Getenv("K8SGPT_PASSWORD")
-			model := os.Getenv("K8SGPT_MODEL")
-			// If the envs are set, alocate in place to the aiProvider
-			// else exit with error
-			if backend != "" || password != "" || model != "" {
-				aiProvider = &ai.AIProvider{
-					Name:     backend,
-					Password: password,
-					Model:    model,
-				}
+		rootCmd := viper.Get("rootCmd").(*cobra.Command)
+		// Start http server
+		router := httprouter.New()
+		router.GET("/:command", func(w http.ResponseWriter,
+			r *http.Request, p httprouter.Params) {

-				configAI.Providers = append(configAI.Providers, *aiProvider)
-
-				viper.Set("ai", configAI)
-				if err := viper.WriteConfig(); err != nil {
-					color.Red("Error writing config file: %s", err.Error())
-					os.Exit(1)
-				}
-			} else {
-				color.Red("Error: AI provider not specified in configuration. Please run k8sgpt auth")
-				os.Exit(1)
+			// find the command
+			command := p.ByName("command")
+			cmd, string, err := rootCmd.Find([]string{command})
+			if err != nil {
+				w.Write([]byte(err.Error()))
 			}
-		}
-		if aiProvider == nil {
-			for _, provider := range configAI.Providers {
-				if backend == provider.Name {
-					aiProvider = &provider
-					break
-				}
-			}
-		}
+			old := os.Stdout // keep backup of the real stdout
+			rd, d, _ := os.Pipe()
+			os.Stdout = d
+			cmd.Run(cmd, string)
+			d.Close()
+			out, _ := ioutil.ReadAll(rd)
+			os.Stdout = old // restoring the real stdout
+			w.Write(out)
+		})

-		if aiProvider.Name == "" {
-			color.Red("Error: AI provider %s not specified in configuration. Please run k8sgpt auth", backend)
-			os.Exit(1)
-		}
-
-		server := k8sgptserver.Config{
-			Backend: aiProvider.Name,
-			Port:    port,
-			Token:   aiProvider.Password,
-		}
-
-		err = server.Serve()
-		if err != nil {
-			color.Red("Error: %v", err)
-			os.Exit(1)
-		}
-		// override the default backend if a flag is provided
+		log.Fatal(http.ListenAndServe(":8080", router))
 	},
 }

 func init() {
 	// add flag for backend
-	ServeCmd.Flags().StringVarP(&port, "port", "p", "8080", "Port to run the server on")
-	ServeCmd.Flags().StringVarP(&backend, "backend", "b", "openai", "Backend AI provider")
+	ServeCmd.Flags().StringVarP(&port, "port", "p", "8080", "Port to serve on")
 }
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -1,6 +1,8 @@
 package cmd

 import (
+	"fmt"
+
 	"github.com/spf13/cobra"
 )

@@ -10,7 +12,7 @@ var versionCmd = &cobra.Command{
 	Short: "Print the version number of k8sgpt",
 	Long:  `All software has versions. This is k8sgpt's`,
 	Run: func(cmd *cobra.Command, args []string) {
-		cmd.Printf("k8sgpt version %s\n", version)
+		fmt.Printf("k8sgpt version %s", version)
 	},
 }

--- a/container/manifests/deployment.yaml
+++ b/container/manifests/deployment.yaml
@@ -1,42 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: k8sgpt-deployment
-  namespace: k8sgpt
-  labels:
-    app: k8sgpt
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: k8sgpt
-  template:
-    metadata:
-      labels:
-        app: k8sgpt
-    spec:
-      serviceAccountName: k8sgpt
-      containers:
-      - name: k8sgpt-container
-        imagePullPolicy: Always
-        image: ghcr.io/k8sgpt-ai/k8sgpt:v0.2.3 #x-release-please-version
-        ports:
-        - containerPort: 8080
-        args: ["serve"]
-        resources:
-          limits:
-            cpu: "1"
-            memory: "512Mi"
-          requests:
-            cpu: "0.5"
-            memory: "256Mi"
-        env:
-        - name: K8SGPT_MODEL
-          value: "gpt-3.5-turbo"
-        - name: K8SGPT_BACKEND
-          value: "openai"
-        - name: K8SGPT_PASSWORD
-          valueFrom:
-            secretKeyRef:
-              name: ai-backend-secret
-              key: secret-key
--- a/container/manifests/role.yaml
+++ b/container/manifests/role.yaml
@@ -1,13 +0,0 @@
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRole
-metadata:
-  name: k8sgpt-cluster-role-all
-rules:
- apiGroups:
-  - '*'
-  resources:
-  - '*'
-  verbs:
-  - get
-  - list
-  - watch
--- a/container/manifests/rolebinding.yaml
+++ b/container/manifests/rolebinding.yaml
@@ -1,13 +0,0 @@
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRoleBinding
-metadata:
-  name: k8sgpt-rolebinding
-  namespace: k8sgpt
-subjects:
- kind: ServiceAccount
-  name: k8sgpt
-  namespace: k8sgpt
-roleRef:
-  kind: ClusterRole
-  name: k8sgpt-cluster-role-all
-  apiGroup: rbac.authorization.k8s.io
--- a/container/manifests/sa.yaml
+++ b/container/manifests/sa.yaml
@@ -1,5 +0,0 @@
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: k8sgpt
-  namespace: k8sgpt
--- a/container/manifests/service.yaml
+++ b/container/manifests/service.yaml
@@ -1,13 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: k8sgpt-service
-  namespace: k8sgpt
-spec:
-  selector:
-    app: k8sgpt
-  ports:
-    - name: http
-      port: 8080
-      targetPort: 8080
-  type: ClusterIP
--- a/11
+++ b/11
@@ -1,11 +0,0 @@
-. demo-magic.sh
-clear
-
-pe "k8sgpt filter list"
-pe "k8sgpt analyze --filter=Pod --explain -o json | jq ."
-pe "k8sgpt integration list"
-pe "k8sgpt integration activate trivy"
-pe "k8sgpt filter list"
-pe "k8sgpt analyze --filter=VulnerabilityReport"
-pe "./k8sgpt analyze --filter=Node --explain"
-
--- a/go.mod
+++ b/go.mod
@@ -3,181 +3,74 @@ 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.8.0
+	github.com/sashabaranov/go-openai v1.6.1
 	github.com/schollz/progressbar/v3 v3.13.1
 	github.com/spf13/cobra v1.7.0
 	github.com/spf13/viper v1.15.0
 	github.com/stretchr/testify v1.8.2
+	golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa
 	golang.org/x/term v0.7.0
-	helm.sh/helm/v3 v3.11.3
 	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/adrg/xdg v0.4.0 // indirect
-
 require (
-	github.com/AdaLogics/go-fuzz-headers v0.0.0-20230106234847-43070de90fa1 // indirect
-	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.7.0 // 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.3+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/evanphx/json-patch v4.12.0+incompatible // 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-logr/stdr v1.2.2 // 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/errwrap v1.1.0 // indirect
-	github.com/hashicorp/go-multierror v1.1.1 // 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/julienschmidt/httprouter v1.3.0 // 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/robfig/cron/v3 v3.0.1
-	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.opentelemetry.io/otel v1.14.0 // indirect
-	go.opentelemetry.io/otel/trace v1.14.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.7.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/text v0.9.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-20230306155012-7f2fa6fef1f4 // 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.2.3
-
-// 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/images/demo5.gif
+++ b/images/demo5.gif
--- a/images/nodes.gif
+++ b/images/nodes.gif
--- a/pkg/ai/noopai.go
+++ b/pkg/ai/noopai.go
@@ -5,7 +5,6 @@ import (
 	"encoding/base64"
 	"fmt"
 	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	"github.com/spf13/viper"
 	"strings"
 )
@@ -34,7 +33,6 @@ func (a *NoOpAIClient) Parse(ctx context.Context, prompt []string, nocache bool)
 	inputKey := strings.Join(prompt, " ")
 	// Check for cached data
 	sEnc := base64.StdEncoding.EncodeToString([]byte(inputKey))
-	cacheKey := util.GetCacheKey(a.GetName(), sEnc)

 	response, err := a.GetCompletion(ctx, inputKey)
 	if err != nil {
@@ -42,8 +40,8 @@ func (a *NoOpAIClient) Parse(ctx context.Context, prompt []string, nocache bool)
 		return "", err
 	}

-	if !viper.IsSet(cacheKey) {
-		viper.Set(cacheKey, base64.StdEncoding.EncodeToString([]byte(response)))
+	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
--- a/pkg/ai/openai.go
+++ b/pkg/ai/openai.go
@@ -5,7 +5,6 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	"strings"

 	"github.com/fatih/color"
@@ -56,14 +55,14 @@ func (c *OpenAIClient) GetCompletion(ctx context.Context, prompt string) (string
 }

 func (a *OpenAIClient) 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))
-	cacheKey := util.GetCacheKey(a.GetName(), sEnc)
 	// find in viper cache
-	if viper.IsSet(cacheKey) && !nocache {
+	if viper.IsSet(sEnc) && !nocache {
 		// retrieve data from cache
-		response := viper.GetString(cacheKey)
+		response := viper.GetString(sEnc)
 		if response == "" {
 			color.Red("error retrieving cached data")
 			return "", nil
@@ -78,11 +77,12 @@ func (a *OpenAIClient) Parse(ctx context.Context, prompt []string, nocache bool)

 	response, err := a.GetCompletion(ctx, inputKey)
 	if err != nil {
+		color.Red("error getting completion: %v", err)
 		return "", err
 	}

-	if !viper.IsSet(cacheKey) || nocache {
-		viper.Set(cacheKey, base64.StdEncoding.EncodeToString([]byte(response)))
+	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
--- a/pkg/analysis/analysis.go
+++ b/pkg/analysis/analysis.go
@@ -2,7 +2,7 @@ package analysis

 import (
 	"context"
-	"errors"
+	"encoding/json"
 	"fmt"
 	"os"
 	"strings"
@@ -10,9 +10,7 @@ import (
 	"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/kubernetes"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
 	"github.com/schollz/progressbar/v3"
 	"github.com/spf13/viper"
 )
@@ -22,7 +20,7 @@ type Analysis struct {
 	Filters   []string
 	Client    *kubernetes.Client
 	AIClient  ai.IAI
-	Results   []common.Result
+	Results   []analyzer.Result
 	Namespace string
 	NoCache   bool
 	Explain   bool
@@ -36,71 +34,18 @@ const (
 )

 type JsonOutput struct {
-	Status   AnalysisStatus  `json:"status"`
-	Problems int             `json:"problems"`
-	Results  []common.Result `json:"results"`
-}
-
-func NewAnalysis(backend string, language string, filters []string, namespace string, noCache bool, explain bool) (*Analysis, error) {
-	var configAI ai.AIConfiguration
-	err := viper.UnmarshalKey("ai", &configAI)
-	if err != nil {
-		color.Red("Error: %v", err)
-		os.Exit(1)
-	}
-
-	if len(configAI.Providers) == 0 && explain {
-		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
-		}
-	}
-
-	if aiProvider.Name == "" {
-		color.Red("Error: AI provider %s not specified in configuration. Please run k8sgpt auth", backend)
-		return nil, errors.New("AI provider not specified in configuration")
-	}
-
-	aiClient := ai.NewClient(aiProvider.Name)
-	if err := aiClient.Configure(aiProvider.Password, aiProvider.Model, language); err != nil {
-		color.Red("Error: %v", err)
-		return nil, err
-	}
-
-	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)
-		return nil, err
-	}
-
-	return &Analysis{
-		Context:   ctx,
-		Filters:   filters,
-		Client:    client,
-		AIClient:  aiClient,
-		Namespace: namespace,
-		NoCache:   noCache,
-		Explain:   explain,
-	}, nil
+	Status   AnalysisStatus    `json:"status"`
+	Problems int               `json:"problems"`
+	Results  []analyzer.Result `json:"results"`
 }

 func (a *Analysis) RunAnalysis() error {
+
 	activeFilters := viper.GetStringSlice("active_filters")

 	analyzerMap := analyzer.GetAnalyzerMap()

-	analyzerConfig := common.Analyzer{
+	analyzerConfig := analyzer.Analyzer{
 		Client:    a.Client,
 		Context:   a.Context,
 		Namespace: a.Namespace,
@@ -128,8 +73,6 @@ func (a *Analysis) RunAnalysis() error {
 					return err
 				}
 				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
@@ -148,7 +91,46 @@ func (a *Analysis) RunAnalysis() error {
 	return nil
 }

-func (a *Analysis) GetAIResults(output string, anonymize bool) error {
+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))
+		}
+		fmt.Println(color.GreenString(result.Details + "\n"))
+	}
+}
+
+func (a *Analysis) GetAIResults(output string) error {
 	if len(a.Results) == 0 {
 		return nil
 	}
@@ -159,40 +141,16 @@ func (a *Analysis) GetAIResults(output string, anonymize bool) error {
 	}

 	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)
+		parsedText, err := a.AIClient.Parse(a.Context, analysis.Error, 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)
+				color.Red("Exhausted API quota. Please try again later")
+				os.Exit(1)
 			}
+			color.Red("Error: %v", err)
+			continue
 		}
-
-		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/pkg/analysis/analysis_test.go
+++ b/pkg/analysis/analysis_test.go
@@ -3,26 +3,25 @@ package analysis
 import (
 	"encoding/json"
 	"fmt"
-	"testing"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
+	"github.com/k8sgpt-ai/k8sgpt/pkg/analyzer"
 	"github.com/stretchr/testify/require"
+	"testing"
 )

 func TestAnalysis_NoProblemJsonOutput(t *testing.T) {

 	analysis := Analysis{
-		Results:   []common.Result{},
+		Results:   []analyzer.Result{},
 		Namespace: "default",
 	}

 	expected := JsonOutput{
 		Status:   StateOK,
 		Problems: 0,
-		Results:  []common.Result{},
+		Results:  []analyzer.Result{},
 	}

-	gotJson, err := analysis.PrintOutput("json")
+	gotJson, err := analysis.JsonOutput()
 	if err != nil {
 		t.Error(err)
 	}
@@ -41,18 +40,13 @@ func TestAnalysis_NoProblemJsonOutput(t *testing.T) {

 func TestAnalysis_ProblemJsonOutput(t *testing.T) {
 	analysis := Analysis{
-		Results: []common.Result{
+		Results: []analyzer.Result{
 			{
-				Kind: "Deployment",
-				Name: "test-deployment",
-				Error: []common.Failure{
-					{
-						Text:      "test-problem",
-						Sensitive: []common.Sensitive{},
-					},
-				},
-				Details:      "test-solution",
-				ParentObject: "parent-resource"},
+				"Deployment",
+				"test-deployment",
+				[]string{"test-problem"},
+				"test-solution",
+				"parent-resource"},
 		},
 		Namespace: "default",
 	}
@@ -60,22 +54,16 @@ func TestAnalysis_ProblemJsonOutput(t *testing.T) {
 	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"},
+		Results: []analyzer.Result{
+			{"Deployment",
+				"test-deployment",
+				[]string{"test-problem"},
+				"test-solution",
+				"parent-resource"},
 		},
 	}

-	gotJson, err := analysis.PrintOutput("json")
+	gotJson, err := analysis.JsonOutput()
 	if err != nil {
 		t.Error(err)
 	}
@@ -94,22 +82,13 @@ func TestAnalysis_ProblemJsonOutput(t *testing.T) {

 func TestAnalysis_MultipleProblemJsonOutput(t *testing.T) {
 	analysis := Analysis{
-		Results: []common.Result{
+		Results: []analyzer.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"},
+				"Deployment",
+				"test-deployment",
+				[]string{"test-problem", "another-test-problem"},
+				"test-solution",
+				"parent-resource"},
 		},
 		Namespace: "default",
 	}
@@ -117,26 +96,16 @@ func TestAnalysis_MultipleProblemJsonOutput(t *testing.T) {
 	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"},
+		Results: []analyzer.Result{
+			{"Deployment",
+				"test-deployment",
+				[]string{"test-problem", "another-test-problem"},
+				"test-solution",
+				"parent-resource"},
 		},
 	}

-	gotJson, err := analysis.PrintOutput("json")
+	gotJson, err := analysis.JsonOutput()
 	if err != nil {
 		t.Error(err)
 	}
--- a/pkg/analysis/output.go
+++ b/pkg/analysis/output.go
@@ -1,72 +0,0 @@
-package analysis
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-
-	"github.com/fatih/color"
-)
-
-var outputFormats = map[string]func(*Analysis) ([]byte, error){
-	"json": (*Analysis).jsonOutput,
-	"text": (*Analysis).textOutput,
-}
-
-func getOutputFormats() []string {
-	formats := make([]string, 0, len(outputFormats))
-	for format := range outputFormats {
-		formats = append(formats, format)
-	}
-	return formats
-}
-
-func (a *Analysis) PrintOutput(format string) ([]byte, error) {
-	outputFunc, ok := outputFormats[format]
-	if !ok {
-		return nil, fmt.Errorf("unsupported output format: %s. Available format %s", format, strings.Join(getOutputFormats(), ","))
-	}
-	return outputFunc(a)
-}
-
-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) textOutput() ([]byte, error) {
-	var output strings.Builder
-	output.WriteString("\n")
-	if len(a.Results) == 0 {
-		output.WriteString(color.GreenString("No problems detected\n"))
-		return []byte(output.String()), nil
-	}
-	for n, result := range a.Results {
-		output.WriteString(fmt.Sprintf("%s %s(%s)\n", color.CyanString("%d", n),
-			color.YellowString(result.Name), color.CyanString(result.ParentObject)))
-		for _, err := range result.Error {
-			output.WriteString(fmt.Sprintf("- %s %s\n", color.RedString("Error:"), color.RedString(err.Text)))
-		}
-		output.WriteString(color.GreenString(result.Details + "\n"))
-	}
-	return []byte(output.String()), nil
-}
--- a/pkg/analyzer/analyzer.go
+++ b/pkg/analyzer/analyzer.go
@@ -1,42 +1,24 @@
 package analyzer

-import (
-	"fmt"
-	"os"
+type IAnalyzer interface {
+	Analyze(analysis Analyzer) ([]Result, error)
+}

-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	AnalyzerErrorsMetric = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "analyzer_errors",
-		Help: "Number of errors detected by analyzer",
-	}, []string{"analyzer_name", "object_name", "namespace"})
-)
-
-var coreAnalyzerMap = map[string]common.IAnalyzer{
+var coreAnalyzerMap = map[string]IAnalyzer{
 	"Pod":                   PodAnalyzer{},
-	"Deployment":            DeploymentAnalyzer{},
 	"ReplicaSet":            ReplicaSetAnalyzer{},
 	"PersistentVolumeClaim": PvcAnalyzer{},
 	"Service":               ServiceAnalyzer{},
 	"Ingress":               IngressAnalyzer{},
 	"StatefulSet":           StatefulSetAnalyzer{},
-	"CronJob":               CronJobAnalyzer{},
-	"Node":                  NodeAnalyzer{},
 }

-var additionalAnalyzerMap = map[string]common.IAnalyzer{
+var additionalAnalyzerMap = map[string]IAnalyzer{
 	"HorizontalPodAutoScaler": HpaAnalyzer{},
 	"PodDisruptionBudget":     PdbAnalyzer{},
-	"NetworkPolicy":           NetworkPolicyAnalyzer{},
 }

-func ListFilters() ([]string, []string, []string) {
+func ListFilters() ([]string, []string) {
 	coreKeys := make([]string, 0, len(coreAnalyzerMap))
 	for k := range coreAnalyzerMap {
 		coreKeys = append(coreKeys, k)
@@ -46,28 +28,12 @@ func ListFilters() ([]string, []string, []string) {
 	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)
-			}
-			integrationAnalyzers = append(integrationAnalyzers, in.GetAnalyzerName())
-		}
-	}
-
-	return coreKeys, additionalKeys, integrationAnalyzers
+	return coreKeys, additionalKeys
 }

-func GetAnalyzerMap() map[string]common.IAnalyzer {
+func GetAnalyzerMap() map[string]IAnalyzer {

-	mergedMap := make(map[string]common.IAnalyzer)
+	mergedMap := make(map[string]IAnalyzer)

 	// add core analyzer
 	for key, value := range coreAnalyzerMap {
@@ -79,23 +45,5 @@ func GetAnalyzerMap() map[string]common.IAnalyzer {
 		mergedMap[key] = value
 	}

-	integrationProvider := integration.NewIntegration()
-
-	for _, i := range integrationProvider.List() {
-		b, err := integrationProvider.IsActivate(i)
-		if err != nil {
-			fmt.Println(color.RedString(err.Error()))
-			os.Exit(1)
-		}
-		if b {
-			in, err := integrationProvider.Get(i)
-			if err != nil {
-				fmt.Println(color.RedString(err.Error()))
-				os.Exit(1)
-			}
-			in.AddAnalyzer(&mergedMap)
-		}
-	}
-
 	return mergedMap
 }
--- a/pkg/analyzer/cronjob.go
+++ b/pkg/analyzer/cronjob.go
@@ -1,119 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	cron "github.com/robfig/cron/v3"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type CronJobAnalyzer struct{}
-
-func (analyzer CronJobAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "CronJob"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
-	var results []common.Result
-
-	cronJobList, err := a.Client.GetClient().BatchV1().CronJobs("").List(a.Context, v1.ListOptions{})
-	if err != nil {
-		return results, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, cronJob := range cronJobList.Items {
-		var failures []common.Failure
-		if cronJob.Spec.Suspend != nil && *cronJob.Spec.Suspend {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("CronJob %s is suspended", cronJob.Name),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: cronJob.Namespace,
-						Masked:   util.MaskString(cronJob.Namespace),
-					},
-					{
-						Unmasked: cronJob.Name,
-						Masked:   util.MaskString(cronJob.Name),
-					},
-				},
-			})
-		} else {
-			// check the schedule format
-			if _, err := CheckCronScheduleIsValid(cronJob.Spec.Schedule); err != nil {
-				failures = append(failures, common.Failure{
-					Text: fmt.Sprintf("CronJob %s has an invalid schedule: %s", cronJob.Name, err.Error()),
-					Sensitive: []common.Sensitive{
-						{
-							Unmasked: cronJob.Namespace,
-							Masked:   util.MaskString(cronJob.Namespace),
-						},
-						{
-							Unmasked: cronJob.Name,
-							Masked:   util.MaskString(cronJob.Name),
-						},
-					},
-				})
-			}
-
-			// check the starting deadline
-			if cronJob.Spec.StartingDeadlineSeconds != nil {
-				deadline := time.Duration(*cronJob.Spec.StartingDeadlineSeconds) * time.Second
-				if deadline < 0 {
-
-					failures = append(failures, common.Failure{
-						Text: fmt.Sprintf("CronJob %s has a negative starting deadline", cronJob.Name),
-						Sensitive: []common.Sensitive{
-							{
-								Unmasked: cronJob.Namespace,
-								Masked:   util.MaskString(cronJob.Namespace),
-							},
-							{
-								Unmasked: cronJob.Name,
-								Masked:   util.MaskString(cronJob.Name),
-							},
-						},
-					})
-
-				}
-			}
-
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", cronJob.Namespace, cronJob.Name)] = common.PreAnalysis{
-				FailureDetails: failures,
-			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, cronJob.Name, cronJob.Namespace).Set(float64(len(failures)))
-
-		}
-
-		for key, value := range preAnalysis {
-			currentAnalysis := common.Result{
-				Kind:  kind,
-				Name:  key,
-				Error: value.FailureDetails,
-			}
-			a.Results = append(results, currentAnalysis)
-		}
-	}
-
-	return a.Results, nil
-}
-
-// Check CRON schedule format
-func CheckCronScheduleIsValid(schedule string) (bool, error) {
-	_, err := cron.ParseStandard(schedule)
-	if err != nil {
-		return false, err
-	}
-
-	return true, nil
-}
--- a/pkg/analyzer/cronjob_test.go
+++ b/pkg/analyzer/cronjob_test.go
@@ -1,126 +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"
-	batchv1 "k8s.io/api/batch/v1"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestCronJobSuccess(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&batchv1.CronJob{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example-cronjob",
-			Namespace: "default",
-			Annotations: map[string]string{
-				"analysisDate": "2022-04-01",
-			},
-			Labels: map[string]string{
-				"app": "example-app",
-			},
-		},
-		Spec: batchv1.CronJobSpec{
-			Schedule:          "*/1 * * * *",
-			ConcurrencyPolicy: "Allow",
-			JobTemplate: batchv1.JobTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{
-					Labels: map[string]string{
-						"app": "example-app",
-					},
-				},
-				Spec: batchv1.JobSpec{
-					Template: v1.PodTemplateSpec{
-						Spec: v1.PodSpec{
-							Containers: []v1.Container{
-								{
-									Name:  "example-container",
-									Image: "nginx",
-								},
-							},
-							RestartPolicy: v1.RestartPolicyOnFailure,
-						},
-					},
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analyzer := CronJobAnalyzer{}
-	analysisResults, err := analyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	assert.Equal(t, len(analysisResults), 0)
-}
-
-func TestCronJobBroken(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&batchv1.CronJob{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example-cronjob",
-			Namespace: "default",
-			Annotations: map[string]string{
-				"analysisDate": "2022-04-01",
-			},
-			Labels: map[string]string{
-				"app": "example-app",
-			},
-		},
-		Spec: batchv1.CronJobSpec{
-			Schedule:          "*** * * * *",
-			ConcurrencyPolicy: "Allow",
-			JobTemplate: batchv1.JobTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{
-					Labels: map[string]string{
-						"app": "example-app",
-					},
-				},
-				Spec: batchv1.JobSpec{
-					Template: v1.PodTemplateSpec{
-						Spec: v1.PodSpec{
-							Containers: []v1.Container{
-								{
-									Name:  "example-container",
-									Image: "nginx",
-								},
-							},
-							RestartPolicy: v1.RestartPolicyOnFailure,
-						},
-					},
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analyzer := CronJobAnalyzer{}
-	analysisResults, err := analyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	assert.Equal(t, len(analysisResults), 1)
-	assert.Equal(t, analysisResults[0].Name, "default/example-cronjob")
-	assert.Equal(t, analysisResults[0].Kind, "CronJob")
-}
--- a/pkg/analyzer/deployment.go
+++ b/pkg/analyzer/deployment.go
@@ -1,69 +0,0 @@
-package analyzer
-
-import (
-	"context"
-	"fmt"
-
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-)
-
-// DeploymentAnalyzer is an analyzer that checks for misconfigured Deployments
-type DeploymentAnalyzer struct {
-}
-
-// Analyze scans all namespaces for Deployments with misconfigurations
-func (d DeploymentAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "Deployment"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
-	deployments, err := a.Client.GetClient().AppsV1().Deployments("").List(context.Background(), v1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, deployment := range deployments.Items {
-		var failures []common.Failure
-		if *deployment.Spec.Replicas != deployment.Status.Replicas {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("Deployment %s/%s has %d replicas but %d are available", deployment.Namespace, deployment.Name, *deployment.Spec.Replicas, deployment.Status.Replicas),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: deployment.Namespace,
-						Masked:   util.MaskString(deployment.Namespace),
-					},
-					{
-						Unmasked: deployment.Name,
-						Masked:   util.MaskString(deployment.Name),
-					},
-				}})
-		}
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", deployment.Namespace, deployment.Name)] = common.PreAnalysis{
-				FailureDetails: failures,
-				Deployment:     deployment,
-			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, deployment.Name, deployment.Namespace).Set(float64(len(failures)))
-		}
-
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/analyzer/deployment_test.go
+++ b/pkg/analyzer/deployment_test.go
@@ -1,62 +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"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestDeploymentAnalyzer(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&appsv1.Deployment{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example",
-			Namespace: "default",
-		},
-		Spec: appsv1.DeploymentSpec{
-			Replicas: func() *int32 { i := int32(3); return &i }(),
-			Template: v1.PodTemplateSpec{
-				Spec: v1.PodSpec{
-					Containers: []v1.Container{
-						{
-							Name:  "example-container",
-							Image: "nginx",
-							Ports: []v1.ContainerPort{
-								{
-									ContainerPort: 80,
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		Status: appsv1.DeploymentStatus{
-			Replicas:          2,
-			AvailableReplicas: 1,
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	deploymentAnalyzer := DeploymentAnalyzer{}
-	analysisResults, err := deploymentAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-	assert.Equal(t, analysisResults[0].Kind, "Deployment")
-	assert.Equal(t, analysisResults[0].Name, "default/example")
-}
--- a/pkg/analyzer/events.go
+++ b/pkg/analyzer/events.go
@@ -2,7 +2,6 @@ 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"
--- a/pkg/analyzer/hpa.go
+++ b/pkg/analyzer/hpa.go
@@ -2,31 +2,23 @@ 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) {
-
-	kind := "HorizontalPodAutoscaler"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (HpaAnalyzer) Analyze(a Analyzer) ([]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{}
+	var preAnalysis = map[string]PreAnalysis{}

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

 		// check ScaleTargetRef exist
 		scaleTargetRef := hpa.Spec.ScaleTargetRef
@@ -34,57 +26,45 @@ func (HpaAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {

 		switch scaleTargetRef.Kind {
 		case "Deployment":
-			_, err := a.Client.GetClient().AppsV1().Deployments(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			_, 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(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			_, 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(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			_, 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(hpa.Namespace).Get(a.Context, scaleTargetRef.Name, metav1.GetOptions{})
+			_, err := a.Client.GetClient().AppsV1().StatefulSets(a.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{},
-			})
+			failures = append(failures, fmt.Sprintf("HorizontalPodAutoscaler uses %s as ScaleTargetRef which does not possible option.", scaleTargetRef.Kind))
 		}

 		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),
-					},
-				},
-			})
+			failures = append(failures, fmt.Sprintf("HorizontalPodAutoscaler uses %s/%s as ScaleTargetRef which does not exist.", scaleTargetRef.Kind, scaleTargetRef.Name))
 		}

 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", hpa.Namespace, hpa.Name)] = PreAnalysis{
 				HorizontalPodAutoscalers: hpa,
 				FailureDetails:           failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, hpa.Name, hpa.Namespace).Set(float64(len(failures)))
 		}

 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "HorizontalPodAutoscaler",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/hpaAnalyzer_test.go
+++ b/pkg/analyzer/hpaAnalyzer_test.go
@@ -5,7 +5,6 @@ import (
 	"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"
@@ -24,7 +23,7 @@ func TestHPAAnalyzer(t *testing.T) {
 			},
 		})
 	hpaAnalyzer := HpaAnalyzer{}
-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -56,7 +55,7 @@ func TestHPAAnalyzerWithMultipleHPA(t *testing.T) {
 		},
 	)
 	hpaAnalyzer := HpaAnalyzer{}
-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -87,7 +86,7 @@ func TestHPAAnalyzerWithUnsuportedScaleTargetRef(t *testing.T) {
 		})
 	hpaAnalyzer := HpaAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -102,7 +101,7 @@ func TestHPAAnalyzerWithUnsuportedScaleTargetRef(t *testing.T) {
 	var errorFound bool
 	for _, analysis := range analysisResults {
 		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "which is not an option.") {
+			if strings.Contains(err, "does not possible option.") {
 				errorFound = true
 				break
 			}
@@ -134,7 +133,7 @@ func TestHPAAnalyzerWithNonExistentScaleTargetRef(t *testing.T) {
 		})
 	hpaAnalyzer := HpaAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -149,7 +148,7 @@ func TestHPAAnalyzerWithNonExistentScaleTargetRef(t *testing.T) {
 	var errorFound bool
 	for _, analysis := range analysisResults {
 		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "does not exist.") {
+			if strings.Contains(err, "does not exist.") {
 				errorFound = true
 				break
 			}
@@ -189,7 +188,7 @@ func TestHPAAnalyzerWithExistingScaleTargetRef(t *testing.T) {
 	)
 	hpaAnalyzer := HpaAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
--- a/pkg/analyzer/ingress.go
+++ b/pkg/analyzer/ingress.go
@@ -2,50 +2,30 @@ 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) {
-
-	kind := "Ingress"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (IngressAnalyzer) Analyze(a Analyzer) ([]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{}
+	var preAnalysis = map[string]PreAnalysis{}

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

 		// 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),
-						},
-					},
-				})
+				failures = append(failures, fmt.Sprintf("Ingress %s/%s does not specify an Ingress class.", ing.Namespace, ing.Name))
 			} else {
 				ingressClassName = &ingClassValue
 			}
@@ -55,15 +35,7 @@ func (IngressAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		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),
-						},
-					},
-				})
+				failures = append(failures, fmt.Sprintf("Ingress uses the ingress class %s which does not exist.", *ingressClassName))
 			}
 		}

@@ -73,19 +45,7 @@ func (IngressAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 			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),
-							},
-						},
-					})
+					failures = append(failures, fmt.Sprintf("Ingress uses the service %s/%s which does not exist.", ing.Namespace, path.Backend.Service.Name))
 				}
 			}
 		}
@@ -93,35 +53,21 @@ func (IngressAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		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),
-						},
-					},
-				})
+				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 {
-			preAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", ing.Namespace, ing.Name)] = PreAnalysis{
 				Ingress:        ing,
 				FailureDetails: failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, ing.Name, ing.Namespace).Set(float64(len(failures)))
-
 		}

 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "Ingress",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/ingress_test.go
+++ b/pkg/analyzer/ingress_test.go
@@ -5,7 +5,6 @@ import (
 	"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"
@@ -24,7 +23,7 @@ func TestIngressAnalyzer(t *testing.T) {
 		})
 	ingressAnalyzer := IngressAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -57,7 +56,7 @@ func TestIngressAnalyzerWithMultipleIngresses(t *testing.T) {
 	)
 	ingressAnalyzer := IngressAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -84,7 +83,7 @@ func TestIngressAnalyzerWithoutIngressClassAnnotation(t *testing.T) {
 		})
 	ingressAnalyzer := IngressAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -100,7 +99,7 @@ func TestIngressAnalyzerWithoutIngressClassAnnotation(t *testing.T) {
 	var errorFound bool
 	for _, analysis := range analysisResults {
 		for _, err := range analysis.Error {
-			if strings.Contains(err.Text, "does not specify an Ingress class") {
+			if strings.Contains(err, "does not specify an Ingress class") {
 				errorFound = true
 				break
 			}
--- a/pkg/analyzer/netpol.go
+++ b/pkg/analyzer/netpol.go
@@ -1,83 +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 NetworkPolicyAnalyzer struct{}
-
-func (NetworkPolicyAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "NetworkPolicy"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
-	// get all network policies in the namespace
-	policies, err := a.Client.GetClient().NetworkingV1().
-		NetworkPolicies(a.Namespace).List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, policy := range policies.Items {
-		var failures []common.Failure
-
-		// Check if policy allows traffic to all pods in the namespace
-		if len(policy.Spec.PodSelector.MatchLabels) == 0 {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("Network policy allows traffic to all pods: %s", policy.Name),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: policy.Name,
-						Masked:   util.MaskString(policy.Name),
-					},
-				},
-			})
-			continue
-		}
-		// Check if policy is not applied to any pods
-		podList, err := util.GetPodListByLabels(a.Client.GetClient(), a.Namespace, policy.Spec.PodSelector.MatchLabels)
-		if err != nil {
-			return nil, err
-		}
-		if len(podList.Items) == 0 {
-			failures = append(failures, common.Failure{
-				Text: fmt.Sprintf("Network policy is not applied to any pods: %s", policy.Name),
-				Sensitive: []common.Sensitive{
-					{
-						Unmasked: policy.Name,
-						Masked:   util.MaskString(policy.Name),
-					},
-				},
-			})
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", policy.Namespace, policy.Name)] = common.PreAnalysis{
-				FailureDetails: failures,
-				NetworkPolicy:  policy,
-			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, policy.Name, policy.Namespace).Set(float64(len(failures)))
-
-		}
-	}
-
-	for key, value := range preAnalysis {
-		currentAnalysis := common.Result{
-			Kind:  kind,
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, nil
-}
--- a/pkg/analyzer/netpol_test.go
+++ b/pkg/analyzer/netpol_test.go
@@ -1,122 +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"
-	networkingv1 "k8s.io/api/networking/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/kubernetes/fake"
-)
-
-func TestNetpolNoPods(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&networkingv1.NetworkPolicy{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example",
-			Namespace: "default",
-		},
-		Spec: networkingv1.NetworkPolicySpec{
-			PodSelector: metav1.LabelSelector{
-				MatchLabels: map[string]string{
-					"app": "example",
-				},
-			},
-			Ingress: []networkingv1.NetworkPolicyIngressRule{
-				{
-					From: []networkingv1.NetworkPolicyPeer{
-						{
-							PodSelector: &metav1.LabelSelector{
-								MatchLabels: map[string]string{
-									"app": "database",
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analyzer := NetworkPolicyAnalyzer{}
-	results, err := analyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	assert.Equal(t, len(results), 1)
-	assert.Equal(t, results[0].Kind, "NetworkPolicy")
-
-}
-
-func TestNetpolWithPod(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&networkingv1.NetworkPolicy{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example",
-			Namespace: "default",
-		},
-		Spec: networkingv1.NetworkPolicySpec{
-			PodSelector: metav1.LabelSelector{
-				MatchLabels: map[string]string{
-					"app": "example",
-				},
-			},
-			Ingress: []networkingv1.NetworkPolicyIngressRule{
-				{
-					From: []networkingv1.NetworkPolicyPeer{
-						{
-							PodSelector: &metav1.LabelSelector{
-								MatchLabels: map[string]string{
-									"app": "database",
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}, &v1.Pod{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:      "example",
-			Namespace: "default",
-			Labels: map[string]string{
-				"app": "example",
-			},
-		},
-		Spec: v1.PodSpec{
-			Containers: []v1.Container{
-				{
-					Name:  "example",
-					Image: "example",
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context:   context.Background(),
-		Namespace: "default",
-	}
-
-	analyzer := NetworkPolicyAnalyzer{}
-	results, err := analyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-
-	assert.Equal(t, len(results), 0)
-}
--- a/pkg/analyzer/node.go
+++ b/pkg/analyzer/node.go
@@ -1,83 +0,0 @@
-package analyzer
-
-import (
-	"fmt"
-
-	v1 "k8s.io/api/core/v1"
-
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-type NodeAnalyzer struct{}
-
-func (NodeAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "Node"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
-	list, err := a.Client.GetClient().CoreV1().Nodes().List(a.Context, metav1.ListOptions{})
-	if err != nil {
-		return nil, err
-	}
-
-	var preAnalysis = map[string]common.PreAnalysis{}
-
-	for _, node := range list.Items {
-		var failures []common.Failure
-		for _, nodeCondition := range node.Status.Conditions {
-			// https://kubernetes.io/docs/concepts/architecture/nodes/#condition
-			switch nodeCondition.Type {
-			case v1.NodeReady:
-				if nodeCondition.Status == v1.ConditionTrue {
-					break
-				}
-				failures = addNodeConditionFailure(failures, node.Name, nodeCondition)
-			default:
-				if nodeCondition.Status != v1.ConditionFalse {
-					failures = addNodeConditionFailure(failures, node.Name, nodeCondition)
-				}
-			}
-		}
-
-		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s", node.Name)] = common.PreAnalysis{
-				Node:           node,
-				FailureDetails: failures,
-			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, node.Name, "").Set(float64(len(failures)))
-
-		}
-	}
-
-	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
-			Name:  key,
-			Error: value.FailureDetails,
-		}
-
-		parent, _ := util.GetParent(a.Client, value.Node.ObjectMeta)
-		currentAnalysis.ParentObject = parent
-		a.Results = append(a.Results, currentAnalysis)
-	}
-
-	return a.Results, err
-}
-
-func addNodeConditionFailure(failures []common.Failure, nodeName string, nodeCondition v1.NodeCondition) []common.Failure {
-	failures = append(failures, common.Failure{
-		Text: fmt.Sprintf("%s has condition of type %s, reason %s: %s", nodeName, nodeCondition.Type, nodeCondition.Reason, nodeCondition.Message),
-		Sensitive: []common.Sensitive{
-			{
-				Unmasked: nodeName,
-				Masked:   util.MaskString(nodeName),
-			},
-		},
-	})
-	return failures
-}
--- a/pkg/analyzer/node_test.go
+++ b/pkg/analyzer/node_test.go
@@ -1,111 +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 TestNodeAnalyzerNodeReady(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&v1.Node{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: "node1",
-		},
-		Status: v1.NodeStatus{
-			Conditions: []v1.NodeCondition{
-				{
-					Type:    v1.NodeReady,
-					Status:  v1.ConditionTrue,
-					Reason:  "KubeletReady",
-					Message: "kubelet is posting ready status",
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context: context.Background(),
-	}
-	nodeAnalyzer := NodeAnalyzer{}
-	var analysisResults []common.Result
-	analysisResults, err := nodeAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 0)
-}
-
-func TestNodeAnalyzerNodeDiskPressure(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&v1.Node{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: "node1",
-		},
-		Status: v1.NodeStatus{
-			Conditions: []v1.NodeCondition{
-				{
-					Type:    v1.NodeDiskPressure,
-					Status:  v1.ConditionTrue,
-					Reason:  "KubeletHasDiskPressure",
-					Message: "kubelet has disk pressure",
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context: context.Background(),
-	}
-	nodeAnalyzer := NodeAnalyzer{}
-	var analysisResults []common.Result
-	analysisResults, err := nodeAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
-
-// A cloud provider may set their own condition and/or a new status might be introduced
-// In such cases a failure is assumed and the code shouldn't break, although it might be a false positive
-func TestNodeAnalyzerNodeUnknownType(t *testing.T) {
-	clientset := fake.NewSimpleClientset(&v1.Node{
-		ObjectMeta: metav1.ObjectMeta{
-			Name: "node1",
-		},
-		Status: v1.NodeStatus{
-			Conditions: []v1.NodeCondition{
-				{
-					Type:    "UnknownNodeConditionType",
-					Status:  "CompletelyUnknown",
-					Reason:  "KubeletHasTheUnknown",
-					Message: "kubelet has the unknown",
-				},
-			},
-		},
-	})
-
-	config := common.Analyzer{
-		Client: &kubernetes.Client{
-			Client: clientset,
-		},
-		Context: context.Background(),
-	}
-	nodeAnalyzer := NodeAnalyzer{}
-	var analysisResults []common.Result
-	analysisResults, err := nodeAnalyzer.Analyze(config)
-	if err != nil {
-		t.Error(err)
-	}
-	assert.Equal(t, len(analysisResults), 1)
-}
--- a/pkg/analyzer/pdb.go
+++ b/pkg/analyzer/pdb.go
@@ -2,31 +2,23 @@ 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) {
-
-	kind := "PodDisruptionBudget"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (PdbAnalyzer) Analyze(a Analyzer) ([]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{}
+	var preAnalysis = map[string]PreAnalysis{}

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

 		evt, err := FetchLatestEvent(a.Context, a.Client, pdb.Namespace, pdb.Name)
 		if err != nil || evt == nil {
@@ -36,46 +28,27 @@ func (PdbAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		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),
-							},
-						},
-					})
+					failures = append(failures, fmt.Sprintf("%s, expected label %s=%s", evt.Message, k, 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{},
-					})
+					failures = append(failures, fmt.Sprintf("%s, expected expression %s", evt.Message, v))
 				}
 			} else {
-				failures = append(failures, common.Failure{
-					Text:      fmt.Sprintf("%s, selector is nil", evt.Message),
-					Sensitive: []common.Sensitive{},
-				})
+				failures = append(failures, fmt.Sprintf("%s, selector is nil", evt.Message))
 			}
 		}

 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", pdb.Namespace, pdb.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", pdb.Namespace, pdb.Name)] = PreAnalysis{
 				PodDisruptionBudget: pdb,
 				FailureDetails:      failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, pdb.Name, pdb.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "PodDisruptionBudget",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/pod.go
+++ b/pkg/analyzer/pod.go
@@ -2,8 +2,6 @@ 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"
 )
@@ -11,23 +9,16 @@ import (
 type PodAnalyzer struct {
 }

-func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "Pod"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
+func (PodAnalyzer) Analyze(a Analyzer) ([]Result, 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
 	}
-	var preAnalysis = map[string]common.PreAnalysis{}
+	var preAnalysis = map[string]PreAnalysis{}

 	for _, pod := range list.Items {
-		var failures []common.Failure
+		var failures []string
 		// Check for pending pods
 		if pod.Status.Phase == "Pending" {

@@ -35,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}
 					}
 				}
 			}
@@ -49,10 +37,7 @@ 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
@@ -64,26 +49,22 @@ func (PodAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 						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{
+			preAnalysis[fmt.Sprintf("%s/%s", pod.Namespace, pod.Name)] = PreAnalysis{
 				Pod:            pod,
 				FailureDetails: failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, pod.Name, pod.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "Pod",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/pod_test.go
+++ b/pkg/analyzer/pod_test.go
@@ -4,7 +4,6 @@ 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"
@@ -32,7 +31,7 @@ func TestPodAnalyzer(t *testing.T) {
 		},
 	})

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -40,7 +39,7 @@ func TestPodAnalyzer(t *testing.T) {
 		Namespace: "default",
 	}
 	podAnalyzer := PodAnalyzer{}
-	var analysisResults []common.Result
+	var analysisResults []Result
 	analysisResults, err := podAnalyzer.Analyze(config)
 	if err != nil {
 		t.Error(err)
--- a/pkg/analyzer/pvc.go
+++ b/pkg/analyzer/pvc.go
@@ -2,21 +2,13 @@ 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 PvcAnalyzer struct{}

-func (PvcAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "PersistentVolumeClaim"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (PvcAnalyzer) Analyze(a Analyzer) ([]Result, error) {

 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().CoreV1().PersistentVolumeClaims(a.Namespace).List(a.Context, metav1.ListOptions{})
@@ -24,10 +16,10 @@ func (PvcAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		return nil, err
 	}

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

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

 		// Check for empty rs
 		if pvc.Status.Phase == "Pending" {
@@ -38,24 +30,20 @@ func (PvcAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 				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 {
-			preAnalysis[fmt.Sprintf("%s/%s", pvc.Namespace, pvc.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", pvc.Namespace, pvc.Name)] = PreAnalysis{
 				PersistentVolumeClaim: pvc,
 				FailureDetails:        failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, pvc.Name, pvc.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "PersistentVolumeClaim",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/rs.go
+++ b/pkg/analyzer/rs.go
@@ -2,21 +2,13 @@ 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 ReplicaSetAnalyzer struct{}

-func (ReplicaSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
-
-	kind := "ReplicaSet"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (ReplicaSetAnalyzer) Analyze(a Analyzer) ([]Result, error) {

 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().AppsV1().ReplicaSets(a.Namespace).List(a.Context, metav1.ListOptions{})
@@ -24,10 +16,10 @@ func (ReplicaSetAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		return nil, err
 	}

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

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

 		// Check for empty rs
 		if rs.Status.Replicas == 0 {
@@ -35,26 +27,21 @@ 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}
 				}
 			}
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", rs.Namespace, rs.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", rs.Namespace, rs.Name)] = PreAnalysis{
 				ReplicaSet:     rs,
 				FailureDetails: failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, rs.Name, rs.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "ReplicaSet",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/service.go
+++ b/pkg/analyzer/service.go
@@ -2,22 +2,14 @@ package analyzer

 import (
 	"fmt"
-
 	"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) {
-
-	kind := "Service"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
+func (ServiceAnalyzer) Analyze(a Analyzer) ([]Result, error) {

 	// search all namespaces for pods that are not running
 	list, err := a.Client.GetClient().CoreV1().Endpoints(a.Namespace).List(a.Context, metav1.ListOptions{})
@@ -25,10 +17,10 @@ func (ServiceAnalyzer) Analyze(a common.Analyzer) ([]common.Result, error) {
 		return nil, err
 	}

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

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

 		// Check for empty service
 		if len(ep.Subsets) == 0 {
@@ -39,19 +31,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
@@ -64,26 +44,22 @@ 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))
 				}
 			}
 		}

 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", ep.Namespace, ep.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", ep.Namespace, ep.Name)] = PreAnalysis{
 				Endpoint:       ep,
 				FailureDetails: failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, ep.Name, ep.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "Service",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/service_test.go
+++ b/pkg/analyzer/service_test.go
@@ -4,7 +4,6 @@ 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"
@@ -33,7 +32,7 @@ func TestServiceAnalyzer(t *testing.T) {
 				},
 			}})

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
--- a/pkg/analyzer/statefulset.go
+++ b/pkg/analyzer/statefulset.go
@@ -3,78 +3,39 @@ 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) {
-
-	kind := "StatefulSet"
-
-	AnalyzerErrorsMetric.DeletePartialMatch(map[string]string{
-		"analyzer_name": kind,
-	})
-
+func (StatefulSetAnalyzer) Analyze(a Analyzer) ([]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{}
+	var preAnalysis = map[string]PreAnalysis{}

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

 		// 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),
-								},
-							},
-						})
-					}
-				}
-			}
+			failures = append(failures, fmt.Sprintf("StatefulSet uses the service %s/%s which does not exist.", sts.Namespace, serviceName))
 		}
 		if len(failures) > 0 {
-			preAnalysis[fmt.Sprintf("%s/%s", sts.Namespace, sts.Name)] = common.PreAnalysis{
+			preAnalysis[fmt.Sprintf("%s/%s", sts.Namespace, sts.Name)] = PreAnalysis{
 				StatefulSet:    sts,
 				FailureDetails: failures,
 			}
-			AnalyzerErrorsMetric.WithLabelValues(kind, sts.Name, sts.Namespace).Set(float64(len(failures)))
 		}
 	}

 	for key, value := range preAnalysis {
-		var currentAnalysis = common.Result{
-			Kind:  kind,
+		var currentAnalysis = Result{
+			Kind:  "StatefulSet",
 			Name:  key,
 			Error: value.FailureDetails,
 		}
--- a/pkg/analyzer/statefulset_test.go
+++ b/pkg/analyzer/statefulset_test.go
@@ -4,12 +4,9 @@ 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"
 )
@@ -24,7 +21,7 @@ func TestStatefulSetAnalyzer(t *testing.T) {
 		})
 	statefulSetAnalyzer := StatefulSetAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -51,7 +48,7 @@ func TestStatefulSetAnalyzerWithoutService(t *testing.T) {
 		})
 	statefulSetAnalyzer := StatefulSetAnalyzer{}

-	config := common.Analyzer{
+	config := Analyzer{
 		Client: &kubernetes.Client{
 			Client: clientset,
 		},
@@ -67,7 +64,7 @@ func TestStatefulSetAnalyzerWithoutService(t *testing.T) {

 	for _, analysis := range analysisResults {
 		for _, got := range analysis.Error {
-			if want == got.Text {
+			if want == got {
 				errorFound = true
 			}
 		}
@@ -79,69 +76,3 @@ func TestStatefulSetAnalyzerWithoutService(t *testing.T) {
 		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/analyzer/types.go
+++ b/pkg/analyzer/types.go
@@ -1,9 +1,7 @@
-package common
+package analyzer

 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"
@@ -13,10 +11,6 @@ import (
 	policyv1 "k8s.io/api/policy/v1"
 )

-type IAnalyzer interface {
-	Analyze(analysis Analyzer) ([]Result, error)
-}
-
 type Analyzer struct {
 	Client      *kubernetes.Client
 	Context     context.Context
@@ -28,8 +22,7 @@ type Analyzer struct {

 type PreAnalysis struct {
 	Pod                      v1.Pod
-	FailureDetails           []Failure
-	Deployment               appsv1.Deployment
+	FailureDetails           []string
 	ReplicaSet               appsv1.ReplicaSet
 	PersistentVolumeClaim    v1.PersistentVolumeClaim
 	Endpoint                 v1.Endpoints
@@ -37,26 +30,12 @@ type PreAnalysis struct {
 	HorizontalPodAutoscalers autov1.HorizontalPodAutoscaler
 	PodDisruptionBudget      policyv1.PodDisruptionBudget
 	StatefulSet              appsv1.StatefulSet
-	NetworkPolicy            networkv1.NetworkPolicy
-	Node                     v1.Node
-	// 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
+	Kind         string   `json:"kind"`
+	Name         string   `json:"name"`
+	Error        []string `json:"error"`
+	Details      string   `json:"details"`
+	ParentObject string   `json:"parentObject"`
 }
--- a/pkg/integration/integration.go
+++ b/pkg/integration/integration.go
@@ -1,129 +0,0 @@
-package integration
-
-import (
-	"errors"
-	"os"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/common"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/integration/trivy"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/util"
-	"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")
-	}
-
-	// Update filters
-	activeFilters := viper.GetStringSlice("active_filters")
-
-	mergedFilters := append(activeFilters, integrations[name].GetAnalyzerName())
-
-	uniqueFilters, dupplicatedFilters := util.RemoveDuplicates(mergedFilters)
-
-	// Verify dupplicate
-	if len(dupplicatedFilters) != 0 {
-		color.Red("Integration already activated : %s", strings.Join(dupplicatedFilters, ", "))
-		os.Exit(1)
-	}
-
-	viper.Set("active_filters", uniqueFilters)
-
-	if err := integrations[name].Deploy(namespace); err != nil {
-		return err
-	}
-
-	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")
-	}
-
-	activeFilters := viper.GetStringSlice("active_filters")
-
-	// Update filters
-	// This might be a bad idea, but we cannot reference analyzer here
-	foundFilter := false
-	for i, v := range activeFilters {
-		if v == integrations[name].GetAnalyzerName() {
-			foundFilter = true
-			activeFilters = append(activeFilters[:i], activeFilters[i+1:]...)
-			break
-		}
-	}
-	if !foundFilter {
-		color.Red("Ingregation %s does not exist in configuration file. Please use k8sgpt integration add.", name)
-		os.Exit(1)
-	}
-
-	if err := integrations[name].UnDeploy(namespace); err != nil {
-		return err
-	}
-
-	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,63 +1,36 @@
 package kubernetes

 import (
-	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes"
-	_ "k8s.io/client-go/plugin/pkg/client/auth/oidc"
-	"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
-}
-
-func (c *Client) GetConfig() *rest.Config {
-	return c.Config
+	Client kubernetes.Interface
 }

 func (c *Client) GetClient() kubernetes.Interface {
 	return c.Client
 }

-func (c *Client) GetRestClient() rest.Interface {
-	return c.RestClient
-}
-
 func NewClient(kubecontext string, kubeconfig string) (*Client, error) {
-	var config *rest.Config
-	config, err := rest.InClusterConfig()
-	if err != nil {
-		clientConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
-			&clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig},
-			&clientcmd.ConfigOverrides{
-				CurrentContext: kubecontext,
-			})
-		// create the clientset
-		config, err = clientConfig.ClientConfig()
-		if err != nil {
-			return nil, err
-		}
-	}
-	clientSet, err := kubernetes.NewForConfig(config)
+
+	config := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
+		&clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig},
+		&clientcmd.ConfigOverrides{
+			CurrentContext: kubecontext,
+		})
+	// create the clientset
+	c, err := config.ClientConfig()
 	if err != nil {
 		return nil, err
 	}
-	config.APIPath = "/api"
-	config.GroupVersion = &scheme.Scheme.PrioritizedVersionsForGroup("")[0]
-	config.NegotiatedSerializer = serializer.WithoutConversionCodecFactory{CodecFactory: scheme.Codecs}
-
-	restClient, err := rest.RESTClientFor(config)
+	clientSet, err := kubernetes.NewForConfig(c)
 	if err != nil {
 		return nil, err
 	}

 	return &Client{
-		Client:     clientSet,
-		RestClient: restClient,
-		Config:     config,
+		Client: clientSet,
 	}, nil
 }
--- a/pkg/server/server.go
+++ b/pkg/server/server.go
@@ -1,113 +0,0 @@
-package server
-
-import (
-	json "encoding/json"
-	"fmt"
-	"net/http"
-	"strconv"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/k8sgpt-ai/k8sgpt/pkg/analysis"
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-)
-
-type Config struct {
-	Port    string
-	Backend string
-	Key     string
-	Token   string
-	Output  string
-}
-
-type Health struct {
-	Status  string `json:"status"`
-	Success int    `json:"success"`
-	Failure int    `json:"failure"`
-}
-
-var health = Health{
-	Status:  "ok",
-	Success: 0,
-	Failure: 0,
-}
-
-type Result struct {
-	Analysis []analysis.Analysis `json:"analysis"`
-}
-
-func (s *Config) analyzeHandler(w http.ResponseWriter, r *http.Request) {
-	namespace := r.URL.Query().Get("namespace")
-	explain := getBoolParam(r.URL.Query().Get("explain"))
-	anonymize := getBoolParam(r.URL.Query().Get("anonymize"))
-	nocache := getBoolParam(r.URL.Query().Get("nocache"))
-	language := r.URL.Query().Get("language")
-	s.Output = r.URL.Query().Get("output")
-
-	if s.Output == "" {
-		s.Output = "json"
-	}
-
-	config, err := analysis.NewAnalysis(s.Backend, language, []string{}, namespace, nocache, explain)
-	if err != nil {
-		health.Failure++
-		fmt.Fprintf(w, err.Error())
-	}
-
-	err = config.RunAnalysis()
-	if err != nil {
-		color.Red("Error: %v", err)
-		health.Failure++
-		fmt.Fprintf(w, err.Error())
-	}
-
-	if explain {
-		err := config.GetAIResults(s.Output, anonymize)
-		if err != nil {
-			color.Red("Error: %v", err)
-			health.Failure++
-			fmt.Fprintf(w, err.Error())
-		}
-	}
-
-	out, err := config.PrintOutput(s.Output)
-	if err != nil {
-		color.Red("Error: %v", err)
-		health.Failure++
-		fmt.Fprintf(w, err.Error())
-	}
-
-	health.Success++
-	fmt.Fprintf(w, string(out))
-}
-
-func (s *Config) Serve() error {
-	http.Handle("/metrics", promhttp.Handler())
-	http.HandleFunc("/analyze", s.analyzeHandler)
-	http.HandleFunc("/healthz", s.healthzHandler)
-	color.Green("Starting server on port %s", s.Port)
-	err := http.ListenAndServe(":"+s.Port, nil)
-	if err != nil {
-		fmt.Printf("error starting server: %s\n", err)
-		return err
-	}
-	return nil
-}
-
-func (s *Config) healthzHandler(w http.ResponseWriter, r *http.Request) {
-	js, err := json.MarshalIndent(health, "", "  ")
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	fmt.Fprintf(w, string(js))
-}
-
-func getBoolParam(param string) bool {
-	b, err := strconv.ParseBool(strings.ToLower(param))
-	if err != nil {
-		// Handle error if conversion fails
-		return false
-	}
-	return b
-}
--- a/pkg/util/util.go
+++ b/pkg/util/util.go
@@ -2,30 +2,11 @@ package util

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

 	"github.com/k8sgpt-ai/k8sgpt/pkg/kubernetes"
-	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	k "k8s.io/client-go/kubernetes"
 )

-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 {
@@ -115,60 +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
-}
-
-func GetCacheKey(provider string, sEnc string) string {
-	return fmt.Sprintf("%s-%s", provider, sEnc)
-}
-
-func GetPodListByLabels(client k.Interface,
-	namespace string,
-	labels map[string]string) (*v1.PodList, error) {
-	pods, err := client.CoreV1().Pods(namespace).List(context.Background(), metav1.ListOptions{
-		LabelSelector: metav1.FormatLabelSelector(&metav1.LabelSelector{
-			MatchLabels: labels,
-		}),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return pods, nil
-}
-
-func FileExists(path string) (bool, error) {
-	if _, err := os.Stat(path); err == nil {
-		return true, nil
-	} else if errors.Is(err, os.ErrNotExist) {
-		return false, nil
-	} else {
-		return false, err
-	}
-}
-
-func EnsureDirExists(dir string) error {
-	err := os.Mkdir(dir, 0755)
-
-	if errors.Is(err, os.ErrExist) {
-		return nil
-	}
-
-	return err
-}
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -11,8 +11,7 @@
        "README.md",
        "deploy/manifest.yaml",
        "chart/Chart.yaml",
-        "chart/values.yaml",
-        "container/manifests/deployment.yaml"
+        "chart/values.yaml"
      ],
      "changelog-sections": [
        {
Author	SHA1	Message	Date
AlexsJones	7eba7ff788	chore: removed file Signed-off-by: AlexsJones <alexsimonjones@gmail.com>	2023-04-06 21:40:38 +01:00
AlexsJones	1c0c7bac73	feat: http server Signed-off-by: AlexsJones <alexsimonjones@gmail.com>	2023-04-06 21:35:47 +01:00