aircana 3.0.0.rc8 → 3.1.0

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

@@ -15,12 +15,20 @@ module Aircana
       class << self # rubocop:disable Metrics/ClassLength
         def refresh(agent)
           normalized_agent = normalize_string(agent)
+
+          # Check if this is a local knowledge base agent
+          kb_type = Aircana::Contexts::Manifest.kb_type_from_manifest(normalized_agent)
+          if kb_type == "local"
+            Aircana.human_logger.info "⊘ Skipping #{normalized_agent} (local knowledge base - no refresh needed)"
+            return
+          end
+
           perform_manifest_aware_refresh(normalized_agent)
         rescue Aircana::Error => e
           handle_refresh_error(normalized_agent, e)
         end
 
-        def create # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def create
           prompt = TTY::Prompt.new
 
           agent_name = prompt.ask("Agent name:")
@@ -28,6 +36,20 @@ module Aircana
           model = prompt.select("Select a model for your agent:", SUPPORTED_CLAUDE_MODELS)
           color = prompt.select("Select a color for your agent:", SUPPORTED_CLAUDE_COLORS)
 
+          # Prompt for knowledge base type
+          kb_type = prompt.select("Knowledge base type:", [
+                                    {
+                                      name: "Remote - Stored in ~/.claude/agents/, not version controlled, " \
+                                            "requires refresh",
+                                      value: "remote"
+                                    },
+                                    {
+                                      name: "Local - Stored in agents/<name>/knowledge/, version controlled, " \
+                                            "no refresh needed",
+                                      value: "local"
+                                    }
+                                  ])
+
           description = description_from_claude(short_description)
           normalized_agent_name = normalize_string(agent_name)
 
@@ -36,16 +58,17 @@ module Aircana
             description:,
             short_description:,
             model: normalize_string(model),
-            color: normalize_string(color)
+            color: normalize_string(color),
+            kb_type:
           ).generate
 
           Aircana.human_logger.success "Agent created at #{file}"
 
           # Prompt for knowledge fetching
-          prompt_for_knowledge_fetch(prompt, normalized_agent_name)
+          prompt_for_knowledge_fetch(prompt, normalized_agent_name, kb_type)
 
           # Prompt for web URL fetching
-          prompt_for_url_fetch(prompt, normalized_agent_name)
+          prompt_for_url_fetch(prompt, normalized_agent_name, kb_type)
 
           # Prompt for agent file review
           prompt_for_agent_review(prompt, file)
@@ -63,7 +86,7 @@ module Aircana
           print_agents_list(agent_folders)
         end
 
-        def add_url(agent, url) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+        def add_url(agent, url)
           normalized_agent = normalize_string(agent)
 
           unless agent_exists?(normalized_agent)
@@ -71,8 +94,11 @@ module Aircana
             exit 1
           end
 
+          # Get kb_type from manifest to know where to store
+          kb_type = Aircana::Contexts::Manifest.kb_type_from_manifest(normalized_agent)
+
           web = Aircana::Contexts::Web.new
-          result = web.fetch_url_for(agent: normalized_agent, url: url)
+          result = web.fetch_url_for(agent: normalized_agent, url: url, kb_type: kb_type)
 
           if result
             # Update manifest with the new URL
@@ -101,7 +127,7 @@ module Aircana
           exit 1
         end
 
-        def refresh_all # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def refresh_all
           agent_names = all_agents
 
           if agent_names.empty?
@@ -115,11 +141,22 @@ module Aircana
             total: agent_names.size,
             successful: 0,
             failed: 0,
+            skipped: 0,
             total_pages: 0,
-            failed_agents: []
+            failed_agents: [],
+            skipped_agents: []
           }
 
           agent_names.each do |agent_name|
+            # Check if this is a local knowledge base agent
+            kb_type = Aircana::Contexts::Manifest.kb_type_from_manifest(agent_name)
+            if kb_type == "local"
+              Aircana.human_logger.info "⊘ Skipping #{agent_name} (local knowledge base)"
+              results[:skipped] += 1
+              results[:skipped_agents] << agent_name
+              next
+            end
+
             result = refresh_single_agent(agent_name)
             if result[:success]
               results[:successful] += 1
@@ -133,11 +170,56 @@ module Aircana
           print_refresh_all_summary(results)
         end
 
+        def migrate_to_local
+          agent_names = all_agents
+
+          if agent_names.empty?
+            Aircana.human_logger.info "No agents found to migrate."
+            return
+          end
+
+          # Filter to only remote agents
+          remote_agents = agent_names.select do |agent_name|
+            Aircana::Contexts::Manifest.kb_type_from_manifest(agent_name) == "remote"
+          end
+
+          if remote_agents.empty?
+            Aircana.human_logger.info "No remote agents found. All agents are already using local knowledge bases."
+            return
+          end
+
+          Aircana.human_logger.warn "⚠️  This will migrate #{remote_agents.size} agent(s) to local knowledge bases."
+          Aircana.human_logger.warn "Knowledge will be version-controlled and stored in " \
+                                    ".claude/agents/<agent>/knowledge/"
+          Aircana.human_logger.info ""
+
+          results = {
+            total: remote_agents.size,
+            successful: 0,
+            failed: 0,
+            migrated_agents: [],
+            failed_agents: []
+          }
+
+          remote_agents.each do |agent_name|
+            result = migrate_single_agent(agent_name)
+            if result[:success]
+              results[:successful] += 1
+              results[:migrated_agents] << agent_name
+            else
+              results[:failed] += 1
+              results[:failed_agents] << { name: agent_name, error: result[:error] }
+            end
+          end
+
+          print_migration_summary(results)
+        end
+
         private
 
-        def perform_refresh(normalized_agent)
+        def perform_refresh(normalized_agent, kb_type = "remote")
           confluence = Aircana::Contexts::Confluence.new
-          result = confluence.fetch_pages_for(agent: normalized_agent)
+          result = confluence.fetch_pages_for(agent: normalized_agent, kb_type: kb_type)
 
           log_refresh_result(normalized_agent, result[:pages_count])
           result
@@ -151,7 +233,7 @@ module Aircana
           end
         end
 
-        def perform_manifest_aware_refresh(normalized_agent) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def perform_manifest_aware_refresh(normalized_agent)
           total_pages = 0
           all_sources = []
 
@@ -185,7 +267,10 @@ module Aircana
           { pages_count: total_pages, sources: all_sources }
         end
 
-        def ensure_gitignore_entry
+        def ensure_gitignore_entry(kb_type = "remote")
+          # Only add to gitignore for remote knowledge bases
+          return if kb_type == "local"
+
           gitignore_path = gitignore_file_path
           pattern = gitignore_pattern
 
@@ -263,24 +348,34 @@ module Aircana
           PROMPT
         end
 
-        def prompt_for_knowledge_fetch(prompt, normalized_agent_name) # rubocop:disable Metrics/MethodLength
+        def prompt_for_knowledge_fetch(prompt, normalized_agent_name, kb_type)
           return unless confluence_configured?
 
           if prompt.yes?("Would you like to fetch knowledge for this agent from Confluence now?")
             Aircana.human_logger.info "Fetching knowledge from Confluence..."
-            result = perform_refresh(normalized_agent_name)
-            ensure_gitignore_entry if result[:pages_count]&.positive?
+            result = perform_refresh(normalized_agent_name, kb_type)
+            ensure_gitignore_entry(kb_type) if result[:pages_count]&.positive?
           else
+            refresh_message = if kb_type == "local"
+                                "fetch knowledge"
+                              else
+                                "run 'aircana agents refresh #{normalized_agent_name}'"
+                              end
             Aircana.human_logger.info(
-              "Skipping knowledge fetch. You can run 'aircana agents refresh #{normalized_agent_name}' later."
+              "Skipping knowledge fetch. You can #{refresh_message} later."
             )
           end
         rescue Aircana::Error => e
           Aircana.human_logger.warn "Failed to fetch knowledge: #{e.message}"
-          Aircana.human_logger.info "You can try again later with 'aircana agents refresh #{normalized_agent_name}'"
+          refresh_message = if kb_type == "local"
+                              "fetch knowledge"
+                            else
+                              "try again later with 'aircana agents refresh #{normalized_agent_name}'"
+                            end
+          Aircana.human_logger.info "You can #{refresh_message}"
         end
 
-        def prompt_for_url_fetch(prompt, normalized_agent_name) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def prompt_for_url_fetch(prompt, normalized_agent_name, kb_type)
           return unless prompt.yes?("Would you like to add web URLs for this agent's knowledge base?")
 
           urls = []
@@ -301,11 +396,11 @@ module Aircana
           begin
             Aircana.human_logger.info "Fetching #{urls.size} URL(s)..."
             web = Aircana::Contexts::Web.new
-            result = web.fetch_urls_for(agent: normalized_agent_name, urls: urls)
+            result = web.fetch_urls_for(agent: normalized_agent_name, urls: urls, kb_type: kb_type)
 
             if result[:pages_count].positive?
               Aircana.human_logger.success "Successfully fetched #{result[:pages_count]} URL(s)"
-              ensure_gitignore_entry
+              ensure_gitignore_entry(kb_type)
             else
               Aircana.human_logger.warn "No URLs were successfully fetched"
             end
@@ -325,7 +420,7 @@ module Aircana
           open_file_in_editor(file_path)
         end
 
-        def confluence_configured? # rubocop:disable Metrics/AbcSize
+        def confluence_configured?
           config = Aircana.configuration
 
           base_url_present = !config.confluence_base_url.nil? && !config.confluence_base_url.empty?
@@ -401,7 +496,7 @@ module Aircana
           find_agent_folders(agent_dir)
         end
 
-        def refresh_single_agent(agent_name) # rubocop:disable Metrics/MethodLength
+        def refresh_single_agent(agent_name)
           Aircana.human_logger.info "Refreshing agent '#{agent_name}'..."
 
           begin
@@ -422,12 +517,125 @@ module Aircana
           end
         end
 
-        def print_refresh_all_summary(results) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def print_refresh_all_summary(results)
           Aircana.human_logger.info ""
           Aircana.human_logger.info "=== Refresh All Summary ==="
           Aircana.human_logger.success "✓ Successful: #{results[:successful]}/#{results[:total]} agents"
           Aircana.human_logger.success "✓ Total pages refreshed: #{results[:total_pages]}"
 
+          if results[:skipped].positive?
+            Aircana.human_logger.info "⊘ Skipped: #{results[:skipped]} agent(s) (local knowledge base)"
+          end
+
+          if results[:failed].positive?
+            Aircana.human_logger.error "✗ Failed: #{results[:failed]} agents"
+            Aircana.human_logger.info ""
+            Aircana.human_logger.info "Failed agents:"
+            results[:failed_agents].each do |failed_agent|
+              Aircana.human_logger.error "  - #{failed_agent[:name]}: #{failed_agent[:error]}"
+            end
+          end
+
+          Aircana.human_logger.info ""
+        end
+
+        def migrate_single_agent(agent_name)
+          Aircana.human_logger.info "Migrating agent '#{agent_name}'..."
+
+          begin
+            # Step 1: Refresh knowledge from sources to ensure we have latest
+            Aircana.human_logger.info "  Refreshing knowledge from sources..."
+            perform_manifest_aware_refresh(agent_name)
+
+            # Step 2: Copy knowledge files from global to local directory
+            Aircana.human_logger.info "  Copying knowledge files to local directory..."
+            copy_knowledge_files(agent_name)
+
+            # Step 3: Update manifest kb_type to "local"
+            Aircana.human_logger.info "  Updating manifest..."
+            sources = Aircana::Contexts::Manifest.sources_from_manifest(agent_name)
+            Aircana::Contexts::Manifest.update_manifest(agent_name, sources, kb_type: "local")
+
+            # Step 4: Regenerate agent file with new kb_type
+            Aircana.human_logger.info "  Regenerating agent file..."
+            regenerate_agent_file(agent_name)
+
+            Aircana.human_logger.success "✓ Successfully migrated '#{agent_name}'"
+            { success: true }
+          rescue StandardError => e
+            Aircana.human_logger.error "✗ Failed to migrate agent '#{agent_name}': #{e.message}"
+            { success: false, error: e.message }
+          end
+        end
+
+        def copy_knowledge_files(agent_name)
+          config = Aircana.configuration
+          source_dir = config.global_agent_knowledge_path(agent_name)
+          dest_dir = config.local_agent_knowledge_path(agent_name)
+
+          unless Dir.exist?(source_dir)
+            Aircana.human_logger.warn "    No knowledge files found at #{source_dir}"
+            return
+          end
+
+          FileUtils.mkdir_p(dest_dir)
+
+          # Copy all markdown files
+          Dir.glob(File.join(source_dir, "*.md")).each do |file|
+            filename = File.basename(file)
+            dest_file = File.join(dest_dir, filename)
+            FileUtils.cp(file, dest_file)
+            Aircana.human_logger.info "    Copied #{filename}"
+          end
+        end
+
+        def regenerate_agent_file(agent_name)
+          # Read existing agent file to get metadata
+          agent_file_path = File.join(Aircana.configuration.agents_dir, "#{agent_name}.md")
+          unless File.exist?(agent_file_path)
+            Aircana.human_logger.warn "    Agent file not found at #{agent_file_path}, skipping regeneration"
+            return
+          end
+
+          # Parse frontmatter to get agent metadata
+          content = File.read(agent_file_path)
+          frontmatter_match = content.match(/^---\n(.*?)\n---\n(.*)$/m)
+          return unless frontmatter_match
+
+          frontmatter = frontmatter_match[1]
+          description = frontmatter_match[2]
+
+          # Parse YAML-like frontmatter
+          metadata = {}
+          frontmatter.lines.each do |line|
+            key, value = line.strip.split(":", 2)
+            metadata[key.strip] = value&.strip
+          end
+
+          # Generate new agent file with kb_type="local"
+          Generators::AgentsGenerator.new(
+            agent_name: agent_name,
+            description: description,
+            short_description: metadata["description"],
+            model: metadata["model"],
+            color: metadata["color"],
+            kb_type: "local"
+          ).generate
+        end
+
+        def print_migration_summary(results)
+          Aircana.human_logger.info ""
+          Aircana.human_logger.info "=== Migration Summary ==="
+          Aircana.human_logger.success "✓ Successfully migrated: #{results[:successful]}/#{results[:total]} agents"
+
+          if results[:successful].positive?
+            Aircana.human_logger.info ""
+            Aircana.human_logger.info "Migrated agents:"
+            results[:migrated_agents].each do |agent_name|
+              Aircana.human_logger.success "  ✓ #{agent_name}"
+            end
+          end
+
           if results[:failed].positive?
             Aircana.human_logger.error "✗ Failed: #{results[:failed]} agents"
             Aircana.human_logger.info ""
@@ -437,6 +645,12 @@ module Aircana
             end
           end
 
+          if results[:successful].positive?
+            Aircana.human_logger.info ""
+            Aircana.human_logger.warn "⚠️  Knowledge is now version-controlled in .claude/agents/<agent>/knowledge/"
+            Aircana.human_logger.info "Review and commit these changes to your repository."
+          end
+
           Aircana.human_logger.info ""
         end
       end

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

@@ -25,6 +25,7 @@ module Aircana
         end
 
         def run
+          clean_output_directories
           generators.each(&:generate)
           generate_default_agents
           generate_default_hooks
@@ -33,6 +34,16 @@ module Aircana
 
         private
 
+        def clean_output_directories
+          # Remove stale command files to prevent duplicates during init
+          commands_dir = File.join(Aircana.configuration.output_dir, "commands")
+          FileUtils.rm_rf(Dir.glob("#{commands_dir}/*")) if Dir.exist?(commands_dir)
+
+          # Remove stale agent files for consistency
+          agents_dir = File.join(Aircana.configuration.output_dir, "agents")
+          FileUtils.rm_rf(Dir.glob("#{agents_dir}/*")) if Dir.exist?(agents_dir)
+        end
+
         def generate_default_agents
           Aircana::Generators::AgentsGenerator.available_default_agents.each do |agent_name|
             Aircana::Generators::AgentsGenerator.create_default_agent(agent_name)

data/lib/aircana/configuration.rb

@@ -54,6 +54,25 @@ module Aircana
       File.join(@global_agents_dir, "#{plugin_name}-#{agent_name}", "knowledge")
     end
 
+    # Returns the local knowledge directory path for an agent
+    # Format: <plugin-root>/agents/<agent-name>/knowledge/
+    def local_agent_knowledge_path(agent_name)
+      File.join(@agents_dir, agent_name, "knowledge")
+    end
+
+    # Returns the appropriate knowledge directory path based on kb_type
+    # kb_type can be "remote" or "local"
+    def agent_knowledge_path(agent_name, kb_type)
+      case kb_type
+      when "local"
+        local_agent_knowledge_path(agent_name)
+      when "remote"
+        global_agent_knowledge_path(agent_name)
+      else
+        raise ArgumentError, "Invalid kb_type: #{kb_type}. Must be 'remote' or 'local'"
+      end
+    end
+
     private
 
     def setup_directory_paths

data/lib/aircana/contexts/confluence.rb

@@ -24,21 +24,22 @@ module Aircana
         @local_storage = Local.new
       end
 
-      def fetch_pages_for(agent:)
+      def fetch_pages_for(agent:, kb_type: "remote")
         validate_configuration!
         setup_httparty
 
         pages = search_and_log_pages(agent)
         return { pages_count: 0, sources: [] } if pages.empty?
 
-        sources = process_pages_with_manifest(pages, agent)
-        create_or_update_manifest(agent, sources)
+        sources = process_pages_with_manifest(pages, agent, kb_type)
+        create_or_update_manifest(agent, sources, kb_type)
 
         { pages_count: pages.size, sources: sources }
       end
 
       def refresh_from_manifest(agent:)
         sources = Manifest.sources_from_manifest(agent)
+        kb_type = Manifest.kb_type_from_manifest(agent)
         return { pages_count: 0, sources: [] } if sources.empty?
 
         validate_configuration!
@@ -55,7 +56,7 @@ module Aircana
 
         return { pages_count: 0, sources: [] } if all_pages.empty?
 
-        updated_sources = process_pages_with_manifest(all_pages, agent)
+        updated_sources = process_pages_with_manifest(all_pages, agent, kb_type)
 
         { pages_count: all_pages.size, sources: updated_sources }
       end
@@ -68,17 +69,17 @@ module Aircana
         pages
       end
 
-      def process_pages(pages, agent)
+      def process_pages(pages, agent, kb_type = "remote")
         ProgressTracker.with_batch_progress(pages, "Processing pages") do |page, _index|
-          store_page_as_markdown(page, agent)
+          store_page_as_markdown(page, agent, kb_type)
         end
       end
 
-      def process_pages_with_manifest(pages, agent)
+      def process_pages_with_manifest(pages, agent, kb_type = "remote")
         page_metadata = []
 
         ProgressTracker.with_batch_progress(pages, "Processing pages") do |page, _index|
-          store_page_as_markdown(page, agent)
+          store_page_as_markdown(page, agent, kb_type)
           page_metadata << extract_page_metadata(page)
         end
 
@@ -112,11 +113,11 @@ module Aircana
         ]
       end
 
-      def create_or_update_manifest(agent, sources)
+      def create_or_update_manifest(agent, sources, kb_type = "remote")
         if Manifest.manifest_exists?(agent)
-          Manifest.update_manifest(agent, sources)
+          Manifest.update_manifest(agent, sources, kb_type: kb_type)
         else
-          Manifest.create_manifest(agent, sources)
+          Manifest.create_manifest(agent, sources, kb_type: kb_type)
         end
       end
 

data/lib/aircana/contexts/confluence_content.rb

@@ -21,14 +21,15 @@ module Aircana
         Aircana.human_logger.info "Found #{count} pages for agent '#{agent}'"
       end
 
-      def store_page_as_markdown(page, agent)
+      def store_page_as_markdown(page, agent, kb_type = "remote")
         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,
-          agent: agent
+          agent: agent,
+          kb_type: kb_type
         )
       end
     end

data/lib/aircana/contexts/local.rb

@@ -5,8 +5,8 @@ require "fileutils"
 module Aircana
   module Contexts
     class Local
-      def store_content(title:, content:, agent:)
-        agent_dir = create_agent_knowledge_dir(agent)
+      def store_content(title:, content:, agent:, kb_type: "remote")
+        agent_dir = create_agent_knowledge_dir(agent, kb_type)
         filename = sanitize_filename(title)
         filepath = File.join(agent_dir, "#{filename}.md")
 
@@ -18,10 +18,10 @@ module Aircana
 
       private
 
-      def create_agent_knowledge_dir(agent)
+      def create_agent_knowledge_dir(agent, kb_type = "remote")
         config = Aircana.configuration
-        # Use global agents directory with plugin prefix
-        agent_dir = config.global_agent_knowledge_path(agent)
+        # Route to appropriate directory based on kb_type
+        agent_dir = config.agent_knowledge_path(agent, kb_type)
 
         FileUtils.mkdir_p(agent_dir)
 

data/lib/aircana/contexts/manifest.rb

@@ -7,31 +7,36 @@ module Aircana
   module Contexts
     class Manifest
       class << self
-        def create_manifest(agent, sources)
+        def create_manifest(agent, sources, kb_type: "remote")
           validate_sources(sources)
+          validate_kb_type(kb_type)
 
           manifest_path = manifest_path_for(agent)
-          manifest_data = build_manifest_data(agent, sources)
+          manifest_data = build_manifest_data(agent, sources, kb_type)
 
           FileUtils.mkdir_p(File.dirname(manifest_path))
           File.write(manifest_path, JSON.pretty_generate(manifest_data))
 
-          Aircana.human_logger.info "Created knowledge manifest for agent '#{agent}'"
+          Aircana.human_logger.info "Created knowledge manifest for agent '#{agent}' (kb_type: #{kb_type})"
           manifest_path
         end
 
-        def update_manifest(agent, sources)
+        def update_manifest(agent, sources, kb_type: nil)
           validate_sources(sources)
 
           manifest_path = manifest_path_for(agent)
 
           if File.exist?(manifest_path)
             existing_data = JSON.parse(File.read(manifest_path))
-            manifest_data = existing_data.merge({ "sources" => sources })
+            # Preserve existing kb_type unless explicitly provided
+            kb_type_to_use = kb_type || existing_data["kb_type"] || "remote"
+            manifest_data = existing_data.merge({ "sources" => sources, "kb_type" => kb_type_to_use })
           else
-            manifest_data = build_manifest_data(agent, sources)
+            kb_type_to_use = kb_type || "remote"
+            manifest_data = build_manifest_data(agent, sources, kb_type_to_use)
           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
@@ -61,6 +66,13 @@ module Aircana
           manifest["sources"] || []
         end
 
+        def kb_type_from_manifest(agent)
+          manifest = read_manifest(agent)
+          return "remote" unless manifest
+
+          manifest["kb_type"] || "remote"
+        end
+
         def manifest_exists?(agent)
           File.exist?(manifest_path_for(agent))
         end
@@ -76,10 +88,11 @@ module Aircana
           File.join(Aircana.configuration.agent_knowledge_dir, agent)
         end
 
-        def build_manifest_data(agent, sources)
+        def build_manifest_data(agent, sources, kb_type = "remote")
           {
             "version" => "1.0",
             "agent" => agent,
+            "kb_type" => kb_type,
             "sources" => sources
           }
         end
@@ -95,6 +108,10 @@ module Aircana
             raise ManifestError, "Unsupported manifest version: #{manifest_data["version"]}"
           end
 
+          # kb_type is optional for backward compatibility, defaults to "remote"
+          kb_type = manifest_data["kb_type"] || "remote"
+          validate_kb_type(kb_type)
+
           validate_sources(manifest_data["sources"])
         end
 
@@ -144,6 +161,13 @@ module Aircana
 
           raise ManifestError, "URL entry missing required field: url" unless url_entry.key?("url")
         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