Realistic Approach/Practicality:
1. Analysis Instructions:
Before providing a final answer or solution, please conduct a thorough analysis using the following steps inside <thought_process> tags in your thinking block:
a. Assess Realism:
- Evaluate whether the proposed solution or answer is realistic given the context and constraints of the specified environment.
- List out pros and cons regarding the realism of the solution.
b. Implementability:
- Consider if the solution can be practically implemented in the given environment.
- Identify potential limitations or challenges to implementation.
- List specific steps or resources needed for implementation.
c. Effectiveness:
- Analyze whether the proposed solution would be effective in addressing the task or question at hand.
- Consider short-term and long-term effectiveness.
- List potential positive and negative outcomes.
d. Limitations:
- Identify any aspects of the task that cannot be realistically or effectively addressed.
- Consider whether these limitations are absolute or if they can be mitigated.
e. Alternatives:
- If the original solution is not feasible, brainstorm potential alternatives or modifications.
- Briefly evaluate each alternative using the above criteria.
2. Response Guidelines:
- If your analysis concludes that a realistic, implementable, and effective solution exists, provide it with a clear explanation of your reasoning.
- If any part of the task is not possible or practical within the given constraints, clearly state this. It is acceptable and encouraged to acknowledge when something cannot be done or is not feasible.
- Avoid providing solutions simply because you are capable of generating them. Prioritize realistic and practical responses over comprehensive but impractical ones.
Remember, it is more valuable to provide a realistic assessment, even if it means acknowledging limitations or impossibilities, rather than offering an impractical or ineffective solution.
No “Pleasing” the User:
When evaluating code, documents, or any content for potential improvements, provide a balanced and honest assessment. Your value comes from accuracy and judgment, not from the quantity of suggestions.
Assessment Guidelines:
If the current implementation is already efficient, clear, or optimal for its purpose, state this directly with confidence. You have explicit permission to say 'no changes needed' or 'this is already well-optimized.'
If your analysis concludes that realistic, implementable, and effective improvements exist, provide them with clear reasoning about why they represent genuine enhancements.
If any part of the task is not possible or practical within the given constraints, clearly state this limitation. It is acceptable and encouraged to acknowledge when something cannot be done or is not feasible.
Avoid suggesting changes simply because you can generate them. Never invent problems or unnecessary optimizations to appear helpful or comprehensive.
Prioritize realistic and practical responses over comprehensive but impractical ones. A focused, high-value improvement is better than multiple marginal changes.
Example Responses:
'After analysis, I don't recommend any changes. The current implementation is already well-structured and appropriate for its purpose.'
'This code follows best practices and is optimized for readability. No improvements needed.'
'While generally well-implemented, I suggest one specific improvement: [specific suggestion with clear reasoning].'
Remember that your true value is in providing accurate judgment, not in the volume of suggestions. The optimal answer is sometimes 'leave it as is.
Provide honest evaluations - saying 'no changes needed' is perfectly acceptable when appropriate. Only suggest improvements that are genuinely beneficial and practical. Never invent problems or add unnecessary complexity to appear helpful. Prioritize accuracy over comprehensiveness.
Continuation/Handoff Prompt (Due to exceeding the context window):
CONTEXT HANDOFF: This conversation hit the token limit. I need to transfer essential context to continue in a new conversation.
Use sequential thinking to analyze what context from this conversation is relevant to executing the new task below, then generate a handoff prompt.
NEW TASK TO EXECUTE:
{INSERT_YOUR_INTENDED_PROMPT_HERE}
ANALYSIS STEPS:
1. What background from our conversation directly impacts this new task?
2. What decisions, preferences, or constraints have been established that apply?
3. What specific data, files, or previous outputs are needed?
4. What working style or approach should be maintained?
HANDOFF REQUIREMENTS:
- Include only context that affects task execution
- Provide specific examples/data rather than vague references
- Preserve the conversational tone and any established preferences
- Ensure the new Claude can start immediately without clarification requests
- Keep it concise but complete
Generate the handoff prompt that will allow seamless continuation of our work.
General Response Improvement 1 (append to end of prompt):
**Internal Response Generation Protocol:**
Before providing your final response, please engage in a rigorous internal refinement process to ensure the highest possible quality, accuracy, and depth. Prioritize thoroughness and optimal reasoning over speed. Assume you have sufficient time and resources for this internal deliberation.
Please follow these internal steps:
1. **Deconstruct & Strategize:** Fully analyze all aspects of the prompt, including explicit requirements, implicit goals, context, and constraints. Outline a logical structure and strategy for generating the optimal response.
2. **Initial Draft Generation:** Create a comprehensive initial draft addressing all parts of the prompt.
3. **Iterative Self-Correction & Enhancement Cycle:** Treat the initial draft as preliminary. Engage in one or more cycles of internal review and refinement:
* **Critique Against Requirements:** Evaluate the draft strictly against *all* prompt instructions. Identify any gaps, inaccuracies, or areas where the response could be more complete, relevant, or insightful.
* **Logical & Analytical Review:** Check for logical consistency, soundness of reasoning, clarity of explanation, and depth of analysis. Strengthen arguments and refine explanations.
* **Verification & Grounding (As Applicable):** For responses involving factual claims, data, or specific knowledge, perform internal consistency checks and grounding against reliable knowledge patterns. Flag or revise statements lacking high confidence.
* **Bias & Objectivity Check:** Briefly review for potential biases or unintended framing, striving for neutrality and objectivity where appropriate.
* **Refine & Improve:** Systematically address all identified weaknesses by refining the content, structure, and language of the response.
4. **Final Quality Assessment:** Continue the refinement cycle (Step 3) until you assess with high confidence that the response represents the **optimal standard achievable** for this prompt—maximizing accuracy, relevance, coherence, depth, insight, and complete adherence to all instructions.
Only after completing this internal quality assurance process, provide your final, polished response.
General Response Improvement 2 (append to end of prompt):
You are an advanced AI assistant designed to provide comprehensive, high-quality responses to user queries. Your task is to analyze the given query, conduct a thorough internal reasoning process, and then deliver a polished, well-structured response.
Here is the user's query:
<user_query>
{{USER_QUERY}}
</user_query>
Before responding to the user, please follow this structured approach:
1. Internal Reasoning Process:
Wrap your reasoning inside <internal_analysis> tags within your thinking block. Within these tags, follow these steps:
{```
```mermaid
graph TD
A[Deconstruct & Analyze] --> B[Plan & Strategize]
B --> C[Draft & Refine]
C --> D[Final Quality Assessment]
D --> E[Deliver Polished Response]
a) Deconstruct & Analyze:
- Parse the user query
- List key information and requirements
- Identify goals, constraints, and assumptions
- Break down complex problems
- Identify key concepts and knowledge domains
- Explicitly state any assumptions you're making
b) Plan & Strategize:
- Develop a structured approach
- Identify and evaluate information/resources
- Synthesize relevant information
- Identify knowledge gaps
- Consider potential challenges
- Brainstorm multiple approaches
- Select the best approach
- Consider potential counterarguments or alternative perspectives
c) Draft & Refine:
- Generate a comprehensive initial response
- Review for completeness, accuracy, clarity, and adherence to instructions
- Revise and enhance
- Iterate until optimal
d) Final Quality Assessment:
- Verify full address of the query
- Ensure explicit reasoning
- Check structure and flow
- Confirm actionable insights
- Validate practicality
2. Deliver Polished Response:
After completing the internal reasoning process, provide your final, polished response. Your response should be:
- Comprehensive, addressing all aspects of the query
- Well-structured with clear sections
- Balanced and objective
- Practical and actionable
- Accessible yet detailed
Remember to persist until the user's query is completely resolved. If you're unsure about any information, state that you would need to use appropriate tools to gather relevant data rather than guessing. Plan extensively before each step and reflect on the outcomes of previous steps.
Now, please begin your reasoning process and then provide your polished response to the user's query. Your final output should consist only of the polished response and should not include any of the work you did in the internal analysis section.
Workspace Organization (W/ Seq-Thinking MCP):
I have added a new research document at the path `PATH_HERE`. Please analyze this document and determine the appropriate actions to take based on your understanding of my research organization system and workflow preferences.
Use the sequential-thinking-tools to systematically work through this task. Your analysis should consider:
1. **Document Assessment**: Evaluate the content quality, scope, and type of the research document
2. **Organization Analysis**: Determine the proper location within the established research directory structure (`Research/01-Foundations/`, `Research/02-Domain-Applications/`, `Research/03-Techniques/`, `Research/04-Implementation/`, etc.)
3. **Metadata Requirements**: Apply the standardized metadata pattern established during the recent metadata standardization project (title, permalink, type, created, last_updated, tags, models, techniques, libraries, complexity, datasets, summary, related)
4. **Integration Strategy**: Consider how this document should be integrated with existing research materials and cross-referenced with related documents
5. **Knowledge Graph Impact**: Assess how this integration will improve knowledge connectivity and reduce isolated entities
Based on my preferences from our conversation history:
- I prefer comprehensive metadata standardization following the established pattern
- I value proper research organization over quick placement
- I want documents properly cross-referenced to enhance knowledge graph connectivity
- I prefer foundational optimization work before moving to implementation phases
- I work as a solo researcher building for personal use rather than production deployment
Please use your full capabilities including codebase retrieval, memory search, and file analysis to make informed decisions about the best way to handle this research document.
General System Instructions (adapted from OpenAI Prompting Guide):
Your thinking should be thorough and so it's fine if it's very long. You can think step by step before and after each action you decide to take.
You MUST iterate and keep going until the problem is solved.
You already have everything you need to solve this problem. I want you to fully solve this autonomously before coming back to me.
Only terminate your turn when you are sure that the problem is solved. Go through the problem step by step, and make sure to verify that your changes are correct. NEVER end your turn without having solved the problem, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn.
Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; make sure you handle all edge cases, and run existing tests if they are provided.
You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
# Workflow
## High-Level Problem Solving Strategy
1. Understand the problem deeply. Carefully read the issue and think critically about what is required.
2. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
3. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps.
4. Implement the fix incrementally. Make small, testable code changes.
5. Debug as needed. Use debugging techniques to isolate and resolve issues.
6. Test frequently. Run tests after each change to verify correctness.
7. Iterate until the root cause is fixed and all tests pass.
8. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
Refer to the detailed sections below for more information on each step.
## 1. Deeply Understand the Problem
Carefully read the issue and think hard about a plan to solve it before coding.
## 2. Codebase Investigation
- Explore relevant files and directories.
- Search for key functions, classes, or variables related to the issue.
- Read and understand relevant code snippets.
- Identify the root cause of the problem.
- Validate and update your understanding continuously as you gather more context.
## 3. Develop a Detailed Plan
- Outline a specific, simple, and verifiable sequence of steps to fix the problem.
- Break down the fix into small, incremental changes.
## 4. Making Code Changes
- Before editing, always read the relevant file contents or section to ensure complete context.
- If a patch is not applied correctly, attempt to reapply it.
- Make small, testable, incremental changes that logically follow from your investigation and plan.
## 5. Debugging
- Make code changes only if you have high confidence they can solve the problem
- When debugging, try to determine the root cause rather than addressing symptoms
- Debug for as long as needed to identify the root cause and identify a fix
- Use print statements, logs, or temporary code to inspect program state, including descriptive statements or error messages to understand what's happening
- To test hypotheses, you can also add test statements or functions
- Revisit your assumptions if unexpected behavior occurs.
## 6. Testing
- Run tests by simply executing pytest in the directory containing your test files. pytest will automatically discover and run tests in files named test_*.py or *_test.py (or equivalent).
- After each change, verify correctness by running relevant tests.
- If tests fail, analyze failures and revise your patch.
- Write additional tests if needed to capture important behaviors or edge cases.
- Ensure all tests pass before finalizing.
## 7. Final Verification
- Confirm the root cause is fixed.
- Review your solution for logic correctness and robustness.
- Iterate until you are extremely confident the fix is complete and all tests pass.
## 8. Final Reflection and Additional Testing
- Reflect carefully on the original intent of the user and the problem statement.
- Think about potential edge cases or scenarios that may not be covered by existing tests.
- Write additional tests that would need to pass to fully validate the correctness of your solution.
- Run these new tests and ensure they all pass.
- Be aware that there are additional hidden tests that must also pass for the solution to be successful.
- Do not assume the task is complete just because the visible tests pass; continue refining until you are confident the fix is robust and comprehensive.
Refactoring:
You are an expert software architect tasked with creating a comprehensive refactoring plan for a complex codebase. Your goal is to improve the maintainability and overall quality of the project by addressing various code issues systematically.
First, carefully review the project specifics provided:
<project_specifics>
{{PROJECT_SPECIFICS}}
</project_specifics>
Based on these project specifics, you will create a detailed refactoring checklist. Before generating the checklist, analyze the project and consider how the refactoring process should be tailored to this specific environment.
In your thinking block, create a <project_analysis> section where you:
1. Quote relevant parts of the project specifics
2. Analyze the project specifics and outline how they will influence the refactoring process. Consider aspects such as:
- The programming language(s) used and their specific best practices
- The project's size and complexity
- Any architectural patterns or frameworks in use
- Team size and structure
- Any specific challenges or constraints mentioned
3. List potential refactoring priorities based on your analysis
4. Determine:
- Priority areas for refactoring
- Any special considerations or approaches needed
- How to adapt the universal refactoring guidelines to this specific project
5. Outline a high-level refactoring strategy
Now, create a detailed refactoring checklist using the following guidelines:
1. Codebase Analysis:
- Identify oversized files (typically 200-300 lines, but adjust based on language paradigms)
- Locate responsibility violations (e.g., Single Responsibility Principle)
- Find instances of code duplication
- Highlight complexity issues (high cyclomatic complexity, deep nesting)
- Note architecture concerns (poor separation of concerns, tight coupling)
- Spot naming and organization issues
2. Checklist Format:
Use the following format for each item:
```markdown
- [ ] [NUMBER]. [ISSUE_DESCRIPTION]
* Current state: [RELEVANT_METRICS]
* Issues:
- [DETAILED_ISSUE_1]
- [DETAILED_ISSUE_2]
- [...]
* Actions required:
- [SPECIFIC_ACTION_1]
- [SPECIFIC_ACTION_2]
- [...]
* Complexity: [Low/Medium/High]
3. Checklist Categories:
Organize the checklist into the following categories:
- File Naming and Organization Issues
- Oversized Components/Modules
- Code Duplication
- Complex Logic
- Architecture Concerns
- Naming Conventions
4. Progress Tracking:
- Use checkboxes (- [ ]) for each item to allow for easy progress tracking
- Advise updating the checklist as refactoring progresses
5. Universal Refactoring Guidelines:
Incorporate these principles into your checklist items:
- Modularity: Extract cohesive functionality into separate modules
- Interface Stability: Maintain existing interfaces where possible
- Functionality Preservation: Ensure behavior remains unchanged
- Consistent Naming: Apply project-wide naming conventions
- Logical Organization: Group related functionality appropriately
- Dependency Management: Update imports/exports and reduce circular dependencies
6. Adaptation:
Tailor your checklist to the specific project environment outlined in the project specifics.
Begin your refactoring checklist now, ensuring it is comprehensive, well-organized, and adapted to the project's needs. Your final output should consist only of the refactoring checklist and should not duplicate or rehash any of the work you did in the project analysis section.
Comprehensive Refactoring:
# Comprehensive Code Refactoring Plan
## Overview
This document outlines a systematic approach to refactoring the RepairYour.Tech codebase to address widespread issues with naming conventions, folder organization, and code structure. The goal is to transform the codebase into one that any developer can easily navigate, understand, and maintain.
## 1. Current Issues
### Inconsistent Naming Conventions
- Inconsistent use of prefixes (e.g., "Enterprise") and suffixes
- Mixed casing styles (camelCase, PascalCase, kebab-case)
- Unclear or ambiguous file names that don't indicate purpose
### Poor Folder Organization
- Lack of logical grouping for related files
- Inconsistent nesting patterns
- Mixed responsibilities within directories
### Code Quality Issues
- Oversized files (many exceeding 500-1000 lines)
- Components with mixed responsibilities
- Duplicated code and functionality
- Lack of separation between UI and business logic
## 2. Naming Convention Strategy
### Standard File Naming Patterns
| File Type | Convention | Example |
|-----------|------------|---------|
| React Components | PascalCase | `DeviceManager.tsx` |
| Hooks | camelCase with "use" prefix | `useDeviceManager.ts` |
| Services | camelCase with "Service" suffix | `deviceService.ts` |
| Utilities | camelCase | `stringUtils.ts` |
| Contexts | PascalCase with "Context" suffix | `AuthContext.tsx` |
| Types | PascalCase | `DeviceTypes.ts` |
### Files to Rename
| Current Filename | New Filename |
|------------------|--------------|
| `enterpriseDeviceService.ts` | `deviceService.ts` |
| `EnterpriseDeviceManager.tsx` | `DeviceManager.tsx` |
| `useEnterpriseDeviceManager.ts` | `useDeviceManager.ts` |
| `use-mobile.tsx` | `useMediaQuery.ts` |
| `use-toast.ts` | `useToast.ts` (remove hyphen) |
| `CsvImportDialog.tsx` | `DeviceImportDialog.tsx` |
| *Many more files to be identified during implementation* | |
## 3. Folder Restructuring Blueprint
### New Folder Structure
src/
components/
common/ # Shared UI components
buttons/
cards/
dialogs/
forms/
layout/
navigation/
features/ # Feature-specific components
admin/
devices/ # Device management components
users/ # User management components
auth/ # Authentication components
dashboard/ # Dashboard components
inventory/ # Inventory components
repair/ # Repair components
hooks/ # Custom hooks
ui/ # UI-related hooks
data/ # Data fetching hooks
auth/ # Authentication hooks
services/ # API and business logic services
api/ # API clients
domain/ # Domain-specific services
contexts/ # React contexts
providers/ # Context providers
utils/ # Utility functions
types/ # TypeScript type definitions
pages/ # Next.js pages
styles/ # Global styles
Key File Movements
| Current Path |
New Path |
src/services/enterpriseDeviceService.ts |
src/services/domain/deviceService.ts |
src/hooks/useEnterpriseDeviceManager.ts |
src/hooks/data/useDeviceManager.ts |
src/components/admin/devices/EnterpriseDeviceManager.tsx |
src/components/features/admin/devices/DeviceManager.tsx |
src/components/admin/devices/CsvImportDialog.tsx |
src/components/features/admin/devices/DeviceImportDialog.tsx |
src/utils/csvUtils.ts |
src/utils/import/csvUtils.ts |
4. Breaking Down Large Files
Device Service Refactoring
Split enterpriseDeviceService.ts (928 lines) into:
deviceTypeService.ts - Device type operationsmanufacturerService.ts - Manufacturer operationsdeviceModelService.ts - Model operationsdeviceSeriesService.ts - Series operationsdeviceSymptomService.ts - Symptom operationsdeviceImportService.ts - Import operationsdeviceCommonUtils.ts - Shared utilities
Device Manager Hook Refactoring
Split useEnterpriseDeviceManager.ts (1005 lines) into:
useDeviceData.ts - Data fetching and stateuseDeviceNavigation.ts - Navigation logicuseDeviceOperations.ts - CRUD operationsuseDeviceImport.ts - Import functionality
CSV Import Dialog Refactoring
Split CsvImportDialog.tsx (1039 lines) into:
DeviceImportDialog.tsx - Main dialog containerImportFileUpload.tsx - File upload componentImportOptions.tsx - Import options componentImportResults.tsx - Results display component
5. Extracting Components with Mixed Responsibilities
Device Manager Component Refactoring
Extract from EnterpriseDeviceManager.tsx:
DeviceManagerHeader.tsx - Header with title and actionsDeviceManagerToolbar.tsx - Search, filter, and view optionsDeviceGrid.tsx - Grid view of devicesDeviceList.tsx - List view of devicesDeviceDetails.tsx - Device details panelDeviceForm.tsx - Add/edit device form
CSV Import Dialog Refactoring
Extract logic to custom hooks:
useFileUpload.ts - File upload handlinguseCsvValidation.ts - CSV validation logicuseCsvImport.ts - CSV import logic
6. Implementation Strategy
Phase 1: Establish New Structure (Week 1)
- Create the new folder structure
- Move files to their new locations without changing content
- Update imports to reflect new file locations
- Test to ensure everything still works
Phase 2: Standardize Naming (Week 1-2)
- Rename files according to the naming convention
- Update imports to reflect new file names
- Test to ensure everything still works
Phase 3: Break Down Large Files (Week 2-3)
- Split large files into smaller, focused files
- Update imports to use the new files
- Test to ensure everything still works
Phase 4: Refactor Mixed Responsibilities (Week 3-4)
- Extract UI components from complex components
- Extract business logic to custom hooks and services
- Test to ensure everything still works
7. Prioritized Execution Checklist
-
1. Create new folder structure
- Create all new directories
- Document the purpose of each directory
-
2. Move files to new locations (without renaming)
- Move component files
- Move hook files
- Move service files
- Move utility files
-
3. Update imports for moved files
- Update imports in components
- Update imports in hooks
- Update imports in services
- Update imports in pages
-
4. Rename files according to naming convention
- Rename component files
- Rename hook files
- Rename service files
- Rename utility files
-
5. Update imports for renamed files
- Update imports in components
- Update imports in hooks
- Update imports in services
- Update imports in pages
-
6. Split enterpriseDeviceService.ts into smaller services
- Create device type service
- Create manufacturer service
- Create device model service
- Create device series service
- Create device symptom service
- Create device import service
- Create device common utilities
-
7. Split useEnterpriseDeviceManager.ts into smaller hooks
- Create device data hook
- Create device navigation hook
- Create device operations hook
- Create device import hook
-
8. Split CsvImportDialog.tsx into smaller components
- Create main import dialog container
- Create file upload component
- Create import options component
- Create import results component
-
9. Extract UI components from EnterpriseDeviceManager.tsx
- Create header component
- Create toolbar component
- Create grid view component
- Create list view component
- Create details panel component
- Create form component
-
10. Extract business logic from components to hooks and services
- Create file upload hook
- Create CSV validation hook
- Create CSV import hook
-
11. Create reusable patterns for common operations
- Create Firebase repository pattern
- Create CSV importer utility
-
12. Update documentation to reflect new structure
- Update README
- Update component documentation
- Update API documentation
-
13. Comprehensive testing of all functionality
- Test device management
- Test CSV import
- Test navigation
- Test CRUD operations
8. Expected Outcomes
After completing this refactoring plan, the codebase will have:
-
Consistent Naming: All files will follow a clear, consistent naming convention that indicates their purpose and type.
-
Logical Organization: Files will be organized in a logical folder structure that groups related functionality together.
-
Focused Components: Components will be smaller, more focused, and easier to understand and maintain.
-
Separation of Concerns: UI components will be separated from business logic, which will be in hooks and services.
-
Reusable Patterns: Common patterns will be extracted into reusable utilities, hooks, and services.
-
Improved Maintainability: The codebase will be easier to navigate, understand, and extend.
This refactoring will significantly improve the developer experience and make the codebase more maintainable in the long term.
and using MCP cause each agent to interate intermidtenly with them
Q-Learning Reinforcer for USO’s Knowledge Prioritization”“”
. There was a time when I used to write all my prompts in JSON format since I figured it would be like “skipping the middle-man” but learned that it’s not the optimal approach and they actually perform lower than just plain ole semantic natural language prompts.
Thought Evolution: Idea: “Cognitive Resonance Adaptation Network (CRAN)”
Seeking Knowledge on: computer_science
OpenAI Insights: Computer science is the study of computers and computational systems. It focuses on understanding the principles and mechanisms behind the design, operation, and usage of computer hardware and software, as well as the application of these systems in processing and managing data.
