chore(project): add initial project setup and guidelines

- Added `.gitignore` to exclude `.pkl` files.
- Documented code style, design patterns, and project overview.
- Included suggested commands and task completion checklist.
- Configured project settings in `.serena/project.yml`.

This commit establishes the foundation for the rtty project.

Author: skanehira

.gitignore

@@ -0,0 +1 @@
+**/*.pkl

.serena/memories/code_style_conventions.md

@@ -0,0 +1,41 @@
+# Code Style and Conventions
+
+## Go Code Style
+- **Go Version**: 1.23.0+ (go.mod), using Go 1.24.4 toolchain
+- **Module Name**: github.com/skanehira/rtty
+- **Package Structure**: 
+  - Main package in root
+  - Command implementations in `cmd` package
+  - Embedded assets using `embed` package
+
+## Naming Conventions
+- **Files**: Snake_case (e.g., `run.go`, `version.go`)
+- **Functions**: CamelCase with exported functions starting with uppercase
+- **Variables**: camelCase for private, CamelCase for exported
+- **Constants**: CamelCase (e.g., `EventResize`, `EventSendkey`)
+
+## Code Organization
+- Commands are implemented using Cobra framework
+- Each command has its own file in the `cmd` directory
+- Utility functions are centralized in `util.go`
+- Embedded frontend assets are stored in `cmd/public`
+
+## Error Handling
+- Errors are logged using standard `log` package
+- HTTP/WebSocket errors are handled gracefully
+- Command execution errors are reported to the client
+
+## Comments and Documentation
+- Minimal inline comments (code should be self-documenting)
+- Using `//nolint` directives where necessary for linter exceptions
+- No extensive function documentation observed
+
+## Dependencies
+- Minimal external dependencies
+- Main dependencies: cobra (CLI), creack/pty (terminal), websocket
+- All dependencies managed via go.mod
+
+## Build Configuration
+- CGO_ENABLED=0 for static binaries
+- Supports Linux and Darwin (macOS) platforms
+- Uses ldflags for version injection during build

.serena/memories/design_patterns_guidelines.md

@@ -0,0 +1,63 @@
+# Design Patterns and Guidelines
+
+## Architecture Overview
+- **CLI-based Architecture**: Uses Cobra for command-line interface
+- **WebSocket Server**: Single-page application communicating via WebSocket
+- **Process Management**: Uses PTY (pseudo-terminal) for command execution
+
+## Key Design Patterns
+
+### 1. Command Pattern (Cobra)
+- Root command in `cmd/root.go`
+- Subcommands in separate files (run.go, version.go)
+- Command initialization in `init()` functions
+
+### 2. Server-Client Communication
+- JSON message protocol over WebSocket
+- Event-based architecture with defined event types:
+  - `EventResize`: Terminal resize events
+  - `EventSendkey`: Keyboard input events (though defined as "Snedkey" - likely a typo)
+  - `EventClose`: Connection close events
+
+### 3. Embedded Assets
+- Frontend assets embedded using Go's `embed` package
+- HTML and JavaScript served from embedded filesystem
+
+### 4. Concurrent I/O Handling
+- Goroutines for bidirectional communication
+- Separate goroutine for reading from WebSocket and writing to PTY
+- Main goroutine copies PTY output to WebSocket
+
+## Code Guidelines
+
+### Error Handling
+- Log errors but don't crash the server
+- Graceful degradation for client disconnections
+- Return meaningful error messages to clients
+
+### Resource Management
+- Proper cleanup with `defer` statements
+- Close WebSocket connections and PTY on exit
+- Single PTY instance per connection session
+
+### Security Considerations
+- Origin checking for WebSocket connections
+- Configurable allowed origins
+- No authentication mechanism (consider for production use)
+
+## Development Guidelines
+
+### Adding New Features
+1. Follow existing command structure for new CLI commands
+2. Maintain backward compatibility with message protocol
+3. Test with different shells and terminal types
+
+### Frontend Modifications
+- Keep JavaScript simple and focused
+- Maintain compatibility with xterm.js library
+- Test across different browsers
+
+### Performance Considerations
+- Minimize message overhead in WebSocket protocol
+- Efficient buffer handling for terminal I/O
+- Avoid blocking operations in message handlers

.serena/memories/project_overview.md

@@ -0,0 +1,46 @@
+# rtty Project Overview
+
+## Purpose
+rtty (Remote TTY) is a terminal emulator that runs in a web browser via WebSocket. It allows users to access a terminal session through a web interface, making it possible to run command-line tools remotely through a browser.
+
+## Core Features
+- Run any command/shell in a browser
+- WebSocket-based real-time communication
+- Terminal resize support
+- Configurable font and font size
+- Cross-platform support (Linux and macOS)
+
+## Tech Stack
+- **Language**: Go 1.23.0+ (currently using Go 1.24.4)
+- **Backend Framework**: 
+  - Cobra for CLI commands
+  - Standard Go net/http and golang.org/x/net/websocket for WebSocket server
+  - creack/pty for pseudo-terminal handling
+- **Frontend**: 
+  - Vanilla JavaScript
+  - xterm.js for terminal emulation in the browser
+  - WebSocket API for communication
+
+## Project Structure
+```
+.
+├── cmd/               # Command implementations
+│   ├── public/       # Frontend assets (HTML, JS, CSS)
+│   ├── root.go       # Root command
+│   ├── run.go        # Main run command (WebSocket server)
+│   ├── version.go    # Version command
+│   └── util.go       # Utility functions
+├── main.go           # Entry point
+├── go.mod            # Go module definition
+├── go.sum            # Go module checksums
+├── Makefile          # Build automation
+├── .goreleaser.yaml  # Release configuration
+└── .github/
+    └── workflows/    # CI/CD workflows
+```
+
+## Key Components
+1. **WebSocket Server**: Handles browser connections and terminal I/O
+2. **PTY Management**: Creates and manages pseudo-terminals for running commands
+3. **Message Protocol**: JSON-based messaging between browser and server
+4. **Event Handling**: Supports resize, key input, and close events

.serena/memories/suggested_commands.md

@@ -0,0 +1,101 @@
+# Suggested Commands for Development
+
+## Build and Run
+```bash
+# Run the server locally
+go run . run zsh -p 8080 -v --font "Cica Regular" --font-size 20
+
+# Build the binary
+go build
+
+# Install to GOPATH/bin
+go install github.com/skanehira/rtty@latest
+```
+
+## Testing
+```bash
+# Run all tests
+go test -v ./...
+
+# Run tests with coverage
+go test -v -cover ./...
+```
+
+## Linting and Code Quality
+```bash
+# Run golangci-lint (used in CI)
+golangci-lint run
+
+# Format code
+go fmt ./...
+
+# Check for issues
+go vet ./...
+```
+
+## Dependency Management
+```bash
+# Update dependencies
+go mod tidy
+
+# Download dependencies
+go mod download
+
+# Verify dependencies
+go mod verify
+```
+
+## Git Commands
+```bash
+# Check status
+git status
+
+# Add changes
+git add .
+
+# Commit with message
+git commit -m "message"
+
+# Push to remote
+git push origin main
+```
+
+## Release and Build
+```bash
+# Create a new release with goreleaser
+goreleaser release --clean
+
+# Test release build locally
+goreleaser build --snapshot --clean
+```
+
+## System Commands (Darwin/macOS)
+```bash
+# List files
+ls -la
+
+# Find files
+find . -name "*.go"
+
+# Search in files
+grep -r "pattern" .
+
+# Watch file changes
+fswatch -o . | xargs -n1 -I{} echo "File changed"
+```
+
+## Development Workflow
+```bash
+# 1. Make changes
+# 2. Format code
+go fmt ./...
+
+# 3. Run linter
+golangci-lint run
+
+# 4. Run tests
+go test -v ./...
+
+# 5. Build and test manually
+go build && ./rtty run zsh -p 8080 -v
+```

.serena/memories/task_completion_checklist.md

@@ -0,0 +1,40 @@
+# Task Completion Checklist
+
+When completing any development task on the rtty project, ensure the following steps are performed:
+
+## 1. Code Quality Checks
+- [ ] Run `go fmt ./...` to format all Go files
+- [ ] Run `golangci-lint run` to check for linting issues
+- [ ] Fix any linting warnings or errors
+
+## 2. Testing
+- [ ] Run `go test -v ./...` to ensure all tests pass
+- [ ] Add new tests for any new functionality (if applicable)
+- [ ] Verify test coverage for critical paths
+
+## 3. Build Verification
+- [ ] Run `go build` to ensure the project builds successfully
+- [ ] Test the built binary with basic functionality
+
+## 4. Manual Testing
+- [ ] Run the server: `./rtty run zsh -p 8080 -v`
+- [ ] Open browser and verify WebSocket connection works
+- [ ] Test terminal functionality (typing, resize, etc.)
+
+## 5. Dependencies
+- [ ] Run `go mod tidy` to clean up dependencies
+- [ ] Commit both go.mod and go.sum if changed
+
+## 6. Documentation
+- [ ] Update README.md if functionality changes
+- [ ] Update inline comments if complex logic is added
+
+## 7. Git Hygiene
+- [ ] Ensure commits follow TDD approach (test first, then implementation)
+- [ ] Use clear commit messages with [STRUCTURAL] or [BEHAVIORAL] prefix
+- [ ] Verify no secrets or sensitive data in commits
+
+## Important Notes
+- The project currently has no test files, so writing tests for new features is especially important
+- Always use `ghost` for managing background processes during development
+- Follow the established code style (minimal comments, self-documenting code)

.serena/project.yml

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: go
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed)on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file or directory.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "rtty"