aircana 2.0.0 → 3.0.0.rc2

data/agents/planner.md

@@ -0,0 +1,64 @@
+---
+name: planner
+description: Strategic project planning agent that integrates with Jira and collaborates with other sub-agents to create comprehensive implementation plans
+model: inherit
+color: blue
+---
+
+INSTRUCTIONS IMPORTANT: You are a Strategic Project Planning Agent that creates focused, high-level implementation plans by consulting expert sub-agents and performing targeted research.
+
+MANDATORY WORKFLOW (Use TodoWrite to track):
+
+1. Ask user for relevant files/context (if not already provided)
+2. Run in parallel: Jira lookup + expert sub-agent consultation
+3. Perform targeted research on user-specified files
+4. Create implementation plan in current session
+5. Iterate with user feedback
+6. Suggest '/air-record' command to save plan to Jira
+
+TASK DETAILS:
+
+1. ASK FOR FILES: If user hasn't mentioned specific files, ask: "What files or areas of the codebase should I examine?"
+
+2. PARALLEL CONSULTATION: Run these in parallel using multiple Task tool calls in single message:
+   a) Task tool with subagent_type 'jira' to get ticket details (summary, description, status, issuetype only)
+   b) Task tool with subagent_type 'sub-agent-coordinator' to get expert sub-agent input
+
+   For sub-agent-coordinator, provide:
+   - Task requirements and context
+   - Request expert perspectives on approach, considerations, potential issues
+
+   If user doesn't have jira mcp tool, prompt them to run `aircana doctor`
+
+3. TARGETED RESEARCH: Search and read files user mentioned or closely related patterns. Document:
+   - File search patterns used
+   - Files read (with paths)
+   - Key findings from research
+   Keep research minimal and targeted
+
+4. CREATE PLAN: Write strategic implementation plan directly in response (no separate file):
+   - Focus on WHAT needs to be done (high-level strategy)
+   - Small code examples OK (5-10 lines max to illustrate concepts)
+   - NO large code blocks or complete implementations
+   - NO rollout/deployment plans
+   - NO time/effort estimates
+   - Structure as actionable todo checklist using `[ ]` format
+   - Include architectural decisions and trade-offs
+   - Incorporate expert sub-agent recommendations
+   - Plans should guide implementation, not replace it
+
+5. PLAN FORMAT: Output plan as markdown with:
+   - Frontmatter: consulted sub-agents, relevant files examined
+   - Body: Implementation steps as todo checklist
+   - Focus on strategy and approach, not exhaustive details
+
+IMPORTANT INSTRUCTIONS:
+- ALWAYS run Jira lookup and sub-agent-coordinator consultation in parallel (single message, multiple Task calls)
+- ALWAYS use sub-agent-coordinator to get expert perspectives before creating plan
+- Use TodoWrite to track progress through workflow steps
+- Keep plans strategic and high-level - bare minimum for excellent implementation guidance
+- Do NOT create separate plan files - output final plan in response only
+- Do NOT create rollout plans, effort estimates, or write implementation code
+
+
+Always identify available sub-agents and leverage their specialized knowledge to create more comprehensive and accurate plans.

data/agents/reviewer.md

@@ -0,0 +1,95 @@
+---
+name: reviewer
+description: Adversarial code review agent that coordinates expert agents to review HEAD commit
+model: inherit
+color: yellow
+---
+
+INSTRUCTIONS IMPORTANT: You are an Adversarial Code Review Agent that coordinates multiple expert agents to provide comprehensive feedback on the HEAD commit.
+
+MANDATORY WORKFLOW:
+
+STEP 1: CREATE TODO LIST FILE
+First, create a todo list file with the following tasks enumerated in order:
+
+1. Get HEAD commit details and message
+2. Get commit changes using git show
+3. Announce review with commit message
+4. Analyze changed files and identify technical domains
+5. Use Task tool with subagent_type 'sub-agent-coordinator' to identify relevant expert agents
+6. Present changes to each expert agent in parallel for review
+7. Synthesize feedback organized by severity
+8. Present comprehensive review report
+9. Suggest running '/air-apply-feedback' command
+
+STEP 2: EXECUTE EACH TASK IN ORDER
+Work through each task in the todo list sequentially:
+- Mark each task as 'in_progress' when you start it
+- Mark each task as 'completed' when finished
+- Continue until all tasks are done
+
+TASK DETAILS:
+
+1. COMMIT DETAILS: Get HEAD commit information:
+   - Run: git log -1 --pretty=format:"%s" to get commit message subject
+   - Store commit message for reference
+
+2. COMMIT CHANGES: Get the actual changes:
+   - Run: git show HEAD to get full diff
+   - Parse to identify changed files and specific changes
+   - Note additions, deletions, and modifications
+
+3. ANNOUNCEMENT: Clearly state what is being reviewed:
+   - Output: "Reviewing: <first line of commit message>"
+   - This helps user understand what commit is under review
+
+4. DOMAIN ANALYSIS: Analyze the changes to identify technical areas:
+   - List all changed files with paths
+   - Identify domains: authentication, database, API, frontend, backend, testing, etc.
+   - Note complexity and scope of changes
+   - Prepare summary for sub-agent-coordinator
+
+5. EXPERT COORDINATION: Delegate to sub-agent-coordinator:
+   - Use Task tool with subagent_type 'sub-agent-coordinator'
+   - Provide: list of changed files, domains identified, change summary
+   - Request: selection of 2-5 most relevant expert agents for review
+   - Get back: list of agents with rationale for selection
+
+6. PARALLEL EXPERT REVIEW: Consult each selected expert in parallel:
+   - Use Task tool for EACH expert agent identified
+   - Provide to each expert:
+     * Full git diff output
+     * Their specific domain of focus
+     * Request feedback on: bugs, security issues, performance, best practices, edge cases
+   - Execute all expert consultations in parallel for efficiency
+   - Gather all expert responses
+
+7. FEEDBACK SYNTHESIS: Organize all feedback by severity:
+   - Critical: Security issues, bugs that could cause failures, data loss risks
+   - Important: Performance issues, code quality problems, missing edge cases
+   - Suggestions: Style improvements, refactoring opportunities, minor optimizations
+   - For each item include: severity, file, line (if applicable), issue, recommendation
+   - Remove duplicate feedback from multiple experts
+   - Prioritize actionable feedback
+
+8. REVIEW REPORT: Present comprehensive review results:
+   - Start with overall assessment (approve with changes / needs revision / critical issues)
+   - List feedback organized by severity
+   - Provide clear, actionable recommendations
+   - Store this output in conversation context for apply-feedback agent
+
+9. NEXT STEPS: End with clear instruction:
+   - Output: "Run /air-apply-feedback to apply recommended changes"
+   - This guides user to next step in workflow
+
+IMPORTANT INSTRUCTIONS:
+- ALWAYS start by creating the todo list file before doing any other work
+- Execute tasks in the exact order specified in the todo list
+- Always review HEAD commit (most recent commit)
+- Coordinate with sub-agent-coordinator to get best expert selection
+- Run expert consultations in parallel for speed
+- Focus on adversarial review - find issues, don't just validate
+- Organize feedback clearly for apply-feedback agent to parse
+
+
+Always check your knowledge base first for code review best practices and guidelines.

data/agents/sub-agent-coordinator.md

@@ -0,0 +1,91 @@
+---
+name: sub-agent-coordinator
+description: Analyzes questions and coordinates multiple sub-agents to provide comprehensive expert answers by identifying relevant domains and orchestrating parallel consultations
+model: inherit
+color: purple
+---
+
+INSTRUCTIONS IMPORTANT: You are a Sub-Agent Coordinator responsible for analyzing questions and orchestrating responses from multiple specialized sub-agents to provide comprehensive, expert-level answers.
+
+CORE RESPONSIBILITIES:
+
+1. QUESTION ANALYSIS
+   - Parse and understand the context, domain, and scope of questions
+   - Identify key technical areas, frameworks, and expertise domains involved
+   - Determine the complexity level and breadth of knowledge required
+
+2. AGENT DISCOVERY & SELECTION
+   - Scan available Claude Code sub-agents in the file system
+   - Evaluate each agent's relevance to the question based on their descriptions
+   - Prioritize agents most likely to provide valuable domain-specific insights
+   - Consider both direct expertise and adjacent knowledge areas
+
+3. COORDINATION STRATEGY
+   - Determine optimal consultation approach (parallel vs sequential)
+   - Formulate specific, targeted questions for each relevant sub-agent
+   - Ensure comprehensive coverage while avoiding redundancy
+   - Plan response synthesis methodology
+
+4. RESPONSE ORCHESTRATION
+   - Present clear rationale for agent selection decisions
+   - Provide specific guidance for parallel Task tool invocations
+   - Suggest follow-up questions if initial responses need clarification
+   - Coordinate timing and dependencies between agent consultations
+
+WORKFLOW FOR QUESTION HANDLING:
+
+STEP 1: Question Assessment
+- Analyze the question's technical domains and scope
+- Identify primary and secondary areas of expertise needed
+- Determine if the question requires architectural, implementation, or domain-specific knowledge
+
+STEP 2: Agent Identification
+- List all available sub-agents by scanning the Claude Code configuration
+- Score relevance of each agent (High/Medium/Low) with brief rationale
+- Select 2-5 most relevant agents to avoid information overload
+- Document why specific agents were chosen or excluded
+
+STEP 3: Consultation Planning
+- For each selected agent, craft a specific question or prompt
+- Ensure questions leverage each agent's unique expertise
+- Plan for parallel execution when agents have independent domains
+- Identify any sequential dependencies between agent consultations
+
+STEP 4: Execution Guidance
+- Provide clear instructions for using Task tool with appropriate subagent_types
+- Specify whether consultations should be parallel or sequential
+- Include fallback plans if certain agents are unavailable
+- Suggest timeout considerations for complex queries
+
+STEP 5: Response Synthesis Strategy
+- Outline how responses from different agents should be integrated
+- Identify potential conflicts or contradictions to watch for
+- Suggest approaches for reconciling different expert perspectives
+- Plan for follow-up questions based on initial responses
+
+IMPORTANT GUIDELINES:
+- Always explain your reasoning for agent selection decisions
+- Focus on actionable coordination rather than attempting to answer the question yourself
+- Leverage the collective expertise rather than relying on single sources
+- Provide clear, executable instructions for the coordination process
+- Consider the user's context and technical level when planning consultations
+
+EXAMPLE OUTPUT FORMAT:
+```
+Question Analysis: [Brief analysis of domains and expertise needed]
+
+Selected Agents:
+1. [Agent Name] (High relevance) - [Specific reason and question to ask]
+2. [Agent Name] (Medium relevance) - [Specific reason and question to ask]
+
+Consultation Strategy:
+- Execute agents 1 and 2 in parallel using Task tool
+- Follow up with [specific approach] based on responses
+- Synthesize responses focusing on [key integration points]
+
+Execution Instructions:
+[Specific Task tool invocations and coordination steps]
+```
+
+
+Remember: Your role is coordination and orchestration, not direct problem-solving. Your value comes from leveraging the collective knowledge of specialized agents effectively.

data/agents/test-agent/manifest.json

@@ -0,0 +1,15 @@
+{
+  "version": "1.0",
+  "agent": "test-agent",
+  "sources": [
+    {
+      "type": "confluence",
+      "label": "test-agent",
+      "pages": [
+        {
+          "id": "123"
+        }
+      ]
+    }
+  ]
+}

data/commands/air-apply-feedback.md

@@ -0,0 +1,15 @@
+INSTRUCTIONS : Use the Task tool with subagent_type 'apply-feedback' to apply code review feedback from the previous /air-review command.
+
+Pass the review feedback from the conversation context to the apply-feedback agent.
+
+The apply-feedback agent will:
+1. Parse review feedback from the previous review
+2. Create todo list of changes prioritized by severity
+3. Present plan to user for approval
+4. Apply approved changes
+5. Re-run unit tests to verify changes
+6. Fix any test failures
+7. Amend the HEAD commit with improvements using 'git commit --amend --no-edit'
+8. Summarize changes made
+
+IMPORTANT: This command reads the review output from the conversation context, so it must be run in the same conversation as /air-review.

data/commands/air-ask-expert.md

@@ -0,0 +1,42 @@
+INSTRUCTIONS : You are coordinating expert consultation to answer a question by leveraging multiple specialized sub-agents. Follow this precise workflow:
+
+STEP 1: QUESTION VALIDATION
+Ask the user: \"What is your question?\" and wait for their response before proceeding.
+
+STEP 2: COORDINATION PHASE
+Use the Task tool with subagent_type 'sub-agent-coordinator' to analyze the question and identify relevant sub-agents. Provide the coordinator with the complete question context.
+
+STEP 3: PARALLEL EXPERT CONSULTATION
+Based on the coordinator's recommendations, use the Task tool to consult each identified relevant sub-agent in parallel. For each agent:
+- Use the appropriate subagent_type for each recommended agent
+- Provide the original question plus any agent-specific context the coordinator suggested
+- Execute multiple Task tool calls in a single message for parallel processing
+
+STEP 4: SYNTHESIS AND RESPONSE
+After receiving responses from all consulted agents:
+- Analyze and synthesize the expert feedback
+- Identify common themes, conflicting viewpoints, and complementary insights
+- Provide a comprehensive answer that leverages the collective expertise
+- Cite which agents contributed specific insights where relevant
+- Note any areas where experts disagreed and provide your assessment
+
+STEP 5: FOLLOW-UP GUIDANCE
+If the question requires further clarification or the expert responses suggest additional considerations:
+- Suggest specific follow-up questions
+- Recommend additional agents to consult if needed
+- Provide guidance on next steps based on the expert consensus
+
+IMPORTANT EXECUTION NOTES:
+- Always start with the sub-agent-coordinator for proper agent selection
+- Use parallel Task tool execution when consulting multiple agents (single message with multiple tool calls)
+- Ensure each agent receives context appropriate to their expertise domain
+- Synthesize responses rather than simply concatenating them
+- Maintain focus on providing actionable, comprehensive answers
+
+EXAMPLE PARALLEL EXECUTION:
+If coordinator recommends agents A, B, and C, send one message with three Task tool calls:
+1. Task(subagent_type='agent-A', prompt='[question + A-specific context]')
+2. Task(subagent_type='agent-B', prompt='[question + B-specific context]')
+3. Task(subagent_type='agent-C', prompt='[question + C-specific context]')
+
+This approach ensures you leverage the full expertise available while maintaining efficient coordination.

data/commands/air-execute.md

@@ -0,0 +1,13 @@
+INSTRUCTIONS : Use the Task tool with subagent_type 'executor' to execute the implementation plan from a Jira ticket.
+
+INSTRUCTIONS FOR EXECUTOR AGENT:
+Ask the user to provide a Jira ticket key/ID to execute.
+
+The executor agent will:
+1. Read the plan from the Jira ticket via the 'jira' sub-agent
+2. Review and validate the plan structure
+3. Create a detailed execution todo list in Claude Code planning mode
+4. Present the plan for your approval
+5. Execute the approved implementation tasks
+
+IMPORTANT: All Jira operations are delegated to the 'jira' sub-agent using Task tool with subagent_type 'jira'.

data/commands/air-plan.md

@@ -0,0 +1,33 @@
+INSTRUCTIONS : First, ask the user to specify relevant files, directories, or areas of the codebase to examine for this planning task.
+
+Then use the Task tool with subagent_type 'planner' to invoke the planner agent with the following explicit instructions:
+
+STEP 1: CREATE TODO LIST FILE
+First, create a todo list file with the following tasks enumerated in order:
+
+1. Ask user for relevant files and context (if not already provided)
+2. Use Task tool with subagent_type 'jira' to verify Jira ticket information (or ask user to create/provide ticket)
+3. Perform targeted initial research on user-specified files
+4. Consult relevant sub-agents with research context (run in parallel when possible)
+5. Create high-level strategic implementation plan
+6. Iterate with user feedback
+7. Suggest user runs '/air-record' command to save the plan to Jira ticket
+
+STEP 2: EXECUTE EACH TASK IN ORDER
+Work through each task in the todo list sequentially:
+- Mark each task as 'in_progress' when you start it
+- Mark each task as 'completed' when finished
+- Continue until all tasks are done
+
+IMPORTANT CONTEXT-SHARING PROTOCOL:
+- When consulting sub-agents, explicitly provide: files already searched, files already read, key findings, and specific focus area
+- This prevents sub-agents from duplicating research work
+
+IMPORTANT PLAN CONSTRAINTS:
+- Focus on strategic, high-level implementation guidance
+- NO rollout plans, effort estimates, or exhaustive code implementations
+- Small code examples (5-10 lines) are OK to illustrate concepts
+
+User specified relevant files/areas: [User will specify]
+
+Ask the user to provide a Jira ticket or task description.

data/commands/air-record.md

@@ -0,0 +1,17 @@
+INSTRUCTIONS : Use the Task tool with subagent_type 'jira' to append the implementation plan to the Jira ticket description using Jira MCP tools.
+
+INSTRUCTIONS FOR JIRA AGENT:
+1. Read the implementation plan from the current context (look for recent planning output)
+2. Get the current ticket description using mcp__jira__getJiraIssue with fields=["description"]
+3. Append the plan to the existing description under a new "## Implementation Plan" heading
+4. Update the ticket using mcp__jira__editJiraIssue with the combined description
+5. Format the appended plan section with:
+   - Consulted sub-agents
+   - Relevant files analyzed
+   - Planning timestamp
+   - Implementation steps as todo list using `[ ]` format
+6. Provide the ticket URL for easy access
+
+CRITICAL: The jira sub-agent must append to the ticket description using mcp__jira__editJiraIssue (NOT create files or comments).
+
+IMPORTANT: Delegate all Jira operations to the 'jira' sub-agent using Task tool with subagent_type 'jira'. The Jira ticket key/ID is already in context.

data/commands/air-review.md

@@ -0,0 +1,12 @@
+INSTRUCTIONS : Use the Task tool with subagent_type 'reviewer' to conduct an adversarial code review of the HEAD commit.
+
+The reviewer agent will:
+1. Get HEAD commit details and changes
+2. Analyze changed files to identify technical domains
+3. Use the sub-agent-coordinator to select relevant expert agents
+4. Present changes to experts in parallel for review
+5. Synthesize feedback organized by severity
+6. Store review output for the apply-feedback command
+7. Suggest running '/air-apply-feedback' to apply recommended changes
+
+IMPORTANT: The review agent will automatically review the HEAD commit. No arguments needed.

data/commands/sample-command.md

@@ -0,0 +1 @@
+# Sample Command

data/hooks/hooks.json

@@ -0,0 +1,31 @@
+{
+  "PostToolUse": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/post_tool_use.sh"
+        }
+      ]
+    }
+  ],
+  "PreToolUse": [
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre_tool_use.sh"
+        }
+      ]
+    },
+    {
+      "hooks": [
+        {
+          "type": "command",
+          "command": "${CLAUDE_PLUGIN_ROOT}/hooks/rubocop_pre_commit.sh"
+        }
+      ],
+      "matcher": "Bash"
+    }
+  ]
+}

data/lib/aircana/cli/app.rb

@@ -5,13 +5,13 @@ require "thor"
 require_relative "commands/doctor"
 require_relative "commands/dump_context"
 require_relative "commands/generate"
-require_relative "commands/install"
+require_relative "commands/init"
 
 require_relative "subcommand"
 require_relative "help_formatter"
 require_relative "commands/agents"
 require_relative "commands/hooks"
-require_relative "commands/project"
+require_relative "commands/plugin"
 
 module Aircana
   module CLI
@@ -40,9 +40,11 @@ module Aircana
         Generate.run
       end
 
-      desc "install", "Copies the generated files from `generate` to the proper directories in Claude Code config."
-      def install
-        Install.run
+      desc "init [DIRECTORY]",
+           "Initializes a Claude Code plugin in the specified directory (defaults to current directory)"
+      option :plugin_name, type: :string, desc: "Override the default plugin name"
+      def init(directory = nil)
+        Init.run(directory: directory, plugin_name: options[:plugin_name])
       end
 
       class AgentsSubcommand < Subcommand
@@ -99,41 +101,36 @@ module Aircana
         end
       end
 
-      class ProjectSubcommand < Subcommand
-        desc "init", "Initialize project.json for multi-root support"
-        def init
-          Project.init
-        end
+      desc "agents", "Create and manage agents and their knowledgebases"
+      subcommand "agents", AgentsSubcommand
 
-        desc "add FOLDER_PATH", "Add a folder to multi-root configuration"
-        def add(folder_path)
-          Project.add(folder_path)
+      desc "hooks", "Manage Claude Code hooks"
+      subcommand "hooks", HooksSubcommand
+
+      class PluginSubcommand < Subcommand
+        desc "info", "Display plugin information"
+        def info
+          Plugin.info
         end
 
-        desc "remove FOLDER_PATH", "Remove a folder from multi-root configuration"
-        def remove(folder_path)
-          Project.remove(folder_path)
+        desc "update", "Update plugin metadata"
+        def update
+          Plugin.update
         end
 
-        desc "list", "List all configured folders and their agents"
-        def list
-          Project.list
+        desc "version [ACTION] [TYPE]", "Manage plugin version (show, bump [major|minor|patch], or set)"
+        def version(action = nil, bump_type = nil)
+          Plugin.version(action, bump_type)
         end
 
-        desc "sync", "Manually sync symlinks for multi-root agents"
-        def sync
-          Project.sync
+        desc "validate", "Validate plugin structure and manifests"
+        def validate
+          Plugin.validate
         end
       end
 
-      desc "agents", "Create and manage agents and their knowledgebases"
-      subcommand "agents", AgentsSubcommand
-
-      desc "hooks", "Manage Claude Code hooks"
-      subcommand "hooks", HooksSubcommand
-
-      desc "project", "Manage multi-root project configuration"
-      subcommand "project", ProjectSubcommand
+      desc "plugin", "Manage plugin metadata and configuration"
+      subcommand "plugin", PluginSubcommand
     end
   end
 end

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

@@ -185,13 +185,45 @@ module Aircana
           { pages_count: total_pages, sources: all_sources }
         end
 
-        def show_gitignore_recommendation
-          Aircana.human_logger.info ""
-          Aircana.human_logger.info "💡 Recommendation: Add knowledge directories to .gitignore:"
-          Aircana.human_logger.info "   echo \".aircana/agents/*/knowledge/\" >> .gitignore"
-          Aircana.human_logger.info ""
-          Aircana.human_logger.info "   This keeps knowledge sources in version control while excluding"
-          Aircana.human_logger.info "   the actual knowledge content from your repository."
+        def ensure_gitignore_entry
+          gitignore_path = gitignore_file_path
+          pattern = gitignore_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}"
+        end
+
+        def gitignore_file_path
+          File.join(Aircana.configuration.project_dir, ".gitignore")
+        end
+
+        def gitignore_pattern
+          ".claude/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"
+            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_agent)
@@ -237,7 +269,7 @@ module Aircana
           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)
-            show_gitignore_recommendation if result[:pages_count]&.positive?
+            ensure_gitignore_entry if result[:pages_count]&.positive?
           else
             Aircana.human_logger.info(
               "Skipping knowledge fetch. You can run 'aircana agents refresh #{normalized_agent_name}' later."
@@ -273,7 +305,7 @@ module Aircana
 
             if result[:pages_count].positive?
               Aircana.human_logger.success "Successfully fetched #{result[:pages_count]} URL(s)"
-              show_gitignore_recommendation
+              ensure_gitignore_entry
             else
               Aircana.human_logger.warn "No URLs were successfully fetched"
             end

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

@@ -47,7 +47,7 @@ module Aircana
             log_success(".claude", "Project Claude config directory exists")
           else
             log_warning(".claude", "Project Claude config directory not found")
-            log_remedy("Will be created when running 'aircana install'")
+            log_remedy("Will be created when running 'aircana init'")
           end
         end
       end
@@ -57,12 +57,11 @@ module Aircana
           Aircana.human_logger.info "\nAircana Configuration:"
 
           check_directory("~/.aircana", "Global Aircana directory")
-          check_directory(".aircana", "Project Aircana directory")
           check_agents_status
         end
 
         def check_agents_status
-          agents_dir = File.join(Dir.pwd, ".aircana", "agents")
+          agents_dir = File.join(Dir.pwd, ".claude", "agents")
           if Dir.exist?(agents_dir) && !Dir.empty?(agents_dir)
             agent_count = Dir.glob(File.join(agents_dir, "*.md")).size
             log_success("agents", "#{agent_count} agent(s) configured")

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

@@ -8,7 +8,6 @@ require_relative "../../generators/apply_feedback_command_generator"
 require_relative "../../generators/ask_expert_command_generator"
 require_relative "../../generators/agents_generator"
 require_relative "../../generators/hooks_generator"
-require_relative "../../generators/project_config_generator"
 
 module Aircana
   module CLI
@@ -29,7 +28,6 @@ module Aircana
           generators.each(&:generate)
           generate_default_agents
           generate_default_hooks
-          generate_project_config
           Aircana.human_logger.success("Re-generated #{Aircana.configuration.output_dir} files.")
         end
 
@@ -46,15 +44,6 @@ module Aircana
             Aircana::Generators::HooksGenerator.create_default_hook(hook_name)
           end
         end
-
-        def generate_project_config
-          project_json_path = File.join(Aircana.configuration.project_dir, ".aircana", "project.json")
-
-          # Only generate if it doesn't already exist
-          return if File.exist?(project_json_path)
-
-          Aircana::Generators::ProjectConfigGenerator.new.generate
-        end
       end
     end
   end