aircana 4.4.0 → 5.0.0

data/lib/aircana/cli/commands/kb.rb

@@ -28,40 +28,17 @@ module Aircana
                                default: "e.g., 'Canvas Backend Database', 'API Design'")
           short_description = prompt.ask("Briefly describe what this KB contains:")
 
-          # Prompt for knowledge base type
-          kb_type = prompt.select("Knowledge base type:", [
-                                    {
-                                      name: "Local - Version controlled, no refresh needed",
-                                      value: "local"
-                                    },
-                                    {
-                                      name: "Remote - Fetched from Confluence/web, " \
-                                            "auto-refreshed via SessionStart hook",
-                                      value: "remote"
-                                    }
-                                  ])
-
           normalized_kb_name = normalize_string(kb_name)
 
-          # Prompt for knowledge fetching
-          fetched_confluence = prompt_for_knowledge_fetch(prompt, normalized_kb_name, kb_type, short_description)
+          fetched_confluence = prompt_for_knowledge_fetch(prompt, normalized_kb_name, short_description)
 
-          # Prompt for web URL fetching
-          fetched_urls = prompt_for_url_fetch(prompt, normalized_kb_name, kb_type)
+          fetched_urls = prompt_for_url_fetch(prompt, normalized_kb_name)
 
-          # Generate SKILL.md and agent if no content was fetched during the prompts
-          # (the prompt functions already generate it when they successfully fetch content)
           unless fetched_confluence || fetched_urls
             regenerate_skill_md(normalized_kb_name, short_description)
             regenerate_agent_md(normalized_kb_name)
           end
 
-          # If remote kb_type, ensure SessionStart hook is installed
-          ensure_remote_knowledge_refresh_hook if kb_type == "remote"
-
-          # Ensure gitignore is configured
-          ensure_gitignore_entry(kb_type)
-
           Aircana.human_logger.success "Knowledge base '#{kb_name}' setup complete!"
         end
 
@@ -84,30 +61,23 @@ module Aircana
             exit 1
           end
 
-          # Get kb_type from manifest
-          kb_type = Aircana::Contexts::Manifest.kb_type_from_manifest(normalized_kb_name)
-
           web = Aircana::Contexts::Web.new
-          result = web.fetch_url_for(kb_name: normalized_kb_name, url: url, kb_type: kb_type)
+          result = web.fetch_url_for(kb_name: normalized_kb_name, url: url)
 
           if result
-            # Update manifest with the new URL
             existing_sources = Aircana::Contexts::Manifest.sources_from_manifest(normalized_kb_name)
             web_sources = existing_sources.select { |s| s["type"] == "web" }
             other_sources = existing_sources.reject { |s| s["type"] == "web" }
 
             if web_sources.any?
-              # Add to existing web source
               web_sources.first["urls"] << result
             else
-              # Create new web source
               web_sources = [{ "type" => "web", "urls" => [result] }]
             end
 
             all_sources = other_sources + web_sources
             Aircana::Contexts::Manifest.update_manifest(normalized_kb_name, all_sources)
 
-            # Regenerate SKILL.md and agent
             regenerate_skill_md(normalized_kb_name)
             regenerate_agent_md(normalized_kb_name)
 
@@ -156,9 +126,9 @@ module Aircana
 
         private
 
-        def perform_refresh(normalized_kb_name, kb_type, label: nil)
+        def perform_refresh(normalized_kb_name, label: nil)
           confluence = Aircana::Contexts::Confluence.new
-          result = confluence.fetch_pages_for(kb_name: normalized_kb_name, kb_type: kb_type, label: label)
+          result = confluence.fetch_pages_for(kb_name: normalized_kb_name, label: label)
 
           log_refresh_result(normalized_kb_name, result[:pages_count])
           result
@@ -177,31 +147,26 @@ module Aircana
           total_pages = 0
           all_sources = []
 
-          # Try manifest-based refresh first
           if Aircana::Contexts::Manifest.manifest_exists?(normalized_kb_name)
             Aircana.human_logger.info "Refreshing from knowledge manifest..."
 
-            # Refresh Confluence sources
             confluence = Aircana::Contexts::Confluence.new
             confluence_result = confluence.refresh_from_manifest(kb_name: normalized_kb_name)
             total_pages += confluence_result[:pages_count]
             all_sources.concat(confluence_result[:sources])
 
-            # Refresh web sources
             web = Aircana::Contexts::Web.new
             web_result = web.refresh_web_sources(kb_name: normalized_kb_name)
             total_pages += web_result[:pages_count]
             all_sources.concat(web_result[:sources])
           else
             Aircana.human_logger.info "No manifest found, falling back to label-based search..."
-            kb_type = "remote" # Default to remote if no manifest
             confluence = Aircana::Contexts::Confluence.new
-            confluence_result = confluence.fetch_pages_for(kb_name: normalized_kb_name, kb_type: kb_type)
+            confluence_result = confluence.fetch_pages_for(kb_name: normalized_kb_name)
             total_pages += confluence_result[:pages_count]
             all_sources.concat(confluence_result[:sources])
           end
 
-          # Update manifest with all sources combined
           Aircana::Contexts::Manifest.update_manifest(normalized_kb_name, all_sources) if all_sources.any?
 
           log_refresh_result(normalized_kb_name, total_pages)
@@ -233,86 +198,6 @@ module Aircana
           Aircana.human_logger.warn "Failed to generate agent: #{e.message}"
         end
 
-        def ensure_gitignore_entry(kb_type)
-          gitignore_path = gitignore_file_path
-
-          if kb_type == "remote"
-            # For remote KBs, ensure knowledge files are ignored
-            ensure_remote_knowledge_ignored(gitignore_path)
-          else
-            # For local KBs, ensure skills directory is NOT ignored
-            ensure_local_knowledge_not_ignored(gitignore_path)
-          end
-        rescue StandardError => e
-          Aircana.human_logger.warn "Could not update .gitignore: #{e.message}"
-        end
-
-        def ensure_remote_knowledge_ignored(gitignore_path)
-          pattern = remote_knowledge_pattern
-          return if gitignore_has_pattern?(gitignore_path, pattern)
-
-          append_to_gitignore(gitignore_path, pattern)
-          Aircana.human_logger.success "Added remote knowledge files to .gitignore"
-        end
-
-        def ensure_local_knowledge_not_ignored(gitignore_path)
-          negation_pattern = local_knowledge_negation_pattern
-          return if gitignore_has_pattern?(gitignore_path, negation_pattern)
-
-          # Add comment and negation pattern
-          comment = "# Local KB knowledge IS version controlled (don't ignore)"
-          content_to_append = "\n#{comment}\n#{negation_pattern}\n"
-
-          existing_content = File.exist?(gitignore_path) ? File.read(gitignore_path) : ""
-          needs_newline = !existing_content.empty? && !existing_content.end_with?("\n")
-          content_to_append = "\n#{content_to_append}" if needs_newline
-
-          File.open(gitignore_path, "a") { |f| f.write(content_to_append) }
-          Aircana.human_logger.success "Added local knowledge negation to .gitignore"
-        end
-
-        def gitignore_file_path
-          File.join(Aircana.configuration.project_dir, ".gitignore")
-        end
-
-        def remote_knowledge_pattern
-          # Pattern depends on whether we're in a plugin
-          if Aircana.configuration.plugin_mode?
-            "skills/*/*.md"
-          else
-            ".claude/skills/*/*.md"
-          end
-        end
-
-        def local_knowledge_negation_pattern
-          # Negation pattern depends on whether we're in a plugin
-          if Aircana.configuration.plugin_mode?
-            "!skills/*/*.md"
-          else
-            "!.claude/skills/*/*.md"
-          end
-        end
-
-        def gitignore_has_pattern?(gitignore_path, pattern)
-          return false unless File.exist?(gitignore_path)
-
-          content = File.read(gitignore_path)
-          if content.lines.any? { |line| line.strip == pattern }
-            Aircana.human_logger.info "Pattern '#{pattern}' already in .gitignore"
-            true
-          else
-            false
-          end
-        end
-
-        def append_to_gitignore(gitignore_path, pattern)
-          existing_content = File.exist?(gitignore_path) ? File.read(gitignore_path) : ""
-          content_to_append = existing_content.empty? || existing_content.end_with?("\n") ? "" : "\n"
-          content_to_append += "#{pattern}\n"
-
-          File.open(gitignore_path, "a") { |f| f.write(content_to_append) }
-        end
-
         def log_no_pages_found(normalized_kb_name)
           Aircana.human_logger.info "No pages found for KB '#{normalized_kb_name}'. " \
                                     "Make sure pages are labeled with '#{normalized_kb_name}' in Confluence."
@@ -327,15 +212,13 @@ module Aircana
           string.strip.downcase.gsub(" ", "-")
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        # rubocop:disable Metrics/PerceivedComplexity
-        def prompt_for_knowledge_fetch(prompt, normalized_kb_name, kb_type, short_description)
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
+        def prompt_for_knowledge_fetch(prompt, normalized_kb_name, short_description)
           return false unless confluence_configured?
 
           if prompt.yes?("Would you like to fetch knowledge for this KB from Confluence now?")
             Aircana.human_logger.info "Fetching knowledge from Confluence..."
 
-            # Optionally ask for custom label
             use_custom_label = prompt.yes?("Use a custom Confluence label? (default: #{normalized_kb_name})")
             label = if use_custom_label
                       prompt.ask("Enter Confluence label:")
@@ -343,41 +226,28 @@ module Aircana
                       normalized_kb_name
                     end
 
-            result = perform_refresh(normalized_kb_name, kb_type, label: label)
+            result = perform_refresh(normalized_kb_name, label: label)
             if result[:pages_count]&.positive?
-              ensure_gitignore_entry(kb_type)
               regenerate_skill_md(normalized_kb_name, short_description)
               regenerate_agent_md(normalized_kb_name)
               return true
             end
           else
-            refresh_message = if kb_type == "local"
-                                "fetch knowledge"
-                              else
-                                "run 'aircana kb refresh #{normalized_kb_name}'"
-                              end
             Aircana.human_logger.info(
-              "Skipping knowledge fetch. You can #{refresh_message} later."
+              "Skipping knowledge fetch. You can run 'aircana kb refresh #{normalized_kb_name}' later."
             )
           end
 
           false
         rescue Aircana::Error => e
           Aircana.human_logger.warn "Failed to fetch knowledge: #{e.message}"
-          refresh_message = if kb_type == "local"
-                              "fetch knowledge"
-                            else
-                              "try again later with 'aircana kb refresh #{normalized_kb_name}'"
-                            end
-          Aircana.human_logger.info "You can #{refresh_message}"
+          Aircana.human_logger.info "You can try again later with 'aircana kb refresh #{normalized_kb_name}'"
           false
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        # rubocop:disable Metrics/PerceivedComplexity
-        def prompt_for_url_fetch(prompt, normalized_kb_name, kb_type)
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def prompt_for_url_fetch(prompt, normalized_kb_name)
           return false unless prompt.yes?("Would you like to add web URLs for this KB's knowledge base?")
 
           urls = []
@@ -398,11 +268,10 @@ module Aircana
           begin
             Aircana.human_logger.info "Fetching #{urls.size} URL(s)..."
             web = Aircana::Contexts::Web.new
-            result = web.fetch_urls_for(kb_name: normalized_kb_name, urls: urls, kb_type: kb_type)
+            result = web.fetch_urls_for(kb_name: normalized_kb_name, urls: urls)
 
             if result[:pages_count].positive?
               Aircana.human_logger.success "Successfully fetched #{result[:pages_count]} URL(s)"
-              ensure_gitignore_entry(kb_type)
               regenerate_skill_md(normalized_kb_name)
               regenerate_agent_md(normalized_kb_name)
               return true
@@ -418,8 +287,7 @@ module Aircana
 
           false
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         # rubocop:disable Metrics/AbcSize
         def confluence_configured?
@@ -447,17 +315,12 @@ module Aircana
         def print_kbs_list(kb_folders)
           Aircana.human_logger.info("Configured knowledge bases:")
           kb_folders.each_with_index do |kb_name, index|
-            kb_type = get_kb_type(kb_name)
             sources_count = get_sources_count(kb_name)
-            Aircana.human_logger.info("  #{index + 1}. #{kb_name} (#{kb_type}, #{sources_count} sources)")
+            Aircana.human_logger.info("  #{index + 1}. #{kb_name} (#{sources_count} sources)")
           end
           Aircana.human_logger.info("\nTotal: #{kb_folders.length} knowledge bases")
         end
 
-        def get_kb_type(kb_name)
-          Aircana::Contexts::Manifest.kb_type_from_manifest(kb_name) || "unknown"
-        end
-
         def get_sources_count(kb_name)
           sources = Aircana::Contexts::Manifest.sources_from_manifest(kb_name)
           sources.size
@@ -528,63 +391,6 @@ module Aircana
           Aircana.human_logger.info ""
         end
         # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        def ensure_remote_knowledge_refresh_hook
-          hooks_manifest = Aircana::HooksManifest.new(Aircana.configuration.plugin_root)
-
-          # Check if refresh hook already exists
-          current_hooks = hooks_manifest.read || {}
-          session_start_hooks = current_hooks["SessionStart"] || []
-
-          # Check if our refresh script already exists
-          refresh_hook_exists = session_start_hooks.any? do |hook_group|
-            hook_group["hooks"]&.any? { |h| h["command"]&.include?("refresh_remote_kbs.sh") }
-          end
-
-          return if refresh_hook_exists
-
-          # Generate the refresh script
-          generate_refresh_script
-
-          # Add hook to manifest
-          hook_entry = {
-            "type" => "command",
-            "command" => "${CLAUDE_PLUGIN_ROOT}/scripts/refresh_remote_kbs.sh"
-          }
-
-          hooks_manifest.add_hook(event: "SessionStart", hook_entry: hook_entry)
-          Aircana.human_logger.success "Added SessionStart hook to refresh remote knowledge bases"
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-
-        # rubocop:disable Metrics/MethodLength
-        def generate_refresh_script
-          script_path = File.join(Aircana.configuration.scripts_dir, "refresh_remote_kbs.sh")
-          return if File.exist?(script_path)
-
-          script_content = <<~BASH
-            #!/bin/bash
-            # Auto-generated by Aircana
-            # Refreshes all remote knowledge bases from Confluence/web sources
-
-            cd "${CLAUDE_PLUGIN_ROOT}" || exit 1
-
-            # Only refresh if aircana is available
-            if ! command -v aircana &> /dev/null; then
-              echo "Aircana not found, skipping KB refresh"
-              exit 0
-            fi
-
-            # Refresh all remote KBs silently
-            aircana kb refresh-all 2>&1 | grep -E "(Successful|Failed|Error)" || true
-          BASH
-
-          FileUtils.mkdir_p(Aircana.configuration.scripts_dir)
-          File.write(script_path, script_content)
-          File.chmod(0o755, script_path)
-        end
-        # rubocop:enable Metrics/MethodLength
       end
     end
   end

data/lib/aircana/contexts/confluence.rb

@@ -24,7 +24,7 @@ module Aircana
         @local_storage = Local.new
       end
 
-      def fetch_pages_for(kb_name:, kb_type: "local", label: nil)
+      def fetch_pages_for(kb_name:, label: nil)
         validate_configuration!
         setup_httparty
 
@@ -32,15 +32,14 @@ module Aircana
         pages = search_and_log_pages(label_to_search)
         return { pages_count: 0, sources: [] } if pages.empty?
 
-        sources = process_pages_with_manifest(pages, kb_name, kb_type, label_to_search)
-        create_or_update_manifest(kb_name, sources, kb_type)
+        sources = process_pages_with_manifest(pages, kb_name, label_to_search)
+        create_or_update_manifest(kb_name, sources)
 
         { pages_count: pages.size, sources: sources }
       end
 
       def refresh_from_manifest(kb_name:)
         sources = Manifest.sources_from_manifest(kb_name)
-        kb_type = Manifest.kb_type_from_manifest(kb_name)
         return { pages_count: 0, sources: [] } if sources.empty?
 
         validate_configuration!
@@ -53,7 +52,6 @@ module Aircana
         labels_used = []
 
         confluence_sources.each do |source|
-          # Use label from manifest if available, otherwise fall back to kb_name
           label = source["label"] || kb_name
           labels_used << label
           pages = fetch_pages_by_label(label)
@@ -62,8 +60,7 @@ module Aircana
 
         return { pages_count: 0, sources: [] } if all_pages.empty?
 
-        # Use the first label for metadata (typically there's only one Confluence source per KB)
-        updated_sources = process_pages_with_manifest(all_pages, kb_name, kb_type, labels_used.first)
+        updated_sources = process_pages_with_manifest(all_pages, kb_name, labels_used.first)
 
         { pages_count: all_pages.size, sources: updated_sources }
       end
@@ -76,17 +73,17 @@ module Aircana
         pages
       end
 
-      def process_pages(pages, kb_name, kb_type = "local")
+      def process_pages(pages, kb_name)
         ProgressTracker.with_batch_progress(pages, "Processing pages") do |page, _index|
-          store_page_as_markdown(page, kb_name, kb_type)
+          store_page_as_markdown(page, kb_name)
         end
       end
 
-      def process_pages_with_manifest(pages, kb_name, kb_type = "local", label = nil)
+      def process_pages_with_manifest(pages, kb_name, label = nil)
         page_metadata = []
 
         ProgressTracker.with_batch_progress(pages, "Processing pages") do |page, _index|
-          store_page_as_markdown(page, kb_name, kb_type)
+          store_page_as_markdown(page, kb_name)
           page_metadata << extract_page_metadata(page)
         end
 
@@ -145,11 +142,11 @@ module Aircana
         [source]
       end
 
-      def create_or_update_manifest(kb_name, sources, kb_type = "local")
+      def create_or_update_manifest(kb_name, sources)
         if Manifest.manifest_exists?(kb_name)
-          Manifest.update_manifest(kb_name, sources, kb_type: kb_type)
+          Manifest.update_manifest(kb_name, sources)
         else
-          Manifest.create_manifest(kb_name, sources, kb_type: kb_type)
+          Manifest.create_manifest(kb_name, sources)
         end
       end
 

data/lib/aircana/contexts/confluence_content.rb

@@ -64,15 +64,14 @@ module Aircana
         Aircana.human_logger.info "Found #{count} pages for KB '#{kb_name}'"
       end
 
-      def store_page_as_markdown(page, kb_name, kb_type = "local")
+      def store_page_as_markdown(page, kb_name)
         content = page&.dig("body", "storage", "value") || fetch_page_content(page&.[]("id"))
         markdown_content = convert_to_markdown(content)
 
         @local_storage.store_content(
           title: page&.[]("title"),
           content: markdown_content,
-          kb_name: kb_name,
-          kb_type: kb_type
+          kb_name: kb_name
         )
       end
     end

data/lib/aircana/contexts/local.rb

@@ -5,7 +5,7 @@ require "fileutils"
 module Aircana
   module Contexts
     class Local
-      def store_content(title:, content:, kb_name:, kb_type: "local") # rubocop:disable Lint/UnusedMethodArgument
+      def store_content(title:, content:, kb_name:)
         kb_dir = create_kb_dir(kb_name)
         filename = sanitize_filename(title)
         filepath = File.join(kb_dir, "#{filename}.md")

data/lib/aircana/contexts/manifest.rb

@@ -7,36 +7,32 @@ module Aircana
   module Contexts
     class Manifest
       class << self
-        def create_manifest(kb_name, sources, kb_type: "local")
+        def create_manifest(kb_name, sources)
           validate_sources(sources)
-          validate_kb_type(kb_type)
 
           manifest_path = manifest_path_for(kb_name)
-          manifest_data = build_manifest_data(kb_name, sources, kb_type)
+          manifest_data = build_manifest_data(kb_name, sources)
 
           FileUtils.mkdir_p(File.dirname(manifest_path))
           File.write(manifest_path, JSON.pretty_generate(manifest_data))
 
-          Aircana.human_logger.info "Created knowledge manifest for '#{kb_name}' (kb_type: #{kb_type})"
+          Aircana.human_logger.info "Created knowledge manifest for '#{kb_name}'"
           manifest_path
         end
 
-        def update_manifest(kb_name, sources, kb_type: nil)
+        def update_manifest(kb_name, sources)
           validate_sources(sources)
 
           manifest_path = manifest_path_for(kb_name)
 
           if File.exist?(manifest_path)
             existing_data = JSON.parse(File.read(manifest_path))
-            # Preserve existing kb_type unless explicitly provided
-            kb_type_to_use = kb_type || existing_data["kb_type"] || "local"
-            manifest_data = existing_data.merge({ "sources" => sources, "kb_type" => kb_type_to_use })
+            manifest_data = existing_data.merge({ "sources" => sources })
+            manifest_data.delete("kb_type")
           else
-            kb_type_to_use = kb_type || "local"
-            manifest_data = build_manifest_data(kb_name, sources, kb_type_to_use)
+            manifest_data = build_manifest_data(kb_name, sources)
           end
 
-          validate_kb_type(manifest_data["kb_type"])
           FileUtils.mkdir_p(File.dirname(manifest_path))
           File.write(manifest_path, JSON.pretty_generate(manifest_data))
           manifest_path
@@ -66,13 +62,6 @@ module Aircana
           manifest["sources"] || []
         end
 
-        def kb_type_from_manifest(kb_name)
-          manifest = read_manifest(kb_name)
-          return "local" unless manifest
-
-          manifest["kb_type"] || "local"
-        end
-
         def manifest_exists?(kb_name)
           File.exist?(manifest_path_for(kb_name))
         end
@@ -88,11 +77,10 @@ module Aircana
           File.join(Aircana.configuration.kb_knowledge_dir, kb_name)
         end
 
-        def build_manifest_data(kb_name, sources, kb_type = "local")
+        def build_manifest_data(kb_name, sources)
           {
             "version" => "1.0",
             "name" => kb_name,
-            "kb_type" => kb_type,
             "sources" => sources
           }
         end
@@ -108,10 +96,6 @@ module Aircana
             raise ManifestError, "Unsupported manifest version: #{manifest_data["version"]}"
           end
 
-          # kb_type is optional for backward compatibility, defaults to "local"
-          kb_type = manifest_data["kb_type"] || "local"
-          validate_kb_type(kb_type)
-
           validate_sources(manifest_data["sources"])
         end
 
@@ -175,13 +159,6 @@ module Aircana
 
           raise ManifestError, "URL entry missing required field: summary" unless url_entry.key?("summary")
         end
-
-        def validate_kb_type(kb_type)
-          valid_types = %w[remote local]
-          return if valid_types.include?(kb_type)
-
-          raise ManifestError, "Invalid kb_type: #{kb_type}. Must be one of: #{valid_types.join(", ")}"
-        end
       end
     end
 

data/lib/aircana/contexts/web.rb

@@ -22,11 +22,11 @@ module Aircana
         @local_storage = Local.new
       end
 
-      def fetch_url_for(kb_name:, url:, kb_type: "local")
+      def fetch_url_for(kb_name:, url:)
         validate_url!(url)
 
         page_data = fetch_and_process_url(url)
-        store_page_as_markdown(page_data, kb_name, kb_type)
+        store_page_as_markdown(page_data, kb_name)
 
         build_url_metadata(page_data)
       rescue StandardError => e
@@ -34,14 +34,14 @@ module Aircana
         nil
       end
 
-      def fetch_urls_for(kb_name:, urls:, kb_type: "local") # rubocop:disable Metrics/MethodLength
+      def fetch_urls_for(kb_name:, urls:) # rubocop:disable Metrics/MethodLength
         return { pages_count: 0, sources: [] } if urls.empty?
 
         pages_metadata = []
         successful_urls = []
 
         ProgressTracker.with_batch_progress(urls, "Fetching URLs") do |url, _index|
-          metadata = fetch_url_for(kb_name: kb_name, url: url, kb_type: kb_type)
+          metadata = fetch_url_for(kb_name: kb_name, url: url)
           if metadata
             pages_metadata << metadata
             successful_urls << url
@@ -50,7 +50,7 @@ module Aircana
 
         if successful_urls.any?
           sources = build_sources_metadata(successful_urls, pages_metadata)
-          update_or_create_manifest(kb_name, sources, kb_type)
+          update_or_create_manifest(kb_name, sources)
           { pages_count: successful_urls.size, sources: sources }
         else
           { pages_count: 0, sources: [] }
@@ -59,7 +59,6 @@ module Aircana
 
       def refresh_web_sources(kb_name:) # rubocop:disable Metrics/CyclomaticComplexity
         sources = Manifest.sources_from_manifest(kb_name)
-        kb_type = Manifest.kb_type_from_manifest(kb_name)
         web_sources = sources.select { |s| s["type"] == "web" }
 
         return { pages_count: 0, sources: [] } if web_sources.empty?
@@ -67,7 +66,7 @@ module Aircana
         all_urls = web_sources.flat_map { |source| source["urls"]&.map { |u| u["url"] } || [] }
         return { pages_count: 0, sources: [] } if all_urls.empty?
 
-        fetch_urls_for(kb_name: kb_name, urls: all_urls, kb_type: kb_type)
+        fetch_urls_for(kb_name: kb_name, urls: all_urls)
       end
 
       private
@@ -201,12 +200,11 @@ module Aircana
         extract_text_content(html)
       end
 
-      def store_page_as_markdown(page_data, kb_name, kb_type = "local")
+      def store_page_as_markdown(page_data, kb_name)
         @local_storage.store_content(
           title: page_data[:title],
           content: page_data[:content],
-          kb_name: kb_name,
-          kb_type: kb_type
+          kb_name: kb_name
         )
       end
 
@@ -255,17 +253,16 @@ module Aircana
         ]
       end
 
-      def update_or_create_manifest(kb_name, new_sources, kb_type = "local")
+      def update_or_create_manifest(kb_name, new_sources)
         existing_sources = Manifest.sources_from_manifest(kb_name)
 
-        # Remove existing web sources and add new ones
         other_sources = existing_sources.reject { |s| s["type"] == "web" }
         all_sources = other_sources + new_sources
 
         if Manifest.manifest_exists?(kb_name)
-          Manifest.update_manifest(kb_name, all_sources, kb_type: kb_type)
+          Manifest.update_manifest(kb_name, all_sources)
         else
-          Manifest.create_manifest(kb_name, all_sources, kb_type: kb_type)
+          Manifest.create_manifest(kb_name, all_sources)
         end
       end