@laxture/vibe-pm 0.1.0

package/dist/docs/template/_coding_style/go.md

@@ -0,0 +1,158 @@
+# Go Coding Style
+
+## General Format
+
+- Use UTF-8 encoding uniformly, with LF line endings
+- Use gofmt / goimports to auto-format code (run automatically on save)
+- Use Tab for indentation
+- Recommended line length: no more than 120 characters
+- Keep one blank line at the end of the file
+
+## File Organization
+
+### Naming
+
+- Source files use `snake_case` (lowercase + underscores)
+- Directory names use `snake_case` (lowercase, concise)
+- Test files are named: `*_test.go`, in the same directory as the file under test
+- Package names use short lowercase words, avoid underscores
+
+### Import Grouping
+
+```go
+import (
+    // 1. Standard library
+    "fmt"
+    "os"
+
+    // 2. Third-party libraries
+    "github.com/gin-gonic/gin"
+
+    // 3. Internal project packages
+    "example.com/project/internal/models"
+)
+```
+
+### File Structure
+
+- One package per directory, package name matches directory name
+- Each file should ideally have only one primary export
+- Helper types/functions use named exports
+
+## Naming Conventions
+
+### Variables
+
+- Use `camelCase` (exported: `PascalCase`)
+- Short scope → short names: `i`, `item`, `ctx`
+- Long scope → descriptive names: `taskConfig`, `messageCount`
+- Boolean variables use question-word prefixes: `isActive`, `hasPlan`, `canProceed`
+
+### Constants
+
+- `PascalCase` or `camelCase` (exported: `PascalCase`)
+- Go does not use UPPER_SNAKE_CASE
+
+### Functions
+
+- Use `camelCase` (exported: `PascalCase`)
+- Start with a verb: `getTask`, `findFlow`, `createPlan`, `parseSpec`
+
+### Types and Structs
+
+- Use `PascalCase`
+- Interface names typically end with `-er` (e.g., `Reader`, `Writer`)
+- Go has no classes; use `PascalCase` for struct names
+
+### Enums
+
+Go has no native enums; use `const` + `iota`:
+
+```go
+type TaskStatus int
+
+const (
+    TaskStatusRunning TaskStatus = iota
+    TaskStatusCompleted
+    TaskStatusClosed
+)
+```
+
+## Type Safety
+
+### Rules
+
+- ✅ Use strong typing; avoid `interface{}` (prefer generics or concrete types)
+- ✅ Explicit error handling: check `if err != nil` for every call that may fail
+- ✅ Use `go vet` and `staticcheck` for static analysis
+- ❌ Never ignore returned error values
+
+## Function Design
+
+### Parameters
+
+- Use a struct parameter when there are more than 3 parameters
+
+### Return Values
+
+- `(T, error)` tuple
+
+## Control Flow
+
+- Prefer early returns to reduce nesting
+- `switch` does not need `break`; use `fallthrough` for explicit fall-through
+
+## Async Handling
+
+- Use goroutine + channel for concurrency
+- Use `context.Context` to propagate cancellation signals and timeouts
+- Use `sync.WaitGroup` / `errgroup` to manage concurrency
+
+```go
+func LoadTask(ctx context.Context, sessionID string) (*Task, error) {
+    // ...
+}
+```
+
+## Error Handling
+
+- Explicitly handle errors for every call that may fail
+- Error messages start with a lowercase letter and do not end with punctuation
+- Use `fmt.Errorf` to wrap errors
+
+```go
+data, err := db.Query("SELECT * FROM tasks WHERE session_id = ?", sessionID)
+if err != nil {
+    return nil, fmt.Errorf("failed to load task: %w", err)
+}
+```
+
+## Logging
+
+- Use structured logging libraries (e.g., `slog`, `zap`)
+- Log messages use English
+
+```go
+slog.Info("task created", "sessionID", sessionID)
+slog.Error("failed to load task", "error", err)
+```
+
+## Comments and Documentation
+
+- Code comments use English
+- Exported types/functions must have doc comments (starting with the name)
+- Add explanatory comments for complex logic
+
+## Placeholder Code
+
+```go
+// TODO(username): Needs API integration — planned for v1.1
+// FIXME(username): Possible data race under concurrency — needs locking
+// HACK(username): Temporary workaround — replace after v1.0
+```
+
+## Export Conventions
+
+- Capitalized first letter = exported (public)
+- Lowercase first letter = package-private (private)
+- Avoid exporting unnecessary symbols

package/dist/docs/template/_coding_style/java.md

@@ -0,0 +1,154 @@
+# Java Coding Style
+
+## General Format
+
+- Use UTF-8 encoding uniformly, LF for line endings
+- Use Spotless / google-java-format for automatic code formatting
+- Use 4 spaces for indentation, no tabs
+- Recommended line length: max 120 characters
+- Keep one blank line at end of file
+
+## File Organization
+
+### Naming
+
+- Source files use `PascalCase` (one public class per file)
+- Directory names use `snake_case` or follow package naming conventions
+- Test file naming: `*Test.java`, mirroring `src/main/` structure under `src/test/`
+- Package names are all lowercase, using reverse domain notation (e.g. `com.example.project`)
+
+### Import Grouping
+
+```java
+// 1. Static imports
+import static org.junit.Assert.*;
+
+// 2. Java standard library
+import java.util.List;
+import java.util.Optional;
+
+// 3. Third-party libraries
+import com.google.common.collect.ImmutableList;
+
+// 4. Project internals
+import com.example.project.core.TaskState;
+```
+
+### File Structure
+
+- One top-level class per file, class name matches file name
+- Each file should ideally have only one main export
+- Helper types/functions use named exports
+
+## Naming Conventions
+
+### Variables
+
+- Use `camelCase`
+- Short scope: short names, e.g. `i`, `item`, `ctx`
+- Long scope: descriptive names, e.g. `taskConfig`, `messageCount`
+- Boolean variables: question-word prefix, e.g. `isActive`, `hasPlan`, `canProceed`
+
+### Constants
+
+- `UPPER_SNAKE_CASE` (`static final` fields)
+
+### Functions
+
+- Use `camelCase`
+- Verb-prefixed: `getTask`, `findFlow`, `createPlan`, `parseSpec`
+
+### Types and Interfaces
+
+- Use `PascalCase`
+- No `I` prefix for interface names
+
+### Enums
+
+Use `enum`, members in `UPPER_SNAKE_CASE`:
+
+```java
+public enum TaskStatus {
+    RUNNING,
+    COMPLETED,
+    CLOSED
+}
+```
+
+## Type Safety
+
+### Rules
+
+- ✅ Use generics to avoid raw types
+- ✅ Use `Optional<T>` instead of returning null
+- ✅ Use `final` for immutable fields
+- ❌ Never catch `Exception` and swallow it
+
+## Function Design
+
+### Parameters
+
+- Use Builder pattern for complex construction when exceeding 3 parameters
+
+### Return Values
+
+- `Optional<T>` or custom `Result<T, E>`
+
+## Async Handling
+
+- Use `CompletableFuture<T>` or reactive frameworks
+- Async methods return `Future<T>`
+
+```java
+public CompletableFuture<Optional<Task>> loadTask(String sessionId) {
+    return db.queryAsync("SELECT * FROM tasks WHERE session_id = ?", sessionId)
+        .thenApply(data -> data != null ? Task.fromRow(data) : null);
+}
+```
+
+## Error Handling
+
+- Catch specific exception types
+- Use custom exception classes
+- Release resources in `finally` (or use try-with-resources)
+
+```java
+try {
+    var result = riskyOperation();
+} catch (IOException e) {
+    logger.error("Operation failed", e);
+    throw new OperationException("Failed to complete operation", e);
+}
+```
+
+## Logging
+
+- Use SLF4J + Logback
+- Log messages in English
+
+```java
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+private static final Logger logger = LoggerFactory.getLogger(TaskService.class);
+logger.info("Task created, sessionId={}", sessionId);
+logger.error("Failed to load task", e);
+```
+
+## Comments and Documentation
+
+- Code comments in English
+- Use Javadoc for public APIs
+- Add explanatory comments for complex logic
+
+## Placeholder Code
+
+```java
+// TODO(username): Need to integrate API — estimated v1.1
+// FIXME(username): Possible data race in concurrent scenario — need locking
+// HACK(username): Temporary workaround — replace after v1.0
+```
+
+## Export Conventions
+
+Use `public` / `protected` / package-private to control visibility

package/dist/docs/template/_coding_style/python.md

@@ -0,0 +1,195 @@
+# Python Coding Style
+
+## General Formatting
+
+- Use UTF-8 encoding with LF line endings
+- Use Black + isort for automatic code formatting (run on save)
+- Indent with 4 spaces, do not use tabs
+- Recommended line length: no more than 88 characters
+- Keep one blank line at the end of the file
+
+## File Organization
+
+### Naming
+
+- Source files use `snake_case`
+- Directory names use `snake_case`
+- Test file naming: `test_*.py` or `*_test.py`
+
+### Import Grouping
+
+```python
+# 1. Standard library
+import os
+from pathlib import Path
+
+# 2. Third-party libraries
+import requests
+from pydantic import BaseModel
+
+# 3. Project internal modules
+from app.core.config import settings
+from app.models.user import User
+```
+
+### File Structure
+
+- Each file should ideally have one main export
+- Use named exports for helper types/functions
+- Modules should expose a clean public API
+
+## Naming Conventions
+
+### Variables
+
+- Use `snake_case`
+- Short scope uses short names: `i`, `item`, `ctx`
+- Long scope uses descriptive names: `task_config`, `message_count`
+- Boolean variables use interrogative prefixes: `is_active`, `has_plan`, `can_proceed`
+- Do not use Hungarian notation
+
+### Constants
+
+- `UPPER_SNAKE_CASE`
+
+```python
+DEFAULT_LANGUAGE = "zh-CN"
+MAX_RETRY_COUNT = 3
+```
+
+### Functions
+
+- Use `snake_case`
+- Start with a verb: `get_task`, `find_flow`, `create_plan`, `parse_spec`
+- Event handler functions: `handle_xxx` or `on_xxx`
+
+### Types and Classes
+
+- Use `PascalCase`
+- Follow PEP 8, class names use CapWords
+
+```python
+class TaskState:
+    session_id: str
+    flow: str
+    current_step: str
+```
+
+### Enums
+
+Use `Enum`, members use `UPPER_SNAKE_CASE`
+
+```python
+from enum import Enum
+
+class TaskStatus(Enum):
+    RUNNING = "running"
+    COMPLETED = "completed"
+    CLOSED = "closed"
+```
+
+## Type Safety
+
+### Recommended Practices
+
+```python
+# ✅ Use type annotations
+def process(data: dict[str, object]) -> Result:
+    if not isinstance(data, dict) or "id" not in data:
+        raise TypeError("Invalid data")
+    ...
+
+# ✅ Use mypy / pyright for static checking
+# ✅ Use dataclass / Pydantic to define data structures
+from dataclasses import dataclass
+
+@dataclass
+class TaskState:
+    session_id: str
+    flow: str
+    current_step: str
+```
+
+### Prohibitions
+
+- ❌ No bare except (at minimum catch Exception)
+- ❌ Do not use print() instead of logging in production code
+- ❌ No mutable default arguments
+
+## Function Design
+
+### Parameters
+
+- Use object/struct parameters when exceeding 3 arguments
+
+### Return Values
+
+- Prefer concrete types, avoid None
+- For "empty" return scenarios, use the `Result` pattern (e.g., returns library) or `Optional[T]`
+
+## Async Handling
+
+- Use `async/await` (asyncio)
+- Use `async def` for async functions
+- Avoid mixing synchronous and asynchronous code
+
+```python
+async def load_task(session_id: str) -> Task | None:
+    data = await db.fetch_one("SELECT * FROM tasks WHERE session_id = ?", session_id)
+    return Task.from_row(data) if data else None
+```
+
+## Error Handling
+
+- Catch specific exception types, do not use bare `except:`
+- Validate inputs at system boundaries
+- Use custom exception classes
+
+```python
+try:
+    result = await risky_operation()
+except ConnectionError as e:
+    logger.error("Operation failed", extra={"error": str(e)})
+    raise OperationError("Failed to complete operation") from e
+```
+
+## Logging
+
+- Use the `logging` module, do not use `print()` directly
+- Log messages in English
+- Record info/debug logs on critical paths
+
+```python
+import logging
+
+logger = logging.getLogger(__name__)
+logger.info("Task created", extra={"session_id": session_id})
+logger.error("Failed to load task", extra={"error": str(e)})
+```
+
+## Comments and Documentation
+
+- Code comments in English
+- Public APIs use docstrings (Google or NumPy style)
+- Add explanatory comments for complex logic
+
+## Placeholder Code
+
+```python
+# TODO(username): Need to integrate API — expected v1.1
+# FIXME(username): Possible data race under concurrency — needs locking
+# HACK(username): Temporary workaround — replace after v1.0
+```
+
+## Export Conventions
+
+```python
+# Control exports in __init__.py
+__all__ = ["FlowParser", "parse_flow", "FlowDefinition"]
+
+# Main export
+class FlowParser: ...
+
+# Helper functions use named exports
+def parse_flow(path: str) -> FlowDefinition: ...
+```

package/dist/docs/template/_coding_style/rust.md

@@ -0,0 +1,161 @@
+# Rust Coding Style
+
+## General Format
+
+- Use UTF-8 encoding consistently, LF for line endings
+- Use rustfmt for automatic code formatting (runs on save)
+- Use 4 spaces for indentation, no tabs
+- Line length recommended not to exceed 100 characters
+- Keep one blank line at the end of files
+
+## File Organization
+
+### Naming
+
+- Source files use `snake_case`
+- Directory names use `snake_case`
+- Test file naming: inline `#[cfg(test)]` modules or `tests/` directory
+
+### Import Grouping
+
+```rust
+// 1. Standard library
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+// 2. Third-party crates
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+// 3. Project internal modules
+use crate::core::config::Config;
+use crate::models::user::User;
+```
+
+### File Structure
+
+- Prefer one primary export per file
+- Use named exports for auxiliary types/functions
+- Expose a clear public API from modules
+
+## Naming Conventions
+
+### Variables
+
+- Use `snake_case`
+- Short names for short scopes: `i`, `item`, `ctx`
+- Descriptive names for longer scopes: `task_config`, `message_count`
+
+### Constants
+
+- `UPPER_SNAKE_CASE`
+- Static variables use `SCREAMING_SNAKE_CASE`
+
+### Functions
+
+- Use `snake_case`
+- Start with a verb: `get_task`, `find_flow`, `create_plan`, `parse_spec`
+
+### Types
+
+- Use `PascalCase`
+- Trait names use PascalCase, avoid `-able` suffix
+- Rust has no classes; struct/enum use `PascalCase`
+
+### Enums
+
+Use `enum` with `#[derive(...)]`:
+
+```rust
+#[derive(Debug, Clone, PartialEq)]
+enum TaskStatus {
+    Running,
+    Completed,
+    Closed,
+}
+```
+
+## Type Safety
+
+### Rules
+
+- ✅ Leverage Rust's ownership and borrowing system; avoid unnecessary `.clone()`
+- ✅ Use `Result<T, E>` and `Option<T>` instead of null
+- ✅ Use `clippy` for lint checks
+- ❌ Do not use `unsafe` (unless with a strong justification and comments)
+- ❌ Do not use `unwrap()` or `expect()` in production paths
+
+## Function Design
+
+### Parameters
+
+- Use struct parameters when exceeding 3 parameters
+- Use the builder pattern for complex construction
+
+### Return Values
+
+- `Result<T, E>` and `Option<T>`
+
+## Control Flow
+
+- Use `match` for pattern matching
+- Use `if let` to simplify single-branch matches
+- Use the `?` operator to propagate errors
+
+## Async Handling
+
+- Use the `tokio` runtime
+- Async functions return `impl Future<Output = T>` or are annotated with `async fn`
+
+```rust
+async fn load_task(session_id: &str) -> Result<Option<Task>, DbError> {
+    let data = db.query("SELECT * FROM tasks WHERE session_id = ?", session_id).await?;
+    Ok(data.map(Task::from_row))
+}
+```
+
+## Error Handling
+
+- Use `thiserror` to define error types
+- Use the `?` operator to propagate errors
+- Use `anyhow` for application-level errors
+
+```rust
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+enum AppError {
+    #[error("failed to load task: {0}")]
+    DbError(#[from] DbError),
+}
+```
+
+## Logging
+
+- Use the `tracing` / `log` crate
+- Log messages in English
+
+```rust
+tracing::info!(session_id = %session_id, "task created");
+tracing::error!(error = %e, "failed to load task");
+```
+
+## Comments & Documentation
+
+- Code comments in English
+- Use `///` doc comments for public API
+- Use `//!` comments for modules
+
+## Placeholder Code
+
+```rust
+// TODO(username): Needs API integration — planned for v1.1
+// FIXME(username): Possible data race in concurrent scenarios — needs locking
+// HACK(username): Temporary workaround — replace after v1.0
+```
+
+## Export Conventions
+
+- Use `pub` to control visibility
+- `pub(crate)` restricts visibility to within the crate
+- Organize modules via `mod.rs` or same-name files