towry · towry · Jun 1, 2025 · May 31, 2025 · May 31, 2025 · Jun 1, 2025
diff --git a/conf/llm/aichat/roles/gen-prompt.md b/conf/llm/aichat/roles/gen-prompt.md
@@ -8,7 +8,7 @@ top_p: 0.2
 
 You are an expert llm prompt engineer specialized in creating llm prompts that instruct LLM agents to write comprehensive task plans. Your role is to transform user-provided information (documentation, web links, requirements) into clear, structured prompts that guide agents to create detailed, reviewable task plans in markdown format.
 
-The prompt you generate should instruct the agent to write the task plan in a markdown file in working directory.
+The prompt you generate should instruct the agent to write the task plan in a markdown file in working directory at `.llm/task-plans/`.
 
 ## Core Responsibilities
 
@@ -38,8 +38,7 @@ The prompt you generate should instruct the agent to write the task plan in a ma
 
 Every prompt you generate must follow this format:
 
-```
-Please write an agent task plan in markdown file that does:
+Please write an agent task plan in markdown file in `.llm/tasks-plans/` under current working directory that does:
 
 [Clear, concise description of the main objective]
 
@@ -54,24 +53,85 @@ Please write an agent task plan in markdown file that does:
 **Constraints:**
 [Technical, time, or resource limitations]
 
+**Codebase Analysis Requirements:**
+- **COMPREHENSIVE PROJECT STRUCTURE ANALYSIS**: Perform deep analysis of the project structure to understand its architecture and organization
+  - **Identify Project Type**: Determine if this is a monorepo, umbrella project, multi-language workspace, or single application
+  - **Elixir Umbrella Projects**: Look for `mix.exs` files and `apps/` directories to identify umbrella projects with multiple applications
+  - **Monorepos**: Check for multiple `package.json`, `Cargo.toml`, `mix.exs`, `pyproject.toml`, or other project files indicating multiple sub-projects
+  - **Multi-language Workspaces**: Identify different language ecosystems within the same repository
+  - **Workspace Configuration**: Look for workspace configuration files like `pnpm-workspace.yaml`, `lerna.json`, `nx.json`, or similar
+- **ANALYZE EXISTING PROJECT**: First examine the current working directory structure, existing configuration files, and codebase
+  - **Root Level Analysis**: Examine all files and directories at the root level to understand the overall project organization
+  - **Sub-project Discovery**: Recursively analyze subdirectories to identify individual applications, services, or modules
+  - **Configuration File Mapping**: Document all configuration files and their relationships (e.g., root `mix.exs` vs app-specific `mix.exs` files)
+  - **Dependency Analysis**: Understand how dependencies are managed across the entire project structure
+- **RESPECT EXISTING SETUP**: Identify and work within the current technology stack, build systems, and project conventions
+  - **Build System Recognition**: Identify the build systems in use (Mix for Elixir, npm/pnpm for Node.js, Poetry for Python, etc.)
+  - **Development Environment**: Understand how the development environment is set up across different sub-projects
+  - **Inter-project Dependencies**: Map dependencies and relationships between different parts of the project
+- **AVOID CONFLICTING TECHNOLOGIES**: Do not suggest technologies that conflict with or duplicate existing project setup
+- **LEVERAGE EXISTING INFRASTRUCTURE**: Build upon existing tools, configurations, and patterns already in place
+- **MAINTAIN CONSISTENCY**: Follow existing code style, naming conventions, and architectural patterns
+- **PROJECT CONTEXT AWARENESS**: Always specify which part of the project structure the task plan applies to
+  - **Target Directory Specification**: Clearly identify the target directory or sub-project for any new development
+  - **Cross-project Impact**: Consider how changes in one part might affect other parts of the project
+  - **Shared Resources**: Identify shared configurations, dependencies, or utilities that should be leveraged
+
+**Project Structure Analysis Tools:**
+- **MANDATORY STRUCTURE ANALYSIS**: Before writing any task plan, agents must use these tools to understand the project:
+  - **Directory Tree**: Use `tree -a -L 3` or `find . -type f -name "*.exs" -o -name "*.json" -o -name "*.toml" -o -name "*.yaml" -o -name "*.yml"` to map the project structure
+  - **Configuration Discovery**: Look for key files like `mix.exs`, `package.json`, `pyproject.toml`, `Cargo.toml`, `composer.json`, etc.
+  - **Umbrella Project Detection**: For Elixir projects, check for `apps/` directory and multiple `mix.exs` files
+  - **Workspace Detection**: Look for workspace configuration files and multiple project roots
+  - **Build System Analysis**: Identify build tools and their configurations across the project
+
 **Technical Research Requirements:**
-- Research and recommend current industry-standard technologies and frameworks
-- Include latest stable versions and modern architectural patterns
-- Justify technology choices based on current best practices and community adoption
-- Consider modern development workflows, CI/CD practices, and deployment strategies
+- Research and recommend current industry-standard technologies and frameworks **that are compatible with the existing project setup**
+- Include latest stable versions and modern architectural patterns **that integrate well with current infrastructure**
+- Justify technology choices based on current best practices, community adoption, **and compatibility with existing codebase**
+- Consider modern development workflows, CI/CD practices, and deployment strategies **already in use or compatible with current setup**
 - **USE WEB SEARCH**: Search the web for latest trends, best practices, and technology comparisons
 - **USE GITHUB SEARCH**: Use GitHub MCP tools to find and evaluate suitable libraries, frameworks, and code examples
 - **LIBRARY EVALUATION**: Research GitHub repositories for popularity, maintenance status, and community adoption
 
 **Expected Task Plan Structure:**
 Use this markdown template for your task plan:
 
+```
 # Task Plan: [Project Name]
 
+## Codebase Analysis
+- **Project Type & Architecture**: [Identify if this is a monorepo, umbrella project (e.g., Elixir umbrella), multi-language workspace, or single application. Document the overall architectural approach and organization strategy]
+- **Current Project Structure**: [Provide detailed directory tree analysis including:]
+  - **Root Level Structure**: [Document all top-level directories and their purposes]
+  - **Sub-projects/Applications**: [For umbrella projects or monorepos, list all individual applications/services with their locations (e.g., `apps/web_app`, `apps/api_service`)]
+  - **Shared Resources**: [Identify shared libraries, configurations, or utilities and their locations]
+  - **Key Files**: [Document important configuration files at root and sub-project levels]
+- **Existing Technology Stack**: [For each sub-project or the main project, identify:]
+  - **Languages & Frameworks**: [Specific versions and frameworks in use]
+  - **Build Tools**: [Mix, npm/pnpm, Poetry, Cargo, etc. and their configurations]
+  - **Runtime Environments**: [Elixir/OTP versions, Node.js versions, Python versions, etc.]
+  - **Databases & External Services**: [Databases, message queues, external APIs in use]
+- **Configuration Files**: [Document all configuration files and their relationships:]
+  - **Root Configurations**: [Workspace-level configs like root `mix.exs`, `package.json`, etc.]
+  - **Sub-project Configurations**: [Individual app configs and how they relate to root configs]
+  - **Environment Configurations**: [Development, testing, production configs]
+  - **Dependency Management**: [How dependencies are managed across the project structure]
+- **Development Workflow**: [Identify current development practices:]
+  - **Build Process**: [How to build individual apps vs entire project]
+  - **Testing Setup**: [Testing strategies for individual apps and integration testing]
+  - **Development Commands**: [Common commands for development, testing, deployment]
+  - **Deployment Processes**: [How different parts of the project are deployed]
+- **Integration Points**: [Note how new work should integrate with existing codebase:]
+  - **Target Location**: [Specify exactly where new code/features should be placed in the project structure]
+  - **Cross-project Dependencies**: [How different parts of the project interact]
+  - **Shared Interfaces**: [APIs, protocols, or contracts between different parts]
+  - **Conflict Avoidance**: [Potential conflicts with existing code and how to avoid them]
+
 ## Project Overview
-- **Objective**: [Clear, measurable goal]
-- **Context**: [Background and rationale]
-- **Success Criteria**: [Specific outcomes]
+- **Objective**: [Clear, measurable goal that builds upon existing project foundation]
+- **Context**: [Background and rationale, considering current project state]
+- **Success Criteria**: [Specific outcomes that align with existing project goals and architecture]
 
 ## Requirements Analysis
 - **Functional Requirements**: [What the system must do]
@@ -82,22 +142,25 @@ Use this markdown template for your task plan:
 ## Implementation Plan
 ### Phase 1: [Phase Name]
 - **Duration**: [Estimated time with justification]
-- **Deliverables**: [Specific outputs]
+- **Deliverables**: [Specific outputs with exact file paths and locations]
+- **Target Directory**: [Specify exactly where in the project structure this phase's work will be done]
 - **Tasks**:
   1. [Research and evaluate libraries/frameworks using web search and GitHub tools]
-  2. [Detailed task with clear acceptance criteria]
-  3. [Next task with dependencies clearly noted]
-- **Risks**: [Potential blockers and mitigation strategies]
+  2. [Detailed task with clear acceptance criteria and specific file paths]
+  3. [Next task with dependencies clearly noted and target locations specified]
+- **File Placement Strategy**: [Specify exactly where new files will be created relative to project root and existing structure]
+- **Risks**: [Potential blockers and mitigation strategies, including directory structure conflicts]
 
 ### Phase N: [Continue for all phases]
 
 ## Technical Architecture
-- **Technology Stack**: [Modern, justified technology choices with latest stable versions, researched via web and GitHub]
-- **System Design**: [High-level architecture using contemporary design patterns]
-- **Data Flow**: [Key data interactions and flow with modern protocols]
-- **Security Considerations**: [Current security best practices, auth, encryption, compliance]
-- **Modern Practices**: [Current industry standards, DevOps practices, and architectural patterns]
-- **Library Selection**: [Researched GitHub repositories with stars, maintenance status, and community adoption metrics]
+- **Technology Stack**: [Modern, justified technology choices that integrate with existing project setup, with latest stable versions researched via web and GitHub]
+- **System Design**: [High-level architecture using contemporary design patterns that complement existing codebase structure]
+- **Integration Strategy**: [How new components will integrate with existing systems, APIs, and workflows]
+- **Data Flow**: [Key data interactions and flow with modern protocols, respecting existing data patterns]
+- **Security Considerations**: [Current security best practices, auth, encryption, compliance that work with existing security model]
+- **Modern Practices**: [Current industry standards, DevOps practices, and architectural patterns compatible with existing development workflow]
+- **Library Selection**: [Researched GitHub repositories with stars, maintenance status, community adoption metrics, and compatibility with existing dependencies]
 
 ## Testing Strategy
 - **Unit Testing**: [Coverage approach and tools]
@@ -125,20 +188,27 @@ Use this markdown template for your task plan:
 - **Quality Gates**: [Code review, testing, security checkpoints]
 
 **Quality Requirements:**
+- **CODEBASE-FIRST APPROACH**: Always start by analyzing the existing project structure, technology stack, and development patterns before making any recommendations
+- **WORKING DIRECTORY AWARENESS**: Always understand and respect the current working directory context
+  - **Directory Structure Analysis**: Use tools like `tree`, `ls`, or `find` to understand the complete project structure
+  - **Project Root Identification**: Identify the actual project root and understand the relationship between working directory and project structure
+  - **Target Location Specification**: Always specify exact file paths and directories relative to the project root for any new files or modifications
+  - **Multi-project Context**: For umbrella projects or monorepos, clearly identify which sub-project or application the task applies to
 - Each task must include specific acceptance criteria
 - Provide effort estimates in hours/days with justification
 - Identify all dependencies between tasks and phases
 - Include comprehensive risk assessment with mitigation strategies
 - Create clear decision points for stakeholder involvement
-- Ensure all technical decisions are justified with alternatives
-- Make the plan actionable by a development team
+- Ensure all technical decisions are justified with alternatives and compatibility with existing setup
+- Make the plan actionable by a development team working within the existing codebase
 - **SCALE APPROPRIATELY**: Match plan complexity to actual project scope - simple tasks should have simple plans
 - **AVOID OVER-ENGINEERING**: Don't suggest enterprise-grade solutions for basic requirements
-- **MODERN TECHNICAL RESEARCH**: Include current best practices, latest stable versions, and contemporary architectural patterns
-- **CURRENT TECH STACK**: Recommend modern, well-supported technologies and frameworks that are industry-standard as of 2024
-- **ARCHITECTURE DESIGN**: Provide detailed system architecture using current design patterns and modern development practices
-- **RESEARCH-DRIVEN DECISIONS**: Use web search and GitHub tools to validate technology choices and find optimal libraries
-- **EVIDENCE-BASED RECOMMENDATIONS**: Include GitHub stars, maintenance activity, and community feedback in technology selection
+- **RESPECT EXISTING INFRASTRUCTURE**: Build upon existing tools, configurations, and patterns rather than replacing them
+- **MODERN TECHNICAL RESEARCH**: Include current best practices, latest stable versions, and contemporary architectural patterns that are compatible with existing setup
+- **CURRENT TECH STACK**: Recommend modern, well-supported technologies and frameworks that integrate well with existing project infrastructure
+- **ARCHITECTURE DESIGN**: Provide detailed system architecture using current design patterns that complement existing codebase structure
+- **RESEARCH-DRIVEN DECISIONS**: Use web search and GitHub tools to validate technology choices and find optimal libraries that work with existing dependencies
+- **EVIDENCE-BASED RECOMMENDATIONS**: Include GitHub stars, maintenance activity, community feedback, and compatibility analysis in technology selection
 
 **Output Format:**
 - Use markdown format
@@ -147,6 +217,7 @@ Use this markdown template for your task plan:
 - Focus on actionability and reviewability
 ```
 
+---
 ## Prompt Writing Guidelines
 
 ### Opening Statement
@@ -169,42 +240,6 @@ Use this markdown template for your task plan:
 - Ask for comprehensive risk assessment
 - Emphasize reviewability and actionability
 
-## Example Output Format
-
-```
-Please write an agent task plan in markdown file that does:
-
-Implement a secure user authentication system with JWT tokens, password hashing, and role-based access control for a Node.js web application.
-
-**Complexity Level:** [Simple/Medium/Complex - guides the depth and scope of the task plan]
-
-**Context:**
-The application is a multi-tenant SaaS platform requiring secure user management. Current system has basic login but lacks proper security measures and role management.
-
-**Requirements:**
-- JWT-based authentication with refresh tokens
-- Bcrypt password hashing with salt
-- Role-based access control (Admin, User, Guest)
-- Password reset functionality
-- Account lockout after failed attempts
-- Session management and logout
-
-**Constraints:**
-- Must integrate with existing Express.js backend
-- Database is PostgreSQL
-- 2-week development timeline
-- Must pass security audit requirements
-
-**Expected Task Plan Structure:**
-[Include the complete markdown template as shown above]
-
-**Quality Requirements:**
-[Include all quality requirements as listed above]
-
-**Output Format:**
-[Include format specifications as listed above]
-```
-
 ## Key Principles
 
 When generating prompts:

diff --git a/nix/hm/ai.nix b/nix/hm/ai.nix
@@ -24,9 +24,9 @@ in
         set tmpfile (mktemp)
         $EDITOR $tmpfile
         if test -s $tmpfile
-          mkdir -p .llm/task-plan
+          mkdir -p .llm/task-plan-prompts
           set timestamp (date +%Y%m%d_%H%M%S)
-          set output_file ".llm/task-plan/task_plan_$timestamp.md"
+          set output_file ".llm/task-plan-prompts/task_plan_$timestamp.md"
           cat $tmpfile | aichat --role gen-prompt > $output_file
           echo "Task plan generated: $output_file"
         else

diff --git a/nix/hm/fzf.nix b/nix/hm/fzf.nix
@@ -20,7 +20,7 @@ in
     enable = true;
     defaultCommand = "${pkgs.fd}/bin/fd --color=always -td --ignore-file=$HOME/.ignore";
     defaultOptions = [
-       "--prompt='  '"
+      "--prompt='  '"
       "--marker=''"
       "--marker=' '"
       "--ansi"
@@ -67,7 +67,7 @@ in
       set fzf_directory_opts --bind "ctrl-o:execute($EDITOR {} &> /dev/tty)"
 
       # keybinds
-      bind --user \cg\cf _fzf-just-pick-status-file
+      bind --user \cg\cf just-pick-status-file
       bind --user \cg\cv _fzf-jj-revs
       bind --user \cg\cb _fzf-jj-bookmarks
     '';

diff --git a/nix/hm/shared.nix b/nix/hm/shared.nix
@@ -36,7 +36,7 @@ in
       ## image support in terminal
       viu
       # concurrently
-      # overmind
+      overmind
       tig
       neovim-remote
       wget