richard/lxcafe
0
0
Fork 0
mirror of https://codeberg.org/knightsub9/lxcafe.git synced 2026-07-19 19:30:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

do not expect Aptos font file but download it when needed (#8)

Browse Source 
Reviewed-on: lxcafe/lxcafe#8
This commit is contained in:
markus.block
2026-03-14 17:02:38 +01:00
parent 5bffe8f68f
commit b9693a455a
2 changed files with 121 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.agents/AGENTS.md
+103 -132
View File
@@ -1,169 +1,140 @@
AGENTS # AGENTS.md
I created this `AGENTS.md` to help agentic coding assistants work in this repository. It contains Guidelines for agentic coding assistants working in this repository.
1) Build / lint / test commands (including how to run a single test) and
2) Code style guidelines and conventions to follow when editing code here.
Repository state ## Repository Overview
- This repository contains shell scripts for Linux Mint XFCE post-installation setup.
- Main scripts are located in `post_installation_script/` directory.
- Testing infrastructure is in `post_installation_script_test/` (Docker/Podman test containers).
- No build system, package.json, Makefile, or language-specific project files were detected.
- There are no Cursor rules or Copilot instruction files in the repo (checked paths below).
- `.cursor/rules/` : not found
- `.cursorrules` : not found
- `.github/copilot-instructions.md` : not found
If you add new code (Go, Python, Node, Rust, Java, etc.), follow the per-ecosystem quick commands below. - **Type**: Shell script project for Linux Mint XFCE post-installation setup
- **Main scripts**: `post_installation_script/` - Linux Mint XFCE post-installation automation
- **Testing**: `post_installation_script_test/` - Docker/Podman container-based testing
- **No build system**: Pure shell scripts, no package.json/Makefile/Cargo.toml
1) Build / Lint / Test commands ---
- General notes ## 1) Build / Lint / Test Commands
- Run commands from the repository root unless a submodule or service has its own README.
- Prefer local, repo-scoped toolchains (venv, node_modules/.bin, go modules, cargo) to avoid global state.
- Shell scripts ### Shell Scripts
- Quick check: `shellcheck scripts/*.sh` (install `shellcheck` first).
- Run an individual script: `bash path/to/script.sh` or `./script.sh` (ensure executable bit set).
- Syntax check: `bash -n path/to/script.sh`
- Trace execution: `bash -x path/to/script.sh` (shows each command as it runs)
- Testing shell scripts ```bash
- See `post_installation_script_test/README.md` for detailed container-based testing instructions. # Syntax check only (no execution)
- Quick start: bash -n path/to/script.sh
- Build image: `./post_installation_script_test/01_create_image.sh`
- Start container: `./post_installation_script_test/02_start_container_with_image.sh`
- Python (if added) # Trace execution (shows each command as it runs)
- Install: `python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt` bash -x path/to/script.sh
- Lint: `ruff .` or `flake8 .`
- Format: `black .`
- Test all: `pytest -q`
- Run a single test: `pytest path/to/test_file.py::TestClass::test_method -q`
- Node / JavaScript / TypeScript (if added) # Lint with shellcheck (install with: apt install shellcheck)
- Install: `npm ci` or `pnpm install` / `yarn install` shellcheck post_installation_script/*.sh
- Lint: `npm run lint` (or `npx eslint .`)
- Format: `npx prettier --write .`
- Test all: `npm test` (or `npx vitest` / `npx jest`)
- Run a single test:
- Jest: `npx jest path/to/file.test.js -t "test name regex"`
- Vitest: `npx vitest run path/to/file.spec.ts -t "test name"`
- Go (if added) # Run individual script
- Build: `go build ./...` bash path/to/script.sh
- Lint: `golangci-lint run` (if configured) ./script.sh # requires executable bit: chmod +x script.sh
- Test all: `go test ./...` ```
- Run a single test: `go test ./pkg/name -run TestFunctionName`
- Rust (if added) ### Container-Based Testing
- Build: `cargo build`
- Lint: `cargo clippy`
- Test all: `cargo test`
- Run a single test: `cargo test test_name -- --exact`
- Java / Maven (if added) ```bash
- Build: `mvn -DskipTests package` # Build test image (Ubuntu 22.04 with useful utilities)
- Lint/format: use `spotless`/`checkstyle` if configured cd post_installation_script_test
- Test all: `mvn test` bash 01_create_image.sh
- Run a single test: `mvn -Dtest=ClassName#methodName test`
- .NET (if added) # Start interactive container (auto-removed on exit)
- Build: `dotnet build` bash 02_start_container_with_image.sh
- Test all: `dotnet test`
- Run a single test: `dotnet test --filter FullyQualifiedName~Namespace.ClassName.MethodName`
- CI / Automation # Inside container - source scripts mounted at /workspace:
- If you add GitHub Actions, keep workflows idempotent and cache dependencies carefully. bash /workspace/<scriptName>.sh
- Avoid secrets in workflows; read sensitive values from repository/organization secrets. ```
2) Code style guidelines ### Single Test Commands (for future languages)
The guidance below is intentionally general and focuses on consistency, readability and safety so ```bash
agentic tools can make changes predictably across multiple languages. # Python: pytest path/to/test.py::TestClass::test_method -q
# Node/Jest: npx jest path/to/file.test.js -t "test name regex"
# Node/Vitest: npx vitest run path/to/file.spec.ts -t "test name"
# Go: go test ./pkg/name -run TestFunctionName
# Rust: cargo test test_name -- --exact
# Java/Maven: mvn -Dtest=ClassName#methodName test
# .NET: dotnet test --filter FullyQualifiedName~Namespace.ClassName.MethodName
```
- Formatting ---
- Use an automated formatter for the language (Black for Python, Prettier for JS/TS, gofmt/gofmt -s for Go,
rustfmt for Rust). Commit formatted code only.
- Use an editorconfig file for basic whitespace/indentation rules when possible.
- Imports / dependencies ## 2) Code Style Guidelines
- Keep imports explicit and minimal: import only what you use.
- Group imports in a logical order (language default + third-party + local project). Leave a blank line between groups.
- Don’t commit unused dependencies; remove them from lock files / manifests and run the linter.
- Types / typing ### Shell Scripts (Primary Language)
- Prefer explicit types where the language supports them (TypeScript types, Python type hints, Go static types).
- Add types for public interfaces and complex logic; internal simple helper functions may rely on inference.
- Naming conventions - **Shebang**: Use `#!/bin/bash` (not `/bin/sh`) for bash-specific features
- Use clear, descriptive names. Prefer `calculate_total`, `prepare_connection`, `user_id` style for snake_case languages. - **Safety**: Use `set -euo pipefail` at script start
- For camelCase languages (JS/TS): `calculateTotal`, `prepareConnection`. - **Quotes**: Always use double quotes for variable expansion: `"$VAR"`, never bare `$VAR`
- Types and classes: use PascalCase/UpperCamelCase: `UserService`, `HttpClient`. - **Conditionals**: Use `[[ ]]` for tests, not `[ ]`
- Constants: use UPPER_SNAKE_CASE or language-specific constant conventions. - **Variables**: Use `readonly` for constants, `local` for function-scoped variables
- **Performance**: Prefer functions over subshells when possible
- **Naming**: Use descriptive function names: `install_fonts()`, `configure_panel()`, `prompt_user()`
- **Errors**: Write to stderr: `echo "Error: $msg" >&2`
- **Exit codes**: 0=success, 1=general error, 2=invalid usage
- **Comments**: Avoid unless explaining non-obvious behavior
- **Constants**: Define at top of script, UPPER_SNAKE_CASE
- Functions and modules ### General Conventions
- Keep functions small (ideally < 40 lines) and single-responsibility.
- Prefer pure functions where possible; keep side effects explicit and isolated.
- Organize modules by feature/domain, not solely by type (avoid monolithic god-modules).
- Error handling - **Formatting**: Use automated formatters (Black/Prettier/gofmt/rustfmt) - commit formatted code
- Fail fast and return/raise errors with context (message + cause) rather than swallowing them. - **Types**: Prefer explicit typing (TypeScript types, Python type hints, Go static types)
- Avoid logging raw errors in library code; return errors to callers and let the application layer decide logging. - **Naming**:
- Use typed error types when the language supports it (Go error types, custom exceptions in Python/JS). - snake_case: variables, functions (`user_id`, `calculate_total`)
- Clean up resources with `finally`/`defer` equivalents to avoid leaks. - PascalCase: types/classes (`UserService`, `HttpClient`)
- UPPER_SNAKE_CASE: constants (`MAX_RETRIES`, `API_BASE_URL`)
- **Imports**: Keep minimal, group logically (stdlib → third-party → local), blank line between groups
- **Functions**: Keep small (<40 lines), single responsibility, pure where possible
- **Error handling**: Fail fast with context, avoid silent failures, use typed errors where supported
- **Tests**: Deterministic, mock external I/O, explicit names like `test_should_return_400_when_missing_field`
- **Resources**: Always clean up with `finally`/`defer` equivalents
- Tests ---
- Prefer small, deterministic unit tests. Mock external IO and network where reasonable.
- Use explicit fixtures and avoid implicit global state between tests.
- Name tests with the behavior they assert: `test_calculate_total_with_discounts` or `shouldReturn400WhenMissingField`.
- Logging and observability ## 3) Security
- Use structured logging where available (JSON structured logs for services).
- Avoid printing raw stack traces to stdout in production code; include them at debug level.
- Security and secrets - Never commit secrets, API keys, credentials, or tokens
- Never commit secrets, API keys, or credentials. Use environment variables and vaults. - Use environment variables for sensitive values
- Validate and sanitize external input at the boundaries of the system. - Validate and sanitize all external input
- Run linting (`shellcheck`) before committing shell scripts
- Performance ---
- Measure before optimizing. Prefer clarity over micro-optimizations unless a hotspot is identified.
3) Code review / commit guidance for agents ## 4) Commit Guidelines
- Make small, focused commits and include a one-line summary plus a short description of the why. - Make small, focused commits with descriptive messages
- When changing behavior, add or update tests that verify the new/changed behavior. - Include formatter command in commit message if auto-formatting
- If you reformat files automatically, include the formatter command in the commit message to make CI reproduction easy. - When changing behavior, add or update tests
- Run full test suite before opening PRs
4) Repo housekeeping checks (recommended for agents) ---
- When adding a new language or framework, add an entry to this file with the exact commands required to build/test. ## 5) Cursor / Copilot Rules
- Add CI workflows to run lint + tests on PRs and enable branch protection rules if this becomes a shared repo.
- **Session storage**: Store session logs and working notes in `.agents/sessions/` folder for future reference. Use descriptive filenames (e.g., `session-<date>-<topic>.md`).
5) Cursor / Copilot rules - `.cursor/rules/`: Not present
- `.cursorrules`: Not present
- `.github/copilot-instructions.md`: Not present
- Cursor rules: none present at `.cursor/rules/` or `.cursorrules` in this repository. ---
- GitHub Copilot instructions: none present at `.github/copilot-instructions.md`.
If you add any of these files, update this document and include the exact file path and relevant sections for agents to follow. ## 6) Repo Housekeeping
Quick checklist for an agent making changes - Store session logs in `.agents/sessions/` for reference
- Run local linter/formatter configured for the language before opening a PR. - When adding new languages, update this file with exact build/test commands
- Run the test suite and the single-test command for any tests you added/changed.
- Do not add secrets to the tree; use placeholders and document required environment variables.
Next steps (recommended) ---
1) Add a minimal `Makefile` or `package.json` scripts for common tasks so agents can run `make test` / `npm test`.
2) If the project will contain multiple services, add per-service README files and CI workflows.
3) Add EditorConfig + language-specific formatter configs (pyproject.toml, .prettierrc, rustfmt.toml) to lock formatting rules.
Files referenced ## Files Referenced
- Root `README.md`
- `post_installation_script/README.md` - main script usage
- `post_installation_script_test/README.md` - testing instructions
- `.cursor/rules/` (not present)
- `.cursorrules` (not present)
- `.github/copilot-instructions.md` (not present)
If anything in this file needs to be stricter or you want another style (for example a fully opinionated TS style), say which language or style and I will update `AGENTS.md` accordingly. - `README.md` - Project overview
- `post_installation_script/README.md` - Script usage and details
- `post_installation_script_test/README.md` - Container testing instructions
---
## Quick Checklist for Changes
- [ ] Run `shellcheck` on shell scripts before committing
- [ ] Verify `bash -n` syntax check passes
- [ ] Test script changes in container first
- [ ] No secrets in code - use environment variables
- [ ] Run tests if added for new functionality
post_installation_script/Nachinstallationsarbeiten_LC_Esslingen_XFCE.sh
+8 -7
View File
@@ -116,12 +116,11 @@ if question_answered_with_yes " ### Installiere Aptos Schriften? ###"; then
echo "### Aptos Schriften ###" echo "### Aptos Schriften ###"
_aptos_zip="Microsoft Aptos Fonts.zip" _aptos_zip="Microsoft Aptos Fonts.zip"
if [ ! -f "$_aptos_zip" ]; then _aptos_url="https://download.microsoft.com/download/8/6/0/860a94fa-7feb-44ef-ac79-c072d9113d69/Microsoft%20Aptos%20Fonts.zip"
echo ""
echo "$_aptos_zip nicht gefunden." echo "Lade Aptos Schriften herunter..."
echo "Bitte laden Sie die Datei von Microsoft herunter und legen Sie sie im selben Verzeichnis wie dieses Skript ab." wget "$_aptos_url" -O "$_aptos_zip"
else
echo
echo "Entpacke das Archiv..." echo "Entpacke das Archiv..."
unzip -o "$_aptos_zip" unzip -o "$_aptos_zip"
echo "Erstelle /usr/share/fonts/truetype/aptos/" echo "Erstelle /usr/share/fonts/truetype/aptos/"
@@ -131,7 +130,9 @@ if question_answered_with_yes " ### Installiere Aptos Schriften? ###"; then
echo "Aktualisiere den Font-Cache" echo "Aktualisiere den Font-Cache"
fc-cache -f fc-cache -f
echo "Fertig! Aptos Schriftarten sind installiert." echo "Fertig! Aptos Schriftarten sind installiert."
fi
echo "Entferne temporäre Dateien..."
rm -f "$_aptos_zip"
fi fi
echo echo