@el-j/magic-helix-core 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/default_templates/java/build-maven.md

@@ -1,86 +0,0 @@
-# Maven Build Tool Instructions
-
-## Project Structure
-```
-project/
-├── pom.xml
-├── src/
-│   ├── main/
-│   │   ├── java/
-│   │   └── resources/
-│   └── test/
-│       ├── java/
-│       └── resources/
-└── target/
-```
-
-## Common Commands
-
-```bash
-# Build lifecycle
-./mvnw clean              # Clean build artifacts
-./mvnw compile            # Compile source code
-./mvnw test               # Run tests
-./mvnw package            # Package as JAR/WAR
-./mvnw install            # Install to local repo
-./mvnw deploy             # Deploy to remote repo
-
-# Spring Boot
-./mvnw spring-boot:run    # Run application
-
-# Dependency management
-./mvnw dependency:tree    # Show dependency tree
-./mvnw dependency:resolve # Download dependencies
-./mvnw versions:display-dependency-updates  # Check for updates
-```
-
-## Docker Optimization
-
-### Layer Caching Strategy
-```dockerfile
-# Download dependencies in separate layer
-FROM maven:3.9-eclipse-temurin-17 AS deps
-WORKDIR /app
-COPY pom.xml .
-RUN mvn dependency:go-offline
-
-# Build application
-FROM deps AS build
-COPY src ./src
-RUN mvn package -DskipTests
-
-# Runtime
-FROM eclipse-temurin:17-jre-alpine
-COPY --from=build /app/target/*.jar app.jar
-CMD ["java", "-jar", "app.jar"]
-```
-
-## Best Practices
-
-- Use Maven Wrapper (./mvnw) for consistent builds
-- Define dependency versions in `<dependencyManagement>`
-- Use Spring Boot BOM for version management
-- Leverage profiles for different environments
-- Keep plugins up to date
-
-## POM Configuration Tips
-
-```xml
-<properties>
-    <java.version>17</java.version>
-    <maven.compiler.source>17</maven.compiler.source>
-    <maven.compiler.target>17</maven.compiler.target>
-</properties>
-
-<dependencyManagement>
-    <dependencies>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-dependencies</artifactId>
-            <version>${spring-boot.version}</version>
-            <type>pom</type>
-            <scope>import</scope>
-        </dependency>
-    </dependencies>
-</dependencyManagement>
-```

package/dist/default_templates/java/framework-spring-boot.md

@@ -1,179 +0,0 @@
-# Spring Boot Framework Instructions
-
-## Architecture Patterns
-
-### Layered Architecture
-```
-Controller → Service → Repository → Database
-```
-
-### Controller Layer
-```java
-@RestController
-@RequestMapping("/api/users")
-public class UserController {
-    
-    private final UserService userService;
-    
-    public UserController(UserService userService) {
-        this.userService = userService;
-    }
-    
-    @GetMapping("/{id}")
-    public ResponseEntity<User> getUser(@PathVariable Long id) {
-        return userService.findById(id)
-            .map(ResponseEntity::ok)
-            .orElse(ResponseEntity.notFound().build());
-    }
-}
-```
-
-### Service Layer
-```java
-@Service
-public class UserService {
-    
-    private final UserRepository repository;
-    
-    @Transactional
-    public User createUser(User user) {
-        return repository.save(user);
-    }
-}
-```
-
-### Repository Layer
-```java
-@Repository
-public interface UserRepository extends JpaRepository<User, Long> {
-    Optional<User> findByEmail(String email);
-}
-```
-
-## Configuration
-
-### application.yml
-```yaml
-spring:
-  datasource:
-    url: jdbc:postgresql://localhost:5432/mydb
-    username: ${DB_USER}
-    password: ${DB_PASSWORD}
-  jpa:
-    hibernate:
-      ddl-auto: validate
-    properties:
-      hibernate:
-        dialect: org.hibernate.dialect.PostgreSQLDialect
-  
-server:
-  port: 8080
-```
-
-## Docker Best Practices
-
-### Optimized Dockerfile
-```dockerfile
-FROM eclipse-temurin:17-jre-alpine
-WORKDIR /app
-
-# Add non-root user
-RUN addgroup -S spring && adduser -S spring -G spring
-USER spring:spring
-
-COPY --chown=spring:spring target/*.jar app.jar
-
-# JVM optimization for containers
-ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
-
-EXPOSE 8080
-ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]
-```
-
-### Health Checks
-```yaml
-# docker-compose.yml
-services:
-  app:
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-```
-
-## Production Readiness
-
-### Actuator Endpoints
-```xml
-<dependency>
-    <groupId>org.springframework.boot</groupId>
-    <artifactId>spring-boot-starter-actuator</artifactId>
-</dependency>
-```
-
-### Security
-```java
-@Configuration
-@EnableWebSecurity
-public class SecurityConfig {
-    
-    @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
-        http
-            .authorizeHttpRequests(auth -> auth
-                .requestMatchers("/actuator/health").permitAll()
-                .anyRequest().authenticated()
-            )
-            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
-        return http.build();
-    }
-}
-```
-
-## Testing
-
-### Integration Tests
-```java
-@SpringBootTest
-@AutoConfigureMockMvc
-class UserControllerIntegrationTest {
-    
-    @Autowired
-    private MockMvc mockMvc;
-    
-    @Test
-    void shouldGetUser() throws Exception {
-        mockMvc.perform(get("/api/users/1"))
-            .andExpect(status().isOk())
-            .andExpect(jsonPath("$.name").value("John"));
-    }
-}
-```
-
-### Test Containers
-```java
-@Testcontainers
-@SpringBootTest
-class RepositoryIntegrationTest {
-    
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine");
-    
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-    }
-}
-```
-
-## Performance
-
-- Use connection pooling (HikariCP is default)
-- Enable HTTP/2
-- Use caching (@Cacheable, @CacheEvict)
-- Implement pagination for large datasets
-- Use async processing with @Async where appropriate
-- Monitor with Micrometer metrics

package/dist/default_templates/java/lang-java.md

@@ -1,78 +0,0 @@
-# Java/Kotlin Language Instructions
-
-## Project Type
-- Language: Java/Kotlin
-- Build Tool: {Maven|Gradle}
-- Framework: {Spring Boot|Micronaut|Quarkus|None}
-
-## Build Commands
-
-### Maven
-```bash
-./mvnw clean install    # Build project
-./mvnw test            # Run tests
-./mvnw spring-boot:run # Run Spring Boot app
-```
-
-### Gradle
-```bash
-./gradlew build        # Build project
-./gradlew test         # Run tests
-./gradlew bootRun      # Run Spring Boot app
-```
-
-## Code Conventions
-
-### Java
-- Follow Java naming conventions (PascalCase for classes, camelCase for methods)
-- Use meaningful variable names
-- Prefer immutability where possible
-- Use Optional for nullable values
-- Handle exceptions appropriately
-
-### Kotlin
-- Use data classes for DTOs
-- Leverage null safety features
-- Use extension functions appropriately
-- Prefer immutability (val over var)
-- Use scope functions (let, apply, run, with)
-
-## Docker Optimization
-
-### Multi-stage Dockerfile Example (Maven)
-```dockerfile
-FROM maven:3.9-eclipse-temurin-17 AS build
-WORKDIR /app
-COPY pom.xml .
-RUN mvn dependency:go-offline
-COPY src ./src
-RUN mvn clean package -DskipTests
-
-FROM eclipse-temurin:17-jre-alpine
-WORKDIR /app
-COPY --from=build /app/target/*.jar app.jar
-EXPOSE 8080
-ENTRYPOINT ["java", "-jar", "app.jar"]
-```
-
-### JVM Tuning for Containers
-```bash
-# Use container-aware JVM flags
-java -XX:+UseContainerSupport \
-     -XX:MaxRAMPercentage=75.0 \
-     -XX:InitialRAMPercentage=50.0 \
-     -jar app.jar
-```
-
-## Testing
-
-- Use JUnit 5 for unit tests
-- Use Mockito for mocking
-- Use Testcontainers for integration tests
-- Maintain test coverage >80%
-
-## Dependencies
-
-- Keep dependencies up to date
-- Use dependency management (Maven BOM, Gradle platform)
-- Scan for vulnerabilities regularly

package/dist/default_templates/java/lang-kotlin.md

@@ -1,88 +0,0 @@
-# Kotlin Specific Instructions
-
-## Language Features
-
-### Null Safety
-```kotlin
-// Use nullable types explicitly
-val name: String? = null
-val length = name?.length ?: 0
-
-// Safe calls
-user?.address?.city
-```
-
-### Data Classes
-```kotlin
-data class User(
-    val id: Long,
-    val name: String,
-    val email: String
-)
-```
-
-### Extension Functions
-```kotlin
-fun String.toSnakeCase(): String = 
-    this.replace(Regex("([a-z])([A-Z])"), "$1_$2").lowercase()
-```
-
-### Coroutines (Async)
-```kotlin
-suspend fun fetchData(): Data {
-    return withContext(Dispatchers.IO) {
-        // IO operation
-    }
-}
-```
-
-## Spring Boot with Kotlin
-
-### Controller Example
-```kotlin
-@RestController
-@RequestMapping("/api/users")
-class UserController(private val userService: UserService) {
-    
-    @GetMapping("/{id}")
-    fun getUser(@PathVariable id: Long): User {
-        return userService.findById(id)
-    }
-}
-```
-
-### Service with Coroutines
-```kotlin
-@Service
-class UserService(private val repository: UserRepository) {
-    
-    suspend fun findAllAsync(): List<User> = 
-        withContext(Dispatchers.IO) {
-            repository.findAll()
-        }
-}
-```
-
-## Best Practices
-
-- Use `val` over `var` for immutability
-- Leverage sealed classes for state management
-- Use `when` expressions instead of multiple `if-else`
-- Apply scope functions appropriately (let, run, apply, also, with)
-- Use destructuring for data classes
-- Prefer sequences for large collections
-
-## Build Configuration
-
-### build.gradle.kts
-```kotlin
-plugins {
-    kotlin("jvm") version "1.9.20"
-    kotlin("plugin.spring") version "1.9.20"
-}
-
-dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
-}
-```

package/dist/default_templates/meta/magic-helix-meta.md

@@ -1,213 +0,0 @@
-# 🪄 Magic Helix: Universal AI Agent Optimization
-
-This instruction file teaches AI agents to work more efficiently with your codebase.
-
-## Core Principles for Effective Agent Work
-
-### 1. Task Management & Progress Tracking
-
-**Create structured todo lists** for multi-step work:
-- Break complex requests into 3-7 concrete, actionable steps
-- Mark tasks `in-progress` before starting
-- Mark tasks `completed` immediately after finishing
-- Update progress frequently for user visibility
-
-**Example workflow:**
-```
-User: "Add authentication to the app"
-
-Agent creates:
-1. [ ] Research existing auth patterns in codebase
-2. [ ] Create authentication middleware
-3. [ ] Add login/logout routes
-4. [ ] Update user model with auth fields
-5. [ ] Write tests for auth flows
-6. [ ] Update documentation
-```
-
-### 2. Efficient Context Gathering
-
-**Batch parallel operations** to minimize latency:
-- Read multiple files simultaneously, not sequentially
-- Search multiple patterns in one query using alternation: `(pattern1|pattern2|pattern3)`
-- Deduplicate file paths before reading to avoid redundant operations
-
-**Smart search strategies:**
-- Use `semantic_search` for high-level code discovery (finding similar implementations)
-- Use `grep_search` for specific strings/patterns in known areas
-- Use alternation in regex: `function|method|class` instead of multiple searches
-
-**Get enough context to act, then proceed** - don't over-research before implementation.
-
-### 3. Code Editing Best Practices
-
-**Read surrounding context** before editing:
-- Include 3-5 lines before and after the target code
-- Ensure `oldString` is unique enough to match only once
-- Verify the change won't break surrounding logic
-
-**Prefer batch edits** for independent changes:
-- Use `multi_replace_string_in_file` for multiple unrelated edits
-- One tool call is faster than sequential calls
-- Only works for truly independent changes (no dependencies between edits)
-
-**Verify after editing:**
-- Check for compilation/lint errors immediately
-- Run tests if modifying critical code
-- Read the file back if the change was complex
-
-### 4. Communication Style
-
-**Be concise and direct:**
-- Match response length to task complexity
-- No unnecessary preamble: avoid "I will now...", "Here's the...", "Let me..."
-- Confirm completions briefly: "Updated 3 files" not explaining each edit
-- Get straight to the point
-
-**Use proper formatting:**
-- Wrap code symbols in backticks: `functionName`, `fileName.ts`
-- Use code blocks for multi-line code
-- Use bullet points for lists
-- Bold important terms
-
-**Forbidden phrases:**
-- "Great!", "Certainly!", "Sure!", "Of course!"
-- "Let me help you with that"
-- Unnecessary apologies or enthusiasm
-- Redundant confirmations
-
-### 5. Tool Usage Guidelines
-
-**Check tool availability** before using:
-- Tools may be disabled or unavailable
-- Don't reference tools that aren't currently accessible
-
-**Never announce tool names** to users:
-- Say "I'll run the command" not "I'll use run_in_terminal"
-- Say "I'll search the codebase" not "I'll use semantic_search"
-- Focus on what you're doing, not how
-
-**Use absolute paths** for file operations:
-- Always resolve to full paths
-- Don't rely on relative paths
-- Handle URI schemes (untitled:, vscode-userdata:) correctly
-
-**Parallelize wisely:**
-- ✅ DO parallelize: file reads, searches, analysis
-- ❌ DON'T parallelize: terminal commands, sequential workflows
-
-### 6. Project Understanding
-
-**Start with high-level discovery:**
-1. Use `semantic_search` to understand codebase architecture
-2. Use `grep_search` for specific strings once you know where to look
-3. List directories to understand structure before making assumptions
-4. Check for errors with `get_errors` after making changes
-
-**Understand before implementing:**
-- Search for similar existing implementations
-- Identify patterns and conventions in the codebase
-- Match existing code style and architecture
-- Ask clarifying questions if requirements are ambiguous
-
-## Task-Specific Strategies
-
-### When Creating Roadmaps or Plans
-
-1. **Clarify the request**: Rephrase to confirm understanding
-2. **Research existing architecture**: Find similar features/patterns
-3. **Create phased plan**: Break into logical phases with dependencies
-4. **Define success criteria**: How will we know each phase is done?
-5. **Identify risks**: What could go wrong?
-
-### When Implementing Features
-
-1. **Search for similar implementations**: Learn from existing code
-2. **Identify all affected files**: Types, logic, tests, docs
-3. **Plan changes in logical order**: Types → interfaces → implementation → tests
-4. **Make incremental changes**: One logical unit at a time
-5. **Verify compilation**: Check after each major change
-6. **Update tests**: Ensure existing tests pass, add new ones
-
-### When Debugging Issues
-
-1. **Reproduce the error**: Verify it happens consistently
-2. **Read error messages completely**: Don't skim, read fully
-3. **Check recent changes**: Use git diff, check what changed
-4. **Form hypotheses**: List possible causes
-5. **Test incrementally**: Verify each hypothesis systematically
-6. **Fix root cause**: Don't just treat symptoms
-
-### When Refactoring Code
-
-1. **Understand current behavior**: Read and comprehend existing code
-2. **Ensure test coverage**: Write tests if missing
-3. **Make small changes**: Incremental refactors are safer
-4. **Verify tests pass**: After each refactor step
-5. **Maintain backwards compatibility**: Unless explicitly breaking
-6. **Update documentation**: Keep docs in sync
-
-## Error Handling & Recovery
-
-**When errors occur:**
-- Read the full error message (don't skip details)
-- Check the file and line number referenced
-- Look for stack traces or additional context
-- Try the obvious fix first
-- If stuck, ask for clarification
-
-**Never:**
-- Ignore compiler/lint errors
-- Assume success without verification
-- Continue with broken code
-- Skip error checking
-
-## File Operations Safety
-
-**Before modifying files:**
-1. Explain what you're about to change
-2. Show preview of changes when significant
-3. Wait for confirmation if potentially destructive
-4. Never assume success—verify the result
-
-**Never do without explicit permission:**
-- Delete files outside project directory
-- Modify system files
-- Install packages without showing changes
-- Execute shell commands with `sudo`
-- Include API keys or secrets in code
-
-## Performance & Efficiency
-
-**Minimize tool calls:**
-- Read once, not multiple times
-- Batch parallel operations
-- Search smart, not exhaustively
-- Cache information you've already retrieved
-
-**Respect token budgets:**
-- Be concise in responses
-- Don't repeat information unnecessarily
-- Summarize large outputs
-- Use code references instead of copying full files
-
-## Quality Standards
-
-**All code changes should:**
-- Follow existing code style
-- Include error handling
-- Be properly typed (if applicable)
-- Have meaningful names
-- Include comments for complex logic
-- Pass linting and formatting checks
-
-**All features should:**
-- Have tests
-- Update documentation
-- Handle edge cases
-- Provide good error messages
-- Be backwards compatible (unless breaking intentionally)
-
----
-
-*This meta-instruction file helps AI agents work more efficiently with your codebase. It's always included to improve agent performance.*