aircana 3.0.0 → 3.2.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 - Fetched from Confluence/web, stored in ~/.claude/agents/, " \
+                                            "requires refresh",
+                                      value: "remote"
+                                    },
+                                    {
+                                      name: "Local - Version controlled in plugin, auto-synced to ~/.claude/agents/ " \
+                                            "on session start",
+                                      value: "local"
+                                    }
+                                  ])
+
           description = description_from_claude(short_description)
           normalized_agent_name = normalize_string(agent_name)
 
@@ -36,16 +58,20 @@ 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}"
 
+          # If local kb_type, ensure SessionStart hook is installed
+          ensure_local_knowledge_sync_hook if kb_type == "local"
+
           # 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 +89,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 +97,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 +130,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 +144,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 +173,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 in agents/<agent>/knowledge/"
+          Aircana.human_logger.warn "and auto-synced to ~/.claude/agents/ on session start"
+          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 +236,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,33 +270,62 @@ module Aircana
           { pages_count: total_pages, sources: all_sources }
         end
 
-        def ensure_gitignore_entry
+        def ensure_gitignore_entry(kb_type = "remote")
           gitignore_path = gitignore_file_path
-          pattern = gitignore_pattern
 
+          if kb_type == "local"
+            # For local agents, ensure version-controlled knowledge is not ignored
+            ensure_local_knowledge_not_ignored(gitignore_path)
+          else
+            # For remote agents, add ignore pattern for .claude/agents/*/knowledge/
+            ensure_remote_knowledge_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 knowledge directories to .gitignore"
-        rescue StandardError => e
-          Aircana.human_logger.warn "Could not update .gitignore: #{e.message}"
-          Aircana.human_logger.info "Manually add: #{pattern}"
+          Aircana.human_logger.success "Added remote knowledge directories 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 agent 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 gitignore_pattern
+        def remote_knowledge_pattern
           ".claude/agents/*/knowledge/"
         end
 
+        def local_knowledge_negation_pattern
+          "!agents/*/knowledge/"
+        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 "Knowledge directories already in .gitignore"
+            Aircana.human_logger.info "Pattern '#{pattern}' already in .gitignore"
             true
           else
             false
@@ -263,24 +377,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 +425,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 +449,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 +525,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 +546,16 @@ 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 ""
@@ -439,6 +567,166 @@ module Aircana
 
           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)
+
+            # Step 5: Ensure SessionStart hook is installed (only install once for all local agents)
+            Aircana.human_logger.info "  Ensuring SessionStart hook is installed..."
+            ensure_local_knowledge_sync_hook
+
+            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 ""
+            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
+
+          if results[:successful].positive?
+            Aircana.human_logger.info ""
+            Aircana.human_logger.warn "⚠️  Knowledge is now version-controlled in agents/<agent>/knowledge/"
+            Aircana.human_logger.info "A SessionStart hook has been added to auto-sync knowledge to ~/.claude/agents/"
+            Aircana.human_logger.info "Review and commit these changes to your repository."
+          end
+
+          Aircana.human_logger.info ""
+        end
+
+        def ensure_local_knowledge_sync_hook
+          hooks_manifest = Aircana::HooksManifest.new(Aircana.configuration.plugin_root)
+
+          # Check if sync hook already exists
+          current_hooks = hooks_manifest.read || {}
+          session_start_hooks = current_hooks["SessionStart"] || []
+
+          # Check if our sync script already exists
+          sync_hook_exists = session_start_hooks.any? do |hook_group|
+            hook_group["hooks"]&.any? { |h| h["command"]&.include?("sync_local_knowledge.sh") }
+          end
+
+          return if sync_hook_exists
+
+          # Generate the sync script
+          generate_sync_script
+
+          # Add hook to manifest
+          hook_entry = {
+            "type" => "command",
+            "command" => "./scripts/sync_local_knowledge.sh"
+          }
+
+          hooks_manifest.add_hook(event: "SessionStart", hook_entry: hook_entry)
+          Aircana.human_logger.success "Added SessionStart hook to sync local knowledge bases"
+        end
+
+        def generate_sync_script
+          script_path = File.join(Aircana.configuration.scripts_dir, "sync_local_knowledge.sh")
+          return if File.exist?(script_path)
+
+          template_path = File.join(File.dirname(__FILE__), "..", "..", "templates", "hooks",
+                                    "sync_local_knowledge.erb")
+          template_content = File.read(template_path)
+
+          FileUtils.mkdir_p(Aircana.configuration.scripts_dir)
+          File.write(script_path, ERB.new(template_content).result)
+          File.chmod(0o755, script_path)
+        end
       end
     end
   end

data/lib/aircana/configuration.rb

@@ -48,12 +48,32 @@ module Aircana
       File.basename(@plugin_root).downcase.gsub(/[^a-z0-9]+/, "-")
     end
 
-    # Returns the global knowledge directory path for an agent
+    # Returns the global knowledge directory path for an agent (runtime location)
     # Format: ~/.claude/agents/<plugin-name>-<agent-name>/knowledge/
+    # Both local and remote agents use this path at runtime
     def global_agent_knowledge_path(agent_name)
       File.join(@global_agents_dir, "#{plugin_name}-#{agent_name}", "knowledge")
     end
 
+    # Returns the local knowledge directory path for an agent (version-controlled source)
+    # Format: <plugin-root>/agents/<agent-name>/knowledge/
+    # Used only for local agents as the source that gets synced to global path
+    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
+    # For runtime access, both local and remote agents use global_agent_knowledge_path
+    # Local agents are synced there via SessionStart hook from their version-controlled source
+    # kb_type can be "remote" or "local" but is not used (kept for backward compatibility)
+    def agent_knowledge_path(agent_name, _kb_type = nil)
+      # Both types use the global path at runtime
+      # The difference is how the content gets there:
+      # - Remote: via 'aircana agents refresh' from Confluence/web
+      # - Local: via SessionStart hook from version-controlled agents/<name>/knowledge/
+      global_agent_knowledge_path(agent_name)
+    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)