1
0
mirror of https://github.com/XNM1/linux-nixos-hyprland-config-dotfiles.git synced 2025-09-15 09:45:58 +03:00

Compare commits

...

25 Commits

Author SHA1 Message Date
xnm
426bad68f2 feat(fish): 🎣 Add fzf key bindings integration
Add fzf key bindings function file with support for:
- File search widget (Ctrl+T)
- Command history search (Ctrl+R) (replaced by custom implementation)
- Directory navigation (Alt+C) (replaced by custom implementation)

Bindings work in both normal and insert modes, providing
fuzzy search capabilities for fish shell navigation and
command history.
2025-09-13 14:22:16 +03:00
xnm
47f66398b6 chore(config): 🎨 restructure lazygit theme configuration
Move theme settings under `gui` section to match latest lazygit
configuration format. This aligns with the updated configuration
structure introduced in recent versions.

The color values remain unchanged - only the nesting structure has been
modified to maintain compatibility with lazygit's configuration schema
requirements.
2025-09-06 17:18:56 +03:00
xnm
7a4c582b85 feat(terminal-utils): 📦 Add posting CLI tool
Add `posting` to terminal utilities package set and configure two
Catppuccin Macchiato color scheme variants (mauve and teal) for the
tool.
2025-09-06 17:17:14 +03:00
xnm
4845b84fc5 feat(utils): 📦 Move sqlx-cli and mermaid-cli to terminal utilities
Add sqlx-cli and mermaid-cli to terminal-utils.nix while removing them
from
utils.nix to consolidate database and diagramming tools in the
appropriate
utility category.

- Move sqlx-cli (database migrations) to terminal utilities
- Move mermaid-cli (diagram generation) to terminal utilities
- Remove commented git-secrets from terminal utilities

This reorganization groups related development tools together for better
maintainability and logical organization of utility packages.
2025-09-06 16:49:32 +03:00
xnm
6940f6d195 fix(fish-helix): 🐛 Fix argparse syntax and add select_line command
- Remove single quotes around `h/help` flag in argparse call
- Add new `select_line` command case to handle line selection
- Clean up string quoting consistency throughout the function
- Improve indentation and formatting for better readability

The argparse syntax fix resolves potential parsing issues while the
new select_line command provides consistent line selection behavior
across different modes.
2025-08-31 16:44:16 +03:00
xnm
76f078cd17 fix(config): 🔧 Add protocol prefixes to local API URLs
Updated MCP server configuration URLs to include `http://` protocol
prefix for:
- n8n API URL (`localhost:5678` → `http://localhost:5678`)
- Coolify base URL (`localhost:8000` → `http://localhost:8000`)
- Appwrite endpoint (`localhost:8088/v1` → `http://localhost:8088/v1`)

Also migrated logind configuration from `extraConfig` string to
structured
settings format for better maintainability.

```nix
services.logind.settings.Login = {
  RuntimeDirectorySize = "8G";
};
2025-08-31 16:28:47 +03:00
xnm
4556f66ab2 feat(ai): 🤖 Add MCP servers for shadcn, docker, n8n, coolify, and appwrite
Add new Model Context Protocol server configurations:
- **shadcn**: shadcn/ui MCP server using npx
- **docker**: Docker MCP server with custom Python path
- **n8n**: n8n workflow automation server with API configuration
- **coolify**: Coolify deployment platform MCP server
- **appwrite**: Appwrite backend server with full resource access

Each server includes appropriate environment variables for API keys and
endpoint configuration, following existing MCP server patterns in the
configuration file.
2025-08-24 21:06:53 +03:00
xnm
c4f4b80836 feat(config): 🎉 Add crush.json configuration file
Add initial configuration for Crush CLI tool with LSP and MCP server
support:

**LSP Servers:**
- TypeScript/JavaScript (typescript-language-server)
- Rust (rust-analyzer)
- Nix (nil)

**MCP Servers:**
- Context7 search
- Playwright testing
- SearXNG search
- Git operations
- Time utilities
- Sequential thinking
- NixOS tools
- Kubernetes
- Filesystem access

Configuration includes proper schema reference and environment setup for
local
SearXNG instance.
2025-08-24 03:26:43 +03:00
xnm
9eb89bb59f chore(config): 🚀 add npm global packages to PATH and configure npmrc
Add npm global packages bin directory to fish shell PATH for easier
access to globally installed packages.

Create `.npmrc` configuration file with:
- `strict-ssl=true` for secure connections
- Custom prefix set to `${HOME}/.npm-packages` for global installations

This ensures globally installed npm packages are accessible from the
command line and configures npm to use a user-specific directory for
global packages.
2025-08-24 03:22:10 +03:00
xnm
82aebc8cff feat(night-mode): 🌙 Switch from wlsunset to hyprsunset and add temperature control
- Replace wlsunset with hyprsunset for better Hyprland integration
- Add temperature adjustment functions with scroll support in Waybar
- Implement persistent temperature storage in `~/.cache/hyprsunset_temp`
- Add temperature bounds (2000K-6500K) with 100K increment/decrement
steps
- Update NixOS configuration to include hyprsunset package

Fixes temperature persistence and improves Hyprland compatibility
2025-08-24 03:06:11 +03:00
xnm
a6caf5ef5e feat(fish): Add helix key bindings from https://github.com/sshilovsky/fish-helix/tree/main
Add comprehensive helix-like modal key bindings system for fish shell
with:
- New `fish_helix_key_bindings` function with helix-inspired navigation
- Modal editing support with count modifiers via `fish_bind_count`
- Visual mode prompt indicator via `fish_default_mode_prompt`
- Enhanced clipboard integration with proper notification formatting

The implementation provides vim/helix-style modal editing while
maintaining
fish shell compatibility and includes proper mode indicators, count
tracking,
and seamless integration with existing fish key binding systems.
2025-08-19 17:47:39 +03:00
xnm
26fa7f462c feat(packages): 📦 Add mermaid-cli to utils packages
Add mermaid-cli to the list of utils packages for diagram generation
support. This enables users to create diagrams from markdown without
additional configuration.
2025-08-18 17:17:38 +03:00
xnm
f79aad1630 fix(config): 🔧 Update imports and dependency versions
- Changed kitty.typing to kitty.typing_compat import in search.py
- Pinned radicle-tui to specific revision in flake.nix

Fixes compatibility issues with latest kitty version
Ensures reproducible build for radicle-tui dependency
2025-08-16 19:43:06 +03:00
xnm
ff45ab768d feat(config): 🔧 Update model configuration and system packages
- Changed default model from `moonshot/kimi-k2-0711-preview` to
`z/glm-4.5`
- Added new provider configuration for Z AI with GLM-4.5 model
- Added hyprpolkitagent to Hyprland packages
- Updated Ollama models list (removed some Gemma models, added
qwen3-coder)
- Added chromium and playwright to system packages
2025-08-03 16:00:47 +03:00
xnm
b6318f0885 feat(config): 🎨 Update dotfiles configuration
- Fixed theme name format in bat config (removed hyphen)
- Corrected linkedin alias typo in fish config
- Added new keybinding (A-r) in helix config
- Updated Telegram executable name in hyprland config
- Revamped lazygit theme colors to Catppuccin
- Added new opencode configuration file
- Enhanced git delta configuration with new features
- Added n8n service and opencode package to llm.nix
- Updated Python version in lsp.nix and programming-languages.nix
- Updated Telegram firejail profile name in security-services.nix
2025-07-20 19:22:36 +03:00
xnm
4b2884451c feat(ollama): 🚀 Update Gemma3 model variant in loadModels
Updated the Gemma3 model variant from `gemma3:4b` to `gemma3n:e4b` in
the Ollama service configuration
2025-07-06 16:45:56 +03:00
xnm
67332f3129 feat(shell): Add AI-powered Git and writing aliases
Add new fish shell aliases for AI-assisted workflows:
- `ai-commit`/`aic`: Generate commit messages from staged changes
- `ai-emoji-commit`/`aiec`: Generate emoji commit messages
- `ai-branch`/`aib`: Suggest branch names
- `ai-spell`/`ais`: Improve writing
- `ai-email`/`aie`: Draft email responses
- `ai-linkedin`/`ail`: Craft LinkedIn replies

All commands pipe through `hx` for editing before use.
2025-06-01 18:58:47 +03:00
xnm
d22e37ea8e feat(terminal-utils): 📦 Add more terminal utilities
Added several useful terminal utilities to the NixOS configuration:
- `moreutils` for additional Unix tools
- `asciinema` and `asciinema-agg` for terminal recording
- `dogdns` for DNS lookups
- `ncdu` for disk usage analysis
- `magic-wormhole-rs` for secure file transfers

Also commented out `taskwarrior3` and `wormhole-william` for future
reference.
2025-06-01 18:58:43 +03:00
xnm
49f23c4fd4 feat(ai): 🤖 update LLM models and configuration
- Changed default model from `ollama:llama3.2:3b` to `ollama:gemma3:4b`
- Updated model token limits and added new models:
  - Added `gemma3:4b` with vision support
  - Removed `phi4:14b` and added `phi4-reasoning:14b`
  - Updated token limits for existing models
- Added new AI-related roles:
  - `commit-message.md`
  - `email-answer.md`
  - `emoji-commit-message.md`
  - `git-branch.md`
  - `improve-prompt.md`
  - `improve-writing.md`
  - `linkedin-answer.md`
  - Enhanced `to-emoji.md` and added `to-emojies.md`
- Added `ai` alias for `aichat` in fish config
- Updated NixOS configuration to load new models
2025-06-01 18:57:33 +03:00
xnm
2ded474297 💄 fix(waybar): update waybar icon glyphs 2025-05-25 18:34:41 +03:00
xnm
6395991cf6 📦 feat(git): add radicle package
- add `radicle` package
- add `radicle-tui` package
- create fish alias for `rad-tui`
- add radicle config template `radicle.nix`
- add `.gitconfig.radicle` to `.gitconfig`
- create directory for radicle projects with its `.gitconfig.radicle`
2025-05-24 23:39:56 +03:00
xnm
ddb7795d24 📦 ️feat(terminal-utils): add jujutsu and jjui tools 2025-05-20 21:18:11 +03:00
xnm
33aa287e12 🔒 feat(security): replace sudo with sudo-rs
- Enable `sudo-rs` with wheel-only execution
- Disable legacy `sudo`
- Update AppArmor and U2F configs for `sudo-rs`
- Update Yubikey U2F auth for `sudo-rs`
2025-05-18 03:40:44 +03:00
xnm
952fb7f7c1 📦 ️feat(work): update developer tooling
- Add google-cloud-sdk and android-studio
- Reorganize package list ordering
2025-05-18 03:37:28 +03:00
xnm
98452f31a3 📦 ️feat(terminal): add dotenvx to system packages 2025-05-18 03:33:40 +03:00
58 changed files with 11356 additions and 3898 deletions

View File

@@ -1,4 +1,4 @@
# model: ollama:llama3.2:3b # model: ollama:gemma3:4b
model: deepseek:deepseek-chat model: deepseek:deepseek-chat
keybindings: vi keybindings: vi
function_calling: true function_calling: true
@@ -12,20 +12,38 @@ clients:
max_input_tokens: 128000 max_input_tokens: 128000
supports_function_calling: true supports_function_calling: true
- name: phi4:14b - name: phi4-reasoning:14b
max_input_tokens: 16000 max_input_tokens: 32000
supports_function_calling: true supports_function_calling: true
- name: dolphin3:8b - name: dolphin3:8b
max_input_tokens: 130000 max_input_tokens: 128000
supports_function_calling: true supports_function_calling: true
- name: smallthinker:3b - name: smallthinker:3b
max_input_tokens: 16384 max_input_tokens: 32000
supports_function_calling: true supports_function_calling: true
- name: qwq:32b - name: gemma3:4b
max_input_tokens: 33000 max_input_tokens: 128000
supports_vision: true
supports_function_calling: true
- name: gemma3:12b
max_input_tokens: 128000
supports_vision: true
supports_function_calling: true
- name: gemma3:27b
max_input_tokens: 128000
supports_vision: true
supports_function_calling: true
- name: deepcoder:14b
max_input_tokens: 128000
- name: qwen3:14b
max_input_tokens: 40000
supports_function_calling: true supports_function_calling: true
- name: nomic-embed-text:latest - name: nomic-embed-text:latest

View File

@@ -0,0 +1,39 @@
---
model: deepseek:deepseek-chat
---
You are an expert in Git commit messages and Conventional Commits specification. Your task is to generate a well-formatted commit message based on the provided code changes, following these guidelines:
1. **Conventional Commits Format**:
- Structure: `<type>(<scope>): <description>`
- Common types: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
- Optional scope for context (e.g., `fix(authentication):`)
2. **Formatting Requirements**:
- Subject line (first line) must be 50 characters or less
- Description lines (if needed) must be 72 characters or less
- Use Markdown formatting when appropriate (e.g., code blocks, lists)
- Separate subject from body with a blank line
- Use imperative mood ("Add feature" not "Added feature")
3. **Output Instructions**:
- Analyze the changes carefully to determine the most appropriate type and scope
- Write a clear, concise subject line that summarizes the change
- Include a detailed body when necessary, explaining:
* What changed and why
* Any breaking changes (prefixed with `BREAKING CHANGE:`)
* Related issues or tickets (e.g., `Closes #123`)
4. **Example Structure**:
```
feat(auth): implement password strength validation
Add password validation rules requiring:
- Minimum 8 characters
- At least one special character
- Not matching common patterns
Closes #42
```
Please generate the commit message for these changes:

View File

@@ -0,0 +1,33 @@
---
model: deepseek:deepseek-chat
---
Please help me craft a professional yet human-sounding email response based on the following:
**Format:**
```
Email:
<received email>
Draft/Notes:
<my response draft, suggestions, or key points to include>
```
**Response Requirements:**
- Format as a complete email response (include greeting, body, and closing)
- Maintain the tone and structure of the original email
- Keep it concise but descriptive (2-3 paragraphs max)
- Sound professional but natural (avoid robotic/formulaic language)
- Address all key points from the original email
- Include any necessary details from my draft/key points
- End with an appropriate closing and signature
**Important:**
- Match the level of formality of the original email
- If the original email was friendly, mirror that tone
- If it was more formal, maintain that professionalism
- Mirror formating of received mail when appropriate
- Builds rapport when appropriate
- Include proper spacing and formatting for readability
- ONLY output the formatted email response (no commentary or notes)
- Do not include any meta-commentary or notes

View File

@@ -0,0 +1,36 @@
---
model: deepseek:deepseek-chat
---
# Git Commit Message Generator
You are an expert in Git commit messages following Conventional Commits and Gitmoji guidelines. Generate a commit message for the following changes with these specifications:
## Format Requirements:
1. **Structure**: Follow Conventional Commits format:
```
<type>(<scope>): <emoji> <subject>
<BLANK LINE>
<body>
<BLANK LINE>
<footer>
```
2. **Gitmoji**: Include one relevant Gitmoji at the start of the subject line
3. **Length Limits**:
- Subject line: 50 characters maximum
- Body lines: 72 characters maximum per line
4. **Markdown**: Use markdown formatting in the body when appropriate (e.g., code blocks, lists)
## Content Guidelines:
1. **Type**: Choose from: feat, fix, docs, style, refactor, test, chore, etc.
2. **Scope**: Optional, specify if relevant (e.g., component name)
3. **Subject**: Clear, imperative description of change
4. **Body**: Detailed explanation when needed (why, not what)
5. **Footer**: Reference issues/PRs (e.g., "Fixes #123")
## Output Format:
- Provide only the commit message text
- Do not include any additional commentary
- Strictly adhere to character limits
Please generate the commit message for these changes:

View File

@@ -0,0 +1,18 @@
---
model: deepseek:deepseek-chat
---
Generate a descriptive Git branch name that follows conventional branch naming practices for these changes.
Requirements:
- Use lowercase letters and hyphens to separate words (kebab-case)
- Keep it concise but descriptive (aim for 3-5 words)
- Follow one of these common patterns:
* `feature/[short-description]` for new features
* `fix/[issue-description]` for bug fixes
* `hotfix/[urgent-issue]` for critical production fixes
* `docs/[change-description]` for documentation updates
* `refactor/[component-description]` for code refactoring
* `test/[test-description]` for test-related changes
Provide 3 potential branch name options that could work for these changes, ranked from most to least preferred, with a brief justification for each choice.

View File

@@ -0,0 +1,522 @@
---
model: deepseek:deepseek-chat
---
# IDENTITY and PURPOSE
You are an expert LLM prompt writing service. You take an LLM/AI prompt as input and output a better prompt based on your prompt writing expertise and the knowledge below.
START PROMPT WRITING KNOWLEDGE
Prompt engineering
This guide shares strategies and tactics for getting better results from large language models (sometimes referred to as GPT models) like GPT-4. The methods described here can sometimes be deployed in combination for greater effect. We encourage experimentation to find the methods that work best for you.
Some of the examples demonstrated here currently work only with our most capable model, gpt-4. In general, if you find that a model fails at a task and a more capable model is available, it's often worth trying again with the more capable model.
You can also explore example prompts which showcase what our models are capable of:
Prompt examples
Explore prompt examples to learn what GPT models can do
Six strategies for getting better results
Write clear instructions
These models cant read your mind. If outputs are too long, ask for brief replies. If outputs are too simple, ask for expert-level writing. If you dislike the format, demonstrate the format youd like to see. The less the model has to guess at what you want, the more likely youll get it.
Tactics:
Include details in your query to get more relevant answers
Ask the model to adopt a persona
Use delimiters to clearly indicate distinct parts of the input
Specify the steps required to complete a task
Provide examples
Specify the desired length of the output
Provide reference text
Language models can confidently invent fake answers, especially when asked about esoteric topics or for citations and URLs. In the same way that a sheet of notes can help a student do better on a test, providing reference text to these models can help in answering with fewer fabrications.
Tactics:
Instruct the model to answer using a reference text
Instruct the model to answer with citations from a reference text
Split complex tasks into simpler subtasks
Just as it is good practice in software engineering to decompose a complex system into a set of modular components, the same is true of tasks submitted to a language model. Complex tasks tend to have higher error rates than simpler tasks. Furthermore, complex tasks can often be re-defined as a workflow of simpler tasks in which the outputs of earlier tasks are used to construct the inputs to later tasks.
Tactics:
Use intent classification to identify the most relevant instructions for a user query
For dialogue applications that require very long conversations, summarize or filter previous dialogue
Summarize long documents piecewise and construct a full summary recursively
Give the model time to "think"
If asked to multiply 17 by 28, you might not know it instantly, but can still work it out with time. Similarly, models make more reasoning errors when trying to answer right away, rather than taking time to work out an answer. Asking for a "chain of thought" before an answer can help the model reason its way toward correct answers more reliably.
Tactics:
Instruct the model to work out its own solution before rushing to a conclusion
Use inner monologue or a sequence of queries to hide the model's reasoning process
Ask the model if it missed anything on previous passes
Use external tools
Compensate for the weaknesses of the model by feeding it the outputs of other tools. For example, a text retrieval system (sometimes called RAG or retrieval augmented generation) can tell the model about relevant documents. A code execution engine like OpenAI's Code Interpreter can help the model do math and run code. If a task can be done more reliably or efficiently by a tool rather than by a language model, offload it to get the best of both.
Tactics:
Use embeddings-based search to implement efficient knowledge retrieval
Use code execution to perform more accurate calculations or call external APIs
Give the model access to specific functions
Test changes systematically
Improving performance is easier if you can measure it. In some cases a modification to a prompt will achieve better performance on a few isolated examples but lead to worse overall performance on a more representative set of examples. Therefore to be sure that a change is net positive to performance it may be necessary to define a comprehensive test suite (also known an as an "eval").
Tactic:
Evaluate model outputs with reference to gold-standard answers
Tactics
Each of the strategies listed above can be instantiated with specific tactics. These tactics are meant to provide ideas for things to try. They are by no means fully comprehensive, and you should feel free to try creative ideas not represented here.
Strategy: Write clear instructions
Tactic: Include details in your query to get more relevant answers
In order to get a highly relevant response, make sure that requests provide any important details or context. Otherwise you are leaving it up to the model to guess what you mean.
Worse Better
How do I add numbers in Excel? How do I add up a row of dollar amounts in Excel? I want to do this automatically for a whole sheet of rows with all the totals ending up on the right in a column called "Total".
Whos president? Who was the president of Mexico in 2021, and how frequently are elections held?
Write code to calculate the Fibonacci sequence. Write a TypeScript function to efficiently calculate the Fibonacci sequence. Comment the code liberally to explain what each piece does and why it's written that way.
Summarize the meeting notes. Summarize the meeting notes in a single paragraph. Then write a markdown list of the speakers and each of their key points. Finally, list the next steps or action items suggested by the speakers, if any.
Tactic: Ask the model to adopt a persona
The system message can be used to specify the persona used by the model in its replies.
SYSTEM
When I ask for help to write something, you will reply with a document that contains at least one joke or playful comment in every paragraph.
USER
Write a thank you note to my steel bolt vendor for getting the delivery in on time and in short notice. This made it possible for us to deliver an important order.
Tactic: Use delimiters to clearly indicate distinct parts of the input
Delimiters like triple quotation marks, XML tags, section titles, etc. can help demarcate sections of text to be treated differently.
USER
Summarize the text delimited by triple quotes with a haiku.
"""insert text here"""
SYSTEM
You will be provided with a pair of articles (delimited with XML tags) about the same topic. First summarize the arguments of each article. Then indicate which of them makes a better argument and explain why.
USER
<article> insert first article here </article>
<article> insert second article here </article>
SYSTEM
You will be provided with a thesis abstract and a suggested title for it. The thesis title should give the reader a good idea of the topic of the thesis but should also be eye-catching. If the title does not meet these criteria, suggest 5 alternatives.
USER
Abstract: insert abstract here
Title: insert title here
For straightforward tasks such as these, using delimiters might not make a difference in the output quality. However, the more complex a task is the more important it is to disambiguate task details. Dont make the model work to understand exactly what you are asking of them.
Tactic: Specify the steps required to complete a task
Some tasks are best specified as a sequence of steps. Writing the steps out explicitly can make it easier for the model to follow them.
SYSTEM
Use the following step-by-step instructions to respond to user inputs.
Step 1 - The user will provide you with text in triple quotes. Summarize this text in one sentence with a prefix that says "Summary: ".
Step 2 - Translate the summary from Step 1 into Spanish, with a prefix that says "Translation: ".
USER
"""insert text here"""
Tactic: Provide examples
Providing general instructions that apply to all examples is generally more efficient than demonstrating all permutations of a task by example, but in some cases providing examples may be easier. For example, if you intend for the model to copy a particular style of responding to user queries which is difficult to describe explicitly. This is known as "few-shot" prompting.
SYSTEM
Answer in a consistent style.
USER
Teach me about patience.
ASSISTANT
The river that carves the deepest valley flows from a modest spring; the grandest symphony originates from a single note; the most intricate tapestry begins with a solitary thread.
USER
Teach me about the ocean.
Tactic: Specify the desired length of the output
You can ask the model to produce outputs that are of a given target length. The targeted output length can be specified in terms of the count of words, sentences, paragraphs, bullet points, etc. Note however that instructing the model to generate a specific number of words does not work with high precision. The model can more reliably generate outputs with a specific number of paragraphs or bullet points.
USER
Summarize the text delimited by triple quotes in about 50 words.
"""insert text here"""
USER
Summarize the text delimited by triple quotes in 2 paragraphs.
"""insert text here"""
USER
Summarize the text delimited by triple quotes in 3 bullet points.
"""insert text here"""
Strategy: Provide reference text
Tactic: Instruct the model to answer using a reference text
If we can provide a model with trusted information that is relevant to the current query, then we can instruct the model to use the provided information to compose its answer.
SYSTEM
Use the provided articles delimited by triple quotes to answer questions. If the answer cannot be found in the articles, write "I could not find an answer."
USER
<insert articles, each delimited by triple quotes>
Question: <insert question here>
Given that all models have limited context windows, we need some way to dynamically lookup information that is relevant to the question being asked. Embeddings can be used to implement efficient knowledge retrieval. See the tactic "Use embeddings-based search to implement efficient knowledge retrieval" for more details on how to implement this.
Tactic: Instruct the model to answer with citations from a reference text
If the input has been supplemented with relevant knowledge, it's straightforward to request that the model add citations to its answers by referencing passages from provided documents. Note that citations in the output can then be verified programmatically by string matching within the provided documents.
SYSTEM
You will be provided with a document delimited by triple quotes and a question. Your task is to answer the question using only the provided document and to cite the passage(s) of the document used to answer the question. If the document does not contain the information needed to answer this question then simply write: "Insufficient information." If an answer to the question is provided, it must be annotated with a citation. Use the following format for to cite relevant passages ({"citation": …}).
USER
"""<insert document here>"""
Question: <insert question here>
Strategy: Split complex tasks into simpler subtasks
Tactic: Use intent classification to identify the most relevant instructions for a user query
For tasks in which lots of independent sets of instructions are needed to handle different cases, it can be beneficial to first classify the type of query and to use that classification to determine which instructions are needed. This can be achieved by defining fixed categories and hard-coding instructions that are relevant for handling tasks in a given category. This process can also be applied recursively to decompose a task into a sequence of stages. The advantage of this approach is that each query will contain only those instructions that are required to perform the next stage of a task which can result in lower error rates compared to using a single query to perform the whole task. This can also result in lower costs since larger prompts cost more to run (see pricing information).
Suppose for example that for a customer service application, queries could be usefully classified as follows:
SYSTEM
You will be provided with customer service queries. Classify each query into a primary category and a secondary category. Provide your output in json format with the keys: primary and secondary.
Primary categories: Billing, Technical Support, Account Management, or General Inquiry.
Billing secondary categories:
- Unsubscribe or upgrade
- Add a payment method
- Explanation for charge
- Dispute a charge
Technical Support secondary categories:
- Troubleshooting
- Device compatibility
- Software updates
Account Management secondary categories:
- Password reset
- Update personal information
- Close account
- Account security
General Inquiry secondary categories:
- Product information
- Pricing
- Feedback
- Speak to a human
USER
I need to get my internet working again.
Based on the classification of the customer query, a set of more specific instructions can be provided to a model for it to handle next steps. For example, suppose the customer requires help with "troubleshooting".
SYSTEM
You will be provided with customer service inquiries that require troubleshooting in a technical support context. Help the user by:
- Ask them to check that all cables to/from the router are connected. Note that it is common for cables to come loose over time.
- If all cables are connected and the issue persists, ask them which router model they are using
- Now you will advise them how to restart their device:
-- If the model number is MTD-327J, advise them to push the red button and hold it for 5 seconds, then wait 5 minutes before testing the connection.
-- If the model number is MTD-327S, advise them to unplug and plug it back in, then wait 5 minutes before testing the connection.
- If the customer's issue persists after restarting the device and waiting 5 minutes, connect them to IT support by outputting {"IT support requested"}.
- If the user starts asking questions that are unrelated to this topic then confirm if they would like to end the current chat about troubleshooting and classify their request according to the following scheme:
<insert primary/secondary classification scheme from above here>
USER
I need to get my internet working again.
Notice that the model has been instructed to emit special strings to indicate when the state of the conversation changes. This enables us to turn our system into a state machine where the state determines which instructions are injected. By keeping track of state, what instructions are relevant at that state, and also optionally what state transitions are allowed from that state, we can put guardrails around the user experience that would be hard to achieve with a less structured approach.
Tactic: For dialogue applications that require very long conversations, summarize or filter previous dialogue
Since models have a fixed context length, dialogue between a user and an assistant in which the entire conversation is included in the context window cannot continue indefinitely.
There are various workarounds to this problem, one of which is to summarize previous turns in the conversation. Once the size of the input reaches a predetermined threshold length, this could trigger a query that summarizes part of the conversation and the summary of the prior conversation could be included as part of the system message. Alternatively, prior conversation could be summarized asynchronously in the background throughout the entire conversation.
An alternative solution is to dynamically select previous parts of the conversation that are most relevant to the current query. See the tactic "Use embeddings-based search to implement efficient knowledge retrieval".
Tactic: Summarize long documents piecewise and construct a full summary recursively
Since models have a fixed context length, they cannot be used to summarize a text longer than the context length minus the length of the generated summary in a single query.
To summarize a very long document such as a book we can use a sequence of queries to summarize each section of the document. Section summaries can be concatenated and summarized producing summaries of summaries. This process can proceed recursively until an entire document is summarized. If its necessary to use information about earlier sections in order to make sense of later sections, then a further trick that can be useful is to include a running summary of the text that precedes any given point in the book while summarizing content at that point. The effectiveness of this procedure for summarizing books has been studied in previous research by OpenAI using variants of GPT-3.
Strategy: Give models time to "think"
Tactic: Instruct the model to work out its own solution before rushing to a conclusion
Sometimes we get better results when we explicitly instruct the model to reason from first principles before coming to a conclusion. Suppose for example we want a model to evaluate a students solution to a math problem. The most obvious way to approach this is to simply ask the model if the student's solution is correct or not.
SYSTEM
Determine if the student's solution is correct or not.
USER
Problem Statement: I'm building a solar power installation and I need help working out the financials.
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost me a flat $100k per year, and an additional $10 / square foot
What is the total cost for the first year of operations as a function of the number of square feet.
Student's Solution: Let x be the size of the installation in square feet.
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
ASSISTANT
The student's solution is correct.
But the student's solution is actually not correct! We can get the model to successfully notice this by prompting the model to generate its own solution first.
SYSTEM
First work out your own solution to the problem. Then compare your solution to the student's solution and evaluate if the student's solution is correct or not. Don't decide if the student's solution is correct until you have done the problem yourself.
USER
Problem Statement: I'm building a solar power installation and I need help working out the financials.
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost me a flat $100k per year, and an additional $10 / square foot
What is the total cost for the first year of operations as a function of the number of square feet.
Student's Solution: Let x be the size of the installation in square feet.
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
ASSISTANT
Let x be the size of the installation in square feet.
4. Land cost: 100x
5. Solar panel cost: 250x
6. Maintenance cost: 100,000 + 10x
Total cost: 100x + 250x + 100,000 + 10x = 360x + 100,000
The student's solution is incorrect. They made an error in the maintenance cost calculation, using 100x instead of 10x. The correct total cost for the first year of operations is 360x + 100,000.
Tactic: Use inner monologue or a sequence of queries to hide the model's reasoning process
The previous tactic demonstrates that it is sometimes important for the model to reason in detail about a problem before answering a specific question. For some applications, the reasoning process that a model uses to arrive at a final answer would be inappropriate to share with the user. For example, in tutoring applications we may want to encourage students to work out their own answers, but a models reasoning process about the students solution could reveal the answer to the student.
Inner monologue is a tactic that can be used to mitigate this. The idea of inner monologue is to instruct the model to put parts of the output that are meant to be hidden from the user into a structured format that makes parsing them easy. Then before presenting the output to the user, the output is parsed and only part of the output is made visible.
SYSTEM
Follow these steps to answer the user queries.
Step 1 - First work out your own solution to the problem. Don't rely on the student's solution since it may be incorrect. Enclose all your work for this step within triple quotes (""").
Step 2 - Compare your solution to the student's solution and evaluate if the student's solution is correct or not. Enclose all your work for this step within triple quotes (""").
Step 3 - If the student made a mistake, determine what hint you could give the student without giving away the answer. Enclose all your work for this step within triple quotes (""").
Step 4 - If the student made a mistake, provide the hint from the previous step to the student (outside of triple quotes). Instead of writing "Step 4 - ..." write "Hint:".
USER
Problem Statement: <insert problem statement>
Student Solution: <insert student solution>
Alternatively, this can be achieved with a sequence of queries in which all except the last have their output hidden from the end user.
First, we can ask the model to solve the problem on its own. Since this initial query doesn't require the students solution, it can be omitted. This provides the additional advantage that there is no chance that the models solution will be biased by the students attempted solution.
USER
<insert problem statement>
Next, we can have the model use all available information to assess the correctness of the students solution.
SYSTEM
Compare your solution to the student's solution and evaluate if the student's solution is correct or not.
USER
Problem statement: """<insert problem statement>"""
Your solution: """<insert model generated solution>"""
Students solution: """<insert student's solution>"""
Finally, we can let the model use its own analysis to construct a reply in the persona of a helpful tutor.
SYSTEM
You are a math tutor. If the student made an error, offer a hint to the student in a way that does not reveal the answer. If the student did not make an error, simply offer them an encouraging comment.
USER
Problem statement: """<insert problem statement>"""
Your solution: """<insert model generated solution>"""
Students solution: """<insert student's solution>"""
Analysis: """<insert model generated analysis from previous step>"""
Tactic: Ask the model if it missed anything on previous passes
Suppose that we are using a model to list excerpts from a source which are relevant to a particular question. After listing each excerpt the model needs to determine if it should start writing another or if it should stop. If the source document is large, it is common for a model to stop too early and fail to list all relevant excerpts. In that case, better performance can often be obtained by prompting the model with followup queries to find any excerpts it missed on previous passes.
SYSTEM
You will be provided with a document delimited by triple quotes. Your task is to select excerpts which pertain to the following question: "What significant paradigm shifts have occurred in the history of artificial intelligence."
Ensure that excerpts contain all relevant context needed to interpret them - in other words don't extract small snippets that are missing important context. Provide output in JSON format as follows:
[{"excerpt": "..."},
...
{"excerpt": "..."}]
USER
"""<insert document here>"""
ASSISTANT
[{"excerpt": "the model writes an excerpt here"},
...
{"excerpt": "the model writes another excerpt here"}]
USER
Are there more relevant excerpts? Take care not to repeat excerpts. Also ensure that excerpts contain all relevant context needed to interpret them - in other words don't extract small snippets that are missing important context.
Strategy: Use external tools
Tactic: Use embeddings-based search to implement efficient knowledge retrieval
A model can leverage external sources of information if provided as part of its input. This can help the model to generate more informed and up-to-date responses. For example, if a user asks a question about a specific movie, it may be useful to add high quality information about the movie (e.g. actors, director, etc…) to the models input. Embeddings can be used to implement efficient knowledge retrieval, so that relevant information can be added to the model input dynamically at run-time.
A text embedding is a vector that can measure the relatedness between text strings. Similar or relevant strings will be closer together than unrelated strings. This fact, along with the existence of fast vector search algorithms means that embeddings can be used to implement efficient knowledge retrieval. In particular, a text corpus can be split up into chunks, and each chunk can be embedded and stored. Then a given query can be embedded and vector search can be performed to find the embedded chunks of text from the corpus that are most related to the query (i.e. closest together in the embedding space).
Example implementations can be found in the OpenAI Cookbook. See the tactic “Instruct the model to use retrieved knowledge to answer queries” for an example of how to use knowledge retrieval to minimize the likelihood that a model will make up incorrect facts.
Tactic: Use code execution to perform more accurate calculations or call external APIs
Language models cannot be relied upon to perform arithmetic or long calculations accurately on their own. In cases where this is needed, a model can be instructed to write and run code instead of making its own calculations. In particular, a model can be instructed to put code that is meant to be run into a designated format such as triple backtick. After an output is produced, the code can be extracted and run. Finally, if necessary, the output from the code execution engine (i.e. Python interpreter) can be provided as an input to the model for the next query.
SYSTEM
You can write and execute Python code by enclosing it in triple backticks, e.g. `code goes here`. Use this to perform calculations.
USER
Find all real-valued roots of the following polynomial: 3*x\*\*5 - 5*x**4 - 3\*x**3 - 7\*x - 10.
Another good use case for code execution is calling external APIs. If a model is instructed in the proper use of an API, it can write code that makes use of it. A model can be instructed in how to use an API by providing it with documentation and/or code samples showing how to use the API.
SYSTEM
You can write and execute Python code by enclosing it in triple backticks. Also note that you have access to the following module to help users send messages to their friends:
```python
import message
message.write(to="John", message="Hey, want to meetup after work?")
```
WARNING: Executing code produced by a model is not inherently safe and precautions should be taken in any application that seeks to do this. In particular, a sandboxed code execution environment is needed to limit the harm that untrusted code could cause.
Tactic: Give the model access to specific functions
The Chat Completions API allows passing a list of function descriptions in requests. This enables models to generate function arguments according to the provided schemas. Generated function arguments are returned by the API in JSON format and can be used to execute function calls. Output provided by function calls can then be fed back into a model in the following request to close the loop. This is the recommended way of using OpenAI models to call external functions. To learn more see the function calling section in our introductory text generation guide and more function calling examples in the OpenAI Cookbook.
Strategy: Test changes systematically
Sometimes it can be hard to tell whether a change — e.g., a new instruction or a new design — makes your system better or worse. Looking at a few examples may hint at which is better, but with small sample sizes it can be hard to distinguish between a true improvement or random luck. Maybe the change helps performance on some inputs, but hurts performance on others.
Evaluation procedures (or "evals") are useful for optimizing system designs. Good evals are:
Representative of real-world usage (or at least diverse)
Contain many test cases for greater statistical power (see table below for guidelines)
Easy to automate or repeat
DIFFERENCE TO DETECT SAMPLE SIZE NEEDED FOR 95% CONFIDENCE
30% ~10
10% ~100
3% ~1,000
1% ~10,000
Evaluation of outputs can be done by computers, humans, or a mix. Computers can automate evals with objective criteria (e.g., questions with single correct answers) as well as some subjective or fuzzy criteria, in which model outputs are evaluated by other model queries. OpenAI Evals is an open-source software framework that provides tools for creating automated evals.
Model-based evals can be useful when there exists a range of possible outputs that would be considered equally high in quality (e.g. for questions with long answers). The boundary between what can be realistically evaluated with a model-based eval and what requires a human to evaluate is fuzzy and is constantly shifting as models become more capable. We encourage experimentation to figure out how well model-based evals can work for your use case.
Tactic: Evaluate model outputs with reference to gold-standard answers
Suppose it is known that the correct answer to a question should make reference to a specific set of known facts. Then we can use a model query to count how many of the required facts are included in the answer.
For example, using the following system message:
SYSTEM
You will be provided with text delimited by triple quotes that is supposed to be the answer to a question. Check if the following pieces of information are directly contained in the answer:
- Neil Armstrong was the first person to walk on the moon.
- The date Neil Armstrong first walked on the moon was July 21, 1969.
For each of these points perform the following steps:
1 - Restate the point.
2 - Provide a citation from the answer which is closest to this point.
3 - Consider if someone reading the citation who doesn't know the topic could directly infer the point. Explain why or why not before making up your mind.
4 - Write "yes" if the answer to 3 was yes, otherwise write "no".
Finally, provide a count of how many "yes" answers there are. Provide this count as {"count": <insert count here>}.
Here's an example input where both points are satisfied:
SYSTEM
<insert system message above>
USER
"""Neil Armstrong is famous for being the first human to set foot on the Moon. This historic event took place on July 21, 1969, during the Apollo 11 mission."""
Here's an example input where only one point is satisfied:
SYSTEM
<insert system message above>
USER
"""Neil Armstrong made history when he stepped off the lunar module, becoming the first person to walk on the moon."""
Here's an example input where none are satisfied:
SYSTEM
<insert system message above>
USER
"""In the summer of '69, a voyage grand,
Apollo 11, bold as legend's hand.
Armstrong took a step, history unfurled,
"One small step," he said, for a new world."""
There are many possible variants on this type of model-based eval. Consider the following variation which tracks the kind of overlap between the candidate answer and the gold-standard answer, and also tracks whether the candidate answer contradicts any part of the gold-standard answer.
SYSTEM
Use the following steps to respond to user inputs. Fully restate each step before proceeding. i.e. "Step 1: Reason...".
Step 1: Reason step-by-step about whether the information in the submitted answer compared to the expert answer is either: disjoint, equal, a subset, a superset, or overlapping (i.e. some intersection but not subset/superset).
Step 2: Reason step-by-step about whether the submitted answer contradicts any aspect of the expert answer.
Step 3: Output a JSON object structured like: {"type_of_overlap": "disjoint" or "equal" or "subset" or "superset" or "overlapping", "contradiction": true or false}
Here's an example input with a substandard answer which nonetheless does not contradict the expert answer:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """Didn't he walk on the moon or something?"""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
Here's an example input with answer that directly contradicts the expert answer:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """On the 21st of July 1969, Neil Armstrong became the second person to walk on the moon, following after Buzz Aldrin."""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
Here's an example input with a correct answer that also provides a bit more detail than is necessary:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """At approximately 02:56 UTC on July 21st 1969, Neil Armstrong became the first human to set foot on the lunar surface, marking a monumental achievement in human history."""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
END PROMPT WRITING KNOWLEDGE
# STEPS:
- Interpret what the input was trying to accomplish.
- Read and understand the PROMPT WRITING KNOWLEDGE above.
- Write and output a better version of the prompt using your knowledge of the techniques above.
# OUTPUT INSTRUCTIONS:
1. Output the prompt in clean, human-readable Markdown format.
2. Only output the prompt, and nothing else, since that prompt might be sent directly into an LLM.
# INPUT
The following is the prompt you will improve:

View File

@@ -0,0 +1,522 @@
---
model: deepseek:deepseek-chat
---
# IDENTITY and PURPOSE
You are an expert LLM prompt writing service. You take an LLM/AI prompt as input and output a better prompt based on your prompt writing expertise and the knowledge below.
START PROMPT WRITING KNOWLEDGE
Prompt engineering
This guide shares strategies and tactics for getting better results from large language models (sometimes referred to as GPT models) like GPT-4. The methods described here can sometimes be deployed in combination for greater effect. We encourage experimentation to find the methods that work best for you.
Some of the examples demonstrated here currently work only with our most capable model, gpt-4. In general, if you find that a model fails at a task and a more capable model is available, it's often worth trying again with the more capable model.
You can also explore example prompts which showcase what our models are capable of:
Prompt examples
Explore prompt examples to learn what GPT models can do
Six strategies for getting better results
Write clear instructions
These models cant read your mind. If outputs are too long, ask for brief replies. If outputs are too simple, ask for expert-level writing. If you dislike the format, demonstrate the format youd like to see. The less the model has to guess at what you want, the more likely youll get it.
Tactics:
Include details in your query to get more relevant answers
Ask the model to adopt a persona
Use delimiters to clearly indicate distinct parts of the input
Specify the steps required to complete a task
Provide examples
Specify the desired length of the output
Provide reference text
Language models can confidently invent fake answers, especially when asked about esoteric topics or for citations and URLs. In the same way that a sheet of notes can help a student do better on a test, providing reference text to these models can help in answering with fewer fabrications.
Tactics:
Instruct the model to answer using a reference text
Instruct the model to answer with citations from a reference text
Split complex tasks into simpler subtasks
Just as it is good practice in software engineering to decompose a complex system into a set of modular components, the same is true of tasks submitted to a language model. Complex tasks tend to have higher error rates than simpler tasks. Furthermore, complex tasks can often be re-defined as a workflow of simpler tasks in which the outputs of earlier tasks are used to construct the inputs to later tasks.
Tactics:
Use intent classification to identify the most relevant instructions for a user query
For dialogue applications that require very long conversations, summarize or filter previous dialogue
Summarize long documents piecewise and construct a full summary recursively
Give the model time to "think"
If asked to multiply 17 by 28, you might not know it instantly, but can still work it out with time. Similarly, models make more reasoning errors when trying to answer right away, rather than taking time to work out an answer. Asking for a "chain of thought" before an answer can help the model reason its way toward correct answers more reliably.
Tactics:
Instruct the model to work out its own solution before rushing to a conclusion
Use inner monologue or a sequence of queries to hide the model's reasoning process
Ask the model if it missed anything on previous passes
Use external tools
Compensate for the weaknesses of the model by feeding it the outputs of other tools. For example, a text retrieval system (sometimes called RAG or retrieval augmented generation) can tell the model about relevant documents. A code execution engine like OpenAI's Code Interpreter can help the model do math and run code. If a task can be done more reliably or efficiently by a tool rather than by a language model, offload it to get the best of both.
Tactics:
Use embeddings-based search to implement efficient knowledge retrieval
Use code execution to perform more accurate calculations or call external APIs
Give the model access to specific functions
Test changes systematically
Improving performance is easier if you can measure it. In some cases a modification to a prompt will achieve better performance on a few isolated examples but lead to worse overall performance on a more representative set of examples. Therefore to be sure that a change is net positive to performance it may be necessary to define a comprehensive test suite (also known an as an "eval").
Tactic:
Evaluate model outputs with reference to gold-standard answers
Tactics
Each of the strategies listed above can be instantiated with specific tactics. These tactics are meant to provide ideas for things to try. They are by no means fully comprehensive, and you should feel free to try creative ideas not represented here.
Strategy: Write clear instructions
Tactic: Include details in your query to get more relevant answers
In order to get a highly relevant response, make sure that requests provide any important details or context. Otherwise you are leaving it up to the model to guess what you mean.
Worse Better
How do I add numbers in Excel? How do I add up a row of dollar amounts in Excel? I want to do this automatically for a whole sheet of rows with all the totals ending up on the right in a column called "Total".
Whos president? Who was the president of Mexico in 2021, and how frequently are elections held?
Write code to calculate the Fibonacci sequence. Write a TypeScript function to efficiently calculate the Fibonacci sequence. Comment the code liberally to explain what each piece does and why it's written that way.
Summarize the meeting notes. Summarize the meeting notes in a single paragraph. Then write a markdown list of the speakers and each of their key points. Finally, list the next steps or action items suggested by the speakers, if any.
Tactic: Ask the model to adopt a persona
The system message can be used to specify the persona used by the model in its replies.
SYSTEM
When I ask for help to write something, you will reply with a document that contains at least one joke or playful comment in every paragraph.
USER
Write a thank you note to my steel bolt vendor for getting the delivery in on time and in short notice. This made it possible for us to deliver an important order.
Tactic: Use delimiters to clearly indicate distinct parts of the input
Delimiters like triple quotation marks, XML tags, section titles, etc. can help demarcate sections of text to be treated differently.
USER
Summarize the text delimited by triple quotes with a haiku.
"""insert text here"""
SYSTEM
You will be provided with a pair of articles (delimited with XML tags) about the same topic. First summarize the arguments of each article. Then indicate which of them makes a better argument and explain why.
USER
<article> insert first article here </article>
<article> insert second article here </article>
SYSTEM
You will be provided with a thesis abstract and a suggested title for it. The thesis title should give the reader a good idea of the topic of the thesis but should also be eye-catching. If the title does not meet these criteria, suggest 5 alternatives.
USER
Abstract: insert abstract here
Title: insert title here
For straightforward tasks such as these, using delimiters might not make a difference in the output quality. However, the more complex a task is the more important it is to disambiguate task details. Dont make the model work to understand exactly what you are asking of them.
Tactic: Specify the steps required to complete a task
Some tasks are best specified as a sequence of steps. Writing the steps out explicitly can make it easier for the model to follow them.
SYSTEM
Use the following step-by-step instructions to respond to user inputs.
Step 1 - The user will provide you with text in triple quotes. Summarize this text in one sentence with a prefix that says "Summary: ".
Step 2 - Translate the summary from Step 1 into Spanish, with a prefix that says "Translation: ".
USER
"""insert text here"""
Tactic: Provide examples
Providing general instructions that apply to all examples is generally more efficient than demonstrating all permutations of a task by example, but in some cases providing examples may be easier. For example, if you intend for the model to copy a particular style of responding to user queries which is difficult to describe explicitly. This is known as "few-shot" prompting.
SYSTEM
Answer in a consistent style.
USER
Teach me about patience.
ASSISTANT
The river that carves the deepest valley flows from a modest spring; the grandest symphony originates from a single note; the most intricate tapestry begins with a solitary thread.
USER
Teach me about the ocean.
Tactic: Specify the desired length of the output
You can ask the model to produce outputs that are of a given target length. The targeted output length can be specified in terms of the count of words, sentences, paragraphs, bullet points, etc. Note however that instructing the model to generate a specific number of words does not work with high precision. The model can more reliably generate outputs with a specific number of paragraphs or bullet points.
USER
Summarize the text delimited by triple quotes in about 50 words.
"""insert text here"""
USER
Summarize the text delimited by triple quotes in 2 paragraphs.
"""insert text here"""
USER
Summarize the text delimited by triple quotes in 3 bullet points.
"""insert text here"""
Strategy: Provide reference text
Tactic: Instruct the model to answer using a reference text
If we can provide a model with trusted information that is relevant to the current query, then we can instruct the model to use the provided information to compose its answer.
SYSTEM
Use the provided articles delimited by triple quotes to answer questions. If the answer cannot be found in the articles, write "I could not find an answer."
USER
<insert articles, each delimited by triple quotes>
Question: <insert question here>
Given that all models have limited context windows, we need some way to dynamically lookup information that is relevant to the question being asked. Embeddings can be used to implement efficient knowledge retrieval. See the tactic "Use embeddings-based search to implement efficient knowledge retrieval" for more details on how to implement this.
Tactic: Instruct the model to answer with citations from a reference text
If the input has been supplemented with relevant knowledge, it's straightforward to request that the model add citations to its answers by referencing passages from provided documents. Note that citations in the output can then be verified programmatically by string matching within the provided documents.
SYSTEM
You will be provided with a document delimited by triple quotes and a question. Your task is to answer the question using only the provided document and to cite the passage(s) of the document used to answer the question. If the document does not contain the information needed to answer this question then simply write: "Insufficient information." If an answer to the question is provided, it must be annotated with a citation. Use the following format for to cite relevant passages ({"citation": …}).
USER
"""<insert document here>"""
Question: <insert question here>
Strategy: Split complex tasks into simpler subtasks
Tactic: Use intent classification to identify the most relevant instructions for a user query
For tasks in which lots of independent sets of instructions are needed to handle different cases, it can be beneficial to first classify the type of query and to use that classification to determine which instructions are needed. This can be achieved by defining fixed categories and hard-coding instructions that are relevant for handling tasks in a given category. This process can also be applied recursively to decompose a task into a sequence of stages. The advantage of this approach is that each query will contain only those instructions that are required to perform the next stage of a task which can result in lower error rates compared to using a single query to perform the whole task. This can also result in lower costs since larger prompts cost more to run (see pricing information).
Suppose for example that for a customer service application, queries could be usefully classified as follows:
SYSTEM
You will be provided with customer service queries. Classify each query into a primary category and a secondary category. Provide your output in json format with the keys: primary and secondary.
Primary categories: Billing, Technical Support, Account Management, or General Inquiry.
Billing secondary categories:
- Unsubscribe or upgrade
- Add a payment method
- Explanation for charge
- Dispute a charge
Technical Support secondary categories:
- Troubleshooting
- Device compatibility
- Software updates
Account Management secondary categories:
- Password reset
- Update personal information
- Close account
- Account security
General Inquiry secondary categories:
- Product information
- Pricing
- Feedback
- Speak to a human
USER
I need to get my internet working again.
Based on the classification of the customer query, a set of more specific instructions can be provided to a model for it to handle next steps. For example, suppose the customer requires help with "troubleshooting".
SYSTEM
You will be provided with customer service inquiries that require troubleshooting in a technical support context. Help the user by:
- Ask them to check that all cables to/from the router are connected. Note that it is common for cables to come loose over time.
- If all cables are connected and the issue persists, ask them which router model they are using
- Now you will advise them how to restart their device:
-- If the model number is MTD-327J, advise them to push the red button and hold it for 5 seconds, then wait 5 minutes before testing the connection.
-- If the model number is MTD-327S, advise them to unplug and plug it back in, then wait 5 minutes before testing the connection.
- If the customer's issue persists after restarting the device and waiting 5 minutes, connect them to IT support by outputting {"IT support requested"}.
- If the user starts asking questions that are unrelated to this topic then confirm if they would like to end the current chat about troubleshooting and classify their request according to the following scheme:
<insert primary/secondary classification scheme from above here>
USER
I need to get my internet working again.
Notice that the model has been instructed to emit special strings to indicate when the state of the conversation changes. This enables us to turn our system into a state machine where the state determines which instructions are injected. By keeping track of state, what instructions are relevant at that state, and also optionally what state transitions are allowed from that state, we can put guardrails around the user experience that would be hard to achieve with a less structured approach.
Tactic: For dialogue applications that require very long conversations, summarize or filter previous dialogue
Since models have a fixed context length, dialogue between a user and an assistant in which the entire conversation is included in the context window cannot continue indefinitely.
There are various workarounds to this problem, one of which is to summarize previous turns in the conversation. Once the size of the input reaches a predetermined threshold length, this could trigger a query that summarizes part of the conversation and the summary of the prior conversation could be included as part of the system message. Alternatively, prior conversation could be summarized asynchronously in the background throughout the entire conversation.
An alternative solution is to dynamically select previous parts of the conversation that are most relevant to the current query. See the tactic "Use embeddings-based search to implement efficient knowledge retrieval".
Tactic: Summarize long documents piecewise and construct a full summary recursively
Since models have a fixed context length, they cannot be used to summarize a text longer than the context length minus the length of the generated summary in a single query.
To summarize a very long document such as a book we can use a sequence of queries to summarize each section of the document. Section summaries can be concatenated and summarized producing summaries of summaries. This process can proceed recursively until an entire document is summarized. If its necessary to use information about earlier sections in order to make sense of later sections, then a further trick that can be useful is to include a running summary of the text that precedes any given point in the book while summarizing content at that point. The effectiveness of this procedure for summarizing books has been studied in previous research by OpenAI using variants of GPT-3.
Strategy: Give models time to "think"
Tactic: Instruct the model to work out its own solution before rushing to a conclusion
Sometimes we get better results when we explicitly instruct the model to reason from first principles before coming to a conclusion. Suppose for example we want a model to evaluate a students solution to a math problem. The most obvious way to approach this is to simply ask the model if the student's solution is correct or not.
SYSTEM
Determine if the student's solution is correct or not.
USER
Problem Statement: I'm building a solar power installation and I need help working out the financials.
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost me a flat $100k per year, and an additional $10 / square foot
What is the total cost for the first year of operations as a function of the number of square feet.
Student's Solution: Let x be the size of the installation in square feet.
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
ASSISTANT
The student's solution is correct.
But the student's solution is actually not correct! We can get the model to successfully notice this by prompting the model to generate its own solution first.
SYSTEM
First work out your own solution to the problem. Then compare your solution to the student's solution and evaluate if the student's solution is correct or not. Don't decide if the student's solution is correct until you have done the problem yourself.
USER
Problem Statement: I'm building a solar power installation and I need help working out the financials.
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost me a flat $100k per year, and an additional $10 / square foot
What is the total cost for the first year of operations as a function of the number of square feet.
Student's Solution: Let x be the size of the installation in square feet.
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
ASSISTANT
Let x be the size of the installation in square feet.
4. Land cost: 100x
5. Solar panel cost: 250x
6. Maintenance cost: 100,000 + 10x
Total cost: 100x + 250x + 100,000 + 10x = 360x + 100,000
The student's solution is incorrect. They made an error in the maintenance cost calculation, using 100x instead of 10x. The correct total cost for the first year of operations is 360x + 100,000.
Tactic: Use inner monologue or a sequence of queries to hide the model's reasoning process
The previous tactic demonstrates that it is sometimes important for the model to reason in detail about a problem before answering a specific question. For some applications, the reasoning process that a model uses to arrive at a final answer would be inappropriate to share with the user. For example, in tutoring applications we may want to encourage students to work out their own answers, but a models reasoning process about the students solution could reveal the answer to the student.
Inner monologue is a tactic that can be used to mitigate this. The idea of inner monologue is to instruct the model to put parts of the output that are meant to be hidden from the user into a structured format that makes parsing them easy. Then before presenting the output to the user, the output is parsed and only part of the output is made visible.
SYSTEM
Follow these steps to answer the user queries.
Step 1 - First work out your own solution to the problem. Don't rely on the student's solution since it may be incorrect. Enclose all your work for this step within triple quotes (""").
Step 2 - Compare your solution to the student's solution and evaluate if the student's solution is correct or not. Enclose all your work for this step within triple quotes (""").
Step 3 - If the student made a mistake, determine what hint you could give the student without giving away the answer. Enclose all your work for this step within triple quotes (""").
Step 4 - If the student made a mistake, provide the hint from the previous step to the student (outside of triple quotes). Instead of writing "Step 4 - ..." write "Hint:".
USER
Problem Statement: <insert problem statement>
Student Solution: <insert student solution>
Alternatively, this can be achieved with a sequence of queries in which all except the last have their output hidden from the end user.
First, we can ask the model to solve the problem on its own. Since this initial query doesn't require the students solution, it can be omitted. This provides the additional advantage that there is no chance that the models solution will be biased by the students attempted solution.
USER
<insert problem statement>
Next, we can have the model use all available information to assess the correctness of the students solution.
SYSTEM
Compare your solution to the student's solution and evaluate if the student's solution is correct or not.
USER
Problem statement: """<insert problem statement>"""
Your solution: """<insert model generated solution>"""
Students solution: """<insert student's solution>"""
Finally, we can let the model use its own analysis to construct a reply in the persona of a helpful tutor.
SYSTEM
You are a math tutor. If the student made an error, offer a hint to the student in a way that does not reveal the answer. If the student did not make an error, simply offer them an encouraging comment.
USER
Problem statement: """<insert problem statement>"""
Your solution: """<insert model generated solution>"""
Students solution: """<insert student's solution>"""
Analysis: """<insert model generated analysis from previous step>"""
Tactic: Ask the model if it missed anything on previous passes
Suppose that we are using a model to list excerpts from a source which are relevant to a particular question. After listing each excerpt the model needs to determine if it should start writing another or if it should stop. If the source document is large, it is common for a model to stop too early and fail to list all relevant excerpts. In that case, better performance can often be obtained by prompting the model with followup queries to find any excerpts it missed on previous passes.
SYSTEM
You will be provided with a document delimited by triple quotes. Your task is to select excerpts which pertain to the following question: "What significant paradigm shifts have occurred in the history of artificial intelligence."
Ensure that excerpts contain all relevant context needed to interpret them - in other words don't extract small snippets that are missing important context. Provide output in JSON format as follows:
[{"excerpt": "..."},
...
{"excerpt": "..."}]
USER
"""<insert document here>"""
ASSISTANT
[{"excerpt": "the model writes an excerpt here"},
...
{"excerpt": "the model writes another excerpt here"}]
USER
Are there more relevant excerpts? Take care not to repeat excerpts. Also ensure that excerpts contain all relevant context needed to interpret them - in other words don't extract small snippets that are missing important context.
Strategy: Use external tools
Tactic: Use embeddings-based search to implement efficient knowledge retrieval
A model can leverage external sources of information if provided as part of its input. This can help the model to generate more informed and up-to-date responses. For example, if a user asks a question about a specific movie, it may be useful to add high quality information about the movie (e.g. actors, director, etc…) to the models input. Embeddings can be used to implement efficient knowledge retrieval, so that relevant information can be added to the model input dynamically at run-time.
A text embedding is a vector that can measure the relatedness between text strings. Similar or relevant strings will be closer together than unrelated strings. This fact, along with the existence of fast vector search algorithms means that embeddings can be used to implement efficient knowledge retrieval. In particular, a text corpus can be split up into chunks, and each chunk can be embedded and stored. Then a given query can be embedded and vector search can be performed to find the embedded chunks of text from the corpus that are most related to the query (i.e. closest together in the embedding space).
Example implementations can be found in the OpenAI Cookbook. See the tactic “Instruct the model to use retrieved knowledge to answer queries” for an example of how to use knowledge retrieval to minimize the likelihood that a model will make up incorrect facts.
Tactic: Use code execution to perform more accurate calculations or call external APIs
Language models cannot be relied upon to perform arithmetic or long calculations accurately on their own. In cases where this is needed, a model can be instructed to write and run code instead of making its own calculations. In particular, a model can be instructed to put code that is meant to be run into a designated format such as triple backtick. After an output is produced, the code can be extracted and run. Finally, if necessary, the output from the code execution engine (i.e. Python interpreter) can be provided as an input to the model for the next query.
SYSTEM
You can write and execute Python code by enclosing it in triple backticks, e.g. `code goes here`. Use this to perform calculations.
USER
Find all real-valued roots of the following polynomial: 3*x\*\*5 - 5*x**4 - 3\*x**3 - 7\*x - 10.
Another good use case for code execution is calling external APIs. If a model is instructed in the proper use of an API, it can write code that makes use of it. A model can be instructed in how to use an API by providing it with documentation and/or code samples showing how to use the API.
SYSTEM
You can write and execute Python code by enclosing it in triple backticks. Also note that you have access to the following module to help users send messages to their friends:
```python
import message
message.write(to="John", message="Hey, want to meetup after work?")
```
WARNING: Executing code produced by a model is not inherently safe and precautions should be taken in any application that seeks to do this. In particular, a sandboxed code execution environment is needed to limit the harm that untrusted code could cause.
Tactic: Give the model access to specific functions
The Chat Completions API allows passing a list of function descriptions in requests. This enables models to generate function arguments according to the provided schemas. Generated function arguments are returned by the API in JSON format and can be used to execute function calls. Output provided by function calls can then be fed back into a model in the following request to close the loop. This is the recommended way of using OpenAI models to call external functions. To learn more see the function calling section in our introductory text generation guide and more function calling examples in the OpenAI Cookbook.
Strategy: Test changes systematically
Sometimes it can be hard to tell whether a change — e.g., a new instruction or a new design — makes your system better or worse. Looking at a few examples may hint at which is better, but with small sample sizes it can be hard to distinguish between a true improvement or random luck. Maybe the change helps performance on some inputs, but hurts performance on others.
Evaluation procedures (or "evals") are useful for optimizing system designs. Good evals are:
Representative of real-world usage (or at least diverse)
Contain many test cases for greater statistical power (see table below for guidelines)
Easy to automate or repeat
DIFFERENCE TO DETECT SAMPLE SIZE NEEDED FOR 95% CONFIDENCE
30% ~10
10% ~100
3% ~1,000
1% ~10,000
Evaluation of outputs can be done by computers, humans, or a mix. Computers can automate evals with objective criteria (e.g., questions with single correct answers) as well as some subjective or fuzzy criteria, in which model outputs are evaluated by other model queries. OpenAI Evals is an open-source software framework that provides tools for creating automated evals.
Model-based evals can be useful when there exists a range of possible outputs that would be considered equally high in quality (e.g. for questions with long answers). The boundary between what can be realistically evaluated with a model-based eval and what requires a human to evaluate is fuzzy and is constantly shifting as models become more capable. We encourage experimentation to figure out how well model-based evals can work for your use case.
Tactic: Evaluate model outputs with reference to gold-standard answers
Suppose it is known that the correct answer to a question should make reference to a specific set of known facts. Then we can use a model query to count how many of the required facts are included in the answer.
For example, using the following system message:
SYSTEM
You will be provided with text delimited by triple quotes that is supposed to be the answer to a question. Check if the following pieces of information are directly contained in the answer:
- Neil Armstrong was the first person to walk on the moon.
- The date Neil Armstrong first walked on the moon was July 21, 1969.
For each of these points perform the following steps:
1 - Restate the point.
2 - Provide a citation from the answer which is closest to this point.
3 - Consider if someone reading the citation who doesn't know the topic could directly infer the point. Explain why or why not before making up your mind.
4 - Write "yes" if the answer to 3 was yes, otherwise write "no".
Finally, provide a count of how many "yes" answers there are. Provide this count as {"count": <insert count here>}.
Here's an example input where both points are satisfied:
SYSTEM
<insert system message above>
USER
"""Neil Armstrong is famous for being the first human to set foot on the Moon. This historic event took place on July 21, 1969, during the Apollo 11 mission."""
Here's an example input where only one point is satisfied:
SYSTEM
<insert system message above>
USER
"""Neil Armstrong made history when he stepped off the lunar module, becoming the first person to walk on the moon."""
Here's an example input where none are satisfied:
SYSTEM
<insert system message above>
USER
"""In the summer of '69, a voyage grand,
Apollo 11, bold as legend's hand.
Armstrong took a step, history unfurled,
"One small step," he said, for a new world."""
There are many possible variants on this type of model-based eval. Consider the following variation which tracks the kind of overlap between the candidate answer and the gold-standard answer, and also tracks whether the candidate answer contradicts any part of the gold-standard answer.
SYSTEM
Use the following steps to respond to user inputs. Fully restate each step before proceeding. i.e. "Step 1: Reason...".
Step 1: Reason step-by-step about whether the information in the submitted answer compared to the expert answer is either: disjoint, equal, a subset, a superset, or overlapping (i.e. some intersection but not subset/superset).
Step 2: Reason step-by-step about whether the submitted answer contradicts any aspect of the expert answer.
Step 3: Output a JSON object structured like: {"type_of_overlap": "disjoint" or "equal" or "subset" or "superset" or "overlapping", "contradiction": true or false}
Here's an example input with a substandard answer which nonetheless does not contradict the expert answer:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """Didn't he walk on the moon or something?"""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
Here's an example input with answer that directly contradicts the expert answer:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """On the 21st of July 1969, Neil Armstrong became the second person to walk on the moon, following after Buzz Aldrin."""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
Here's an example input with a correct answer that also provides a bit more detail than is necessary:
SYSTEM
<insert system message above>
USER
Question: """What event is Neil Armstrong most famous for and on what date did it occur? Assume UTC time."""
Submitted Answer: """At approximately 02:56 UTC on July 21st 1969, Neil Armstrong became the first human to set foot on the lunar surface, marking a monumental achievement in human history."""
Expert Answer: """Neil Armstrong is most famous for being the first person to walk on the moon. This historic event occurred on July 21, 1969."""
END PROMPT WRITING KNOWLEDGE
# STEPS:
- Interpret what the input was trying to accomplish.
- Read and understand the PROMPT WRITING KNOWLEDGE above.
- Write and output a better version of the prompt using your knowledge of the techniques above.
# OUTPUT INSTRUCTIONS:
1. Output the prompt in clean, human-readable Markdown format.
2. Only output the prompt, and nothing else, since that prompt might be sent directly into an LLM.
# INPUT
The following is the prompt you will improve:

View File

@@ -0,0 +1,31 @@
---
model: deepseek:deepseek-chat
---
# LinkedIn Response Assistant
**Instructions:**
1. Carefully analyze the received LinkedIn message below, noting its tone, structure, and key points.
2. Review my draft response/suggestions and incorporate them naturally.
3. Craft a professional yet human response that:
- Matches the original message's tone and structure
- Is concise but complete (3-5 sentences typically)
- Sounds natural and personable (avoid robotic phrasing)
- Addresses all points from the original message
- Builds rapport when appropriate
**Input Format:**
```
Message:
<received message here>
Draft/Notes:
<my draft response, suggestions, or key points to include>
```
**Output Requirements:**
- Return ONLY the formatted LinkedIn response message
- Use the same greeting style as the original message
- Maintain similar paragraph structure and length
- Include proper spacing and formatting for readability
- Do not include any meta-commentary or notes

View File

@@ -1,5 +0,0 @@
---
model: deepseek:deepseek-chat
---
Your task is to take the text provided and rewrite it into a clear, grammatically correct version while preserving the original meaning as closely as possible. Correct any spelling mistakes, punctuation errors, verb tense issues, word choice problems, and other grammatical mistakes. Responde with just a varinat or varinats of improved text.

View File

@@ -1,6 +1,22 @@
--- ---
model: ollama:llama3.2:3b model: ollama:gemma3:4b
--- ---
convert __INPUT__ to emoji. # Emoji Conversion Prompt
response: just an emoji or emojies, without words or explanations
**Task:**
Convert the user's input text into a single, most representative emoji that captures the core meaning or emotion of the message.
**Rules:**
1. Respond **only** with one emoji—no words, explanations, or additional characters.
2. Choose the emoji that best symbolizes the essence of the input (e.g., "happy" → 😊, "rain" → 🌧️).
3. If the input is ambiguous or unclear, default to a neutral symbol (e.g., ❓ or 🤔).
**Example Inputs & Outputs:**
- "I love pizza" → 🍕
- "I'm so tired" → 😴
- "Celebration!" → 🎉
**Note:**
- Avoid combining multiple emojis.
- Prioritize universally recognized emojis (Unicode standard).

View File

@@ -0,0 +1,31 @@
---
model: ollama:gemma3:4b
---
# Enhanced Emoji Conversion Prompt
**Role:** You are an expert emoji translator that converts any input text into the most accurate and expressive emoji representation.
**Instructions:**
1. Receive text input from the user
2. Analyze the meaning, context, and emotional tone of the input
3. Select the most appropriate emoji or emoji sequence that captures:
- Core meaning
- Emotional tone
- Key concepts
4. Only respond with emoji - no words, explanations, or additional text
5. For complex concepts, use multiple emojis in a logical sequence (maximum 5 emojis)
6. Prioritize clarity and recognizability over creativity
**Examples:**
Input: "I love pizza"
Output: 🍕❤️
Input: "It's raining cats and dogs"
Output: 🌧️🐱🐶
Input: "I'm feeling excited about the trip!"
Output: ✈️🎉😃
**Response Format:**
[Your response should contain only emoji characters with no additional text or formatting]

View File

@@ -4,7 +4,7 @@
# Specify desired highlighting theme (e.g. "TwoDark"). Run `bat --list-themes` # Specify desired highlighting theme (e.g. "TwoDark"). Run `bat --list-themes`
# for a list of all available themes # for a list of all available themes
--theme="Catppuccin-macchiato" --theme="Catppuccin Macchiato"
# Enable this to use italic text on the terminal. This is not supported on all # Enable this to use italic text on the terminal. This is not supported on all
# terminal emulators (like tmux, by default): # terminal emulators (like tmux, by default):

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,959 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>name</key>
<string>Catppuccin</string>
<key>settings</key>
<array>
<dict>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6d0f5</string>
<key>background</key>
<string>#303446</string>
<key>caret</key>
<string>#b5bfe2</string>
<key>invisibles</key>
<string>#a5adce</string>
<key>gutterForeground</key>
<string>#949cbb</string>
<key>gutterForegroundHighlight</key>
<string>#a6d189</string>
<key>lineHighlight</key>
<string>#626880</string>
<key>selection</key>
<string>#737994</string>
<key>selectionBorder</key>
<string>#303446</string>
<key>activeGuide</key>
<string>#ef9f76</string>
<key>findHighlightForeground</key>
<string>#292c3c</string>
<key>findHighlight</key>
<string>#e5c890</string>
<key>bracketsForeground</key>
<string>#949cbb</string>
<key>bracketContentsForeground</key>
<string>#949cbb</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Comment</string>
<key>scope</key>
<string>comment</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#737994</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String</string>
<key>scope</key>
<string>string</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6d189</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String regex</string>
<key>scope</key>
<string>string.regexp</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Number</string>
<key>scope</key>
<string>constant.numeric</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Boolean</string>
<key>scope</key>
<string>constant.language.boolean</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string>bold italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in constant</string>
<key>scope</key>
<string>constant.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#babbf1</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in function</string>
<key>scope</key>
<string>support.function.builtin</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>User-defined constant</string>
<key>scope</key>
<string>variable.other.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable</string>
<key>scope</key>
<string>variable</string>
<key>settings</key>
<dict></dict>
</dict>
<dict>
<key>name</key>
<string>Keyword</string>
<key>scope</key>
<string>keyword</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Conditional/loop</string>
<key>scope</key>
<string>keyword.control.loop, keyword.control.conditional, keyword.control.c++</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ca9ee6</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Return</string>
<key>scope</key>
<string>keyword.control.return, keyword.control.flow.return</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4b8e4</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Exception</string>
<key>scope</key>
<string>support.type.exception</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Operator</string>
<key>scope</key>
<string>keyword.operator, punctuation.accessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#99d1db</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation separator</string>
<key>scope</key>
<string>punctuation.separator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation terminator</string>
<key>scope</key>
<string>punctuation.terminator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation bracket</string>
<key>scope</key>
<string>punctuation.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#949cbb</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Include</string>
<key>scope</key>
<string>keyword.control.import.include</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage</string>
<key>scope</key>
<string>storage</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type</string>
<key>scope</key>
<string>storage.type</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e5c890</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage modifier</string>
<key>scope</key>
<string>storage.modifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type namespace</string>
<key>scope</key>
<string>entity.name.namespace, meta.path</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type class</string>
<key>scope</key>
<string>storage.type.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Label</string>
<key>scope</key>
<string>entity.name.label</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Keyword class</string>
<key>scope</key>
<string>keyword.declaration.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Class name</string>
<key>scope</key>
<string>entity.name.class, meta.toc-list.full-identifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#99d1db</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Inherited class</string>
<key>scope</key>
<string>entity.other.inherited-class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#99d1db</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function name</string>
<key>scope</key>
<string>entity.name.function, variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function macro</string>
<key>scope</key>
<string>entity.name.function.preprocessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Macro directive - ifdef</string>
<key>scope</key>
<string>keyword.control.import</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Constructor</string>
<key>scope</key>
<string>entity.name.function.constructor, entity.name.function.destructor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#babbf1</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function argument</string>
<key>scope</key>
<string>variable.parameter.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function declaration</string>
<key>scope</key>
<string>keyword.declaration.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea999c</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library function</string>
<key>scope</key>
<string>support.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#99d1db</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library constant</string>
<key>scope</key>
<string>support.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library class/type</string>
<key>scope</key>
<string>support.type, support.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library variable</string>
<key>scope</key>
<string>support.other.variable</string>
<key>settings</key>
<dict>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable function</string>
<key>scope</key>
<string>variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable parameter</string>
<key>scope</key>
<string>variable.parameter</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable other</string>
<key>scope</key>
<string>variable.other</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6d0f5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable field</string>
<key>scope</key>
<string>variable.other.member</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable language</string>
<key>scope</key>
<string>variable.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag name</string>
<key>scope</key>
<string>entity.name.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ef9f76</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag attribute</string>
<key>scope</key>
<string>entity.other.attribute-name</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ca9ee6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag delimiter</string>
<key>scope</key>
<string>punctuation.definition.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea999c</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown URL</string>
<key>scope</key>
<string>markup.underline.link.markdown</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2d5cf</string>
<key>fontStyle</key>
<string>italic underline</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown reference</string>
<key>scope</key>
<string>meta.link.inline.description</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#babbf1</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown literal</string>
<key>scope</key>
<string>comment.block.markdown, meta.code-fence, markup.raw.code-fence, markup.raw.inline</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown title</string>
<key>scope</key>
<string>punctuation.definition.heading, entity.name.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8caaee</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown emphasis</string>
<key>scope</key>
<string>markup.italic</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea999c</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown strong</string>
<key>scope</key>
<string>markup.bold</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea999c</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Escape</string>
<key>scope</key>
<string>constant.character.escape</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4b8e4</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash built-in function</string>
<key>scope</key>
<string>source.shell.bash meta.function.shell meta.compound.shell meta.function-call.identifier.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4b8e4</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash parameter</string>
<key>scope</key>
<string>variable.language.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua field</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.value.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#babbf1</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua constructor</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eebebe</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Java constant</string>
<key>scope</key>
<string>entity.name.constant.java</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS property</string>
<key>scope</key>
<string>support.type.property-name.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eebebe</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS constant</string>
<key>scope</key>
<string>support.constant.property-value.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6d0f5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS suffix</string>
<key>scope</key>
<string>constant.numeric.suffix.css, keyword.other.unit.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS variable property</string>
<key>scope</key>
<string>variable.other.custom-property.name.css, support.type.custom-property.name.css, punctuation.definition.custom-property.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SCSS tag</string>
<key>scope</key>
<string>entity.name.tag.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#babbf1</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SASS variable</string>
<key>scope</key>
<string>variable.other.sass</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#81c8be</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid</string>
<key>scope</key>
<string>invalid</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6d0f5</string>
<key>background</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid deprecated</string>
<key>scope</key>
<string>invalid.deprecated</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6d0f5</string>
<key>background</key>
<string>#ca9ee6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff header</string>
<key>scope</key>
<string>meta.diff, meta.diff.header</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#737994</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff deleted</string>
<key>scope</key>
<string>markup.deleted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff inserted</string>
<key>scope</key>
<string>markup.inserted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6d189</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff changed</string>
<key>scope</key>
<string>markup.changed</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e5c890</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Message error</string>
<key>scope</key>
<string>message.error</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e78284</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
</array>
<key>uuid</key>
<string>4d0379b5-ef82-467b-b8b8-365889420646</string>
<key>colorSpaceName</key>
<string>sRGB</string>
<key>semanticClass</key>
<string>theme.dark.Catppuccin</string>
<key>author</key>
<string>BrunDerSchwarzmagier</string>
</dict>
</plist>

View File

@@ -1,959 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>name</key>
<string>Catppuccin</string>
<key>settings</key>
<array>
<dict>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#4c4f69</string>
<key>background</key>
<string>#eff1f5</string>
<key>caret</key>
<string>#5c5f77</string>
<key>invisibles</key>
<string>#6c6f85</string>
<key>gutterForeground</key>
<string>#7c7f93</string>
<key>gutterForegroundHighlight</key>
<string>#40a02b</string>
<key>lineHighlight</key>
<string>#acb0be</string>
<key>selection</key>
<string>#9ca0b0</string>
<key>selectionBorder</key>
<string>#eff1f5</string>
<key>activeGuide</key>
<string>#fe640b</string>
<key>findHighlightForeground</key>
<string>#e6e9ef</string>
<key>findHighlight</key>
<string>#df8e1d</string>
<key>bracketsForeground</key>
<string>#7c7f93</string>
<key>bracketContentsForeground</key>
<string>#7c7f93</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Comment</string>
<key>scope</key>
<string>comment</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#9ca0b0</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String</string>
<key>scope</key>
<string>string</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#40a02b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String regex</string>
<key>scope</key>
<string>string.regexp</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Number</string>
<key>scope</key>
<string>constant.numeric</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Boolean</string>
<key>scope</key>
<string>constant.language.boolean</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string>bold italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in constant</string>
<key>scope</key>
<string>constant.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7287fd</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in function</string>
<key>scope</key>
<string>support.function.builtin</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>User-defined constant</string>
<key>scope</key>
<string>variable.other.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable</string>
<key>scope</key>
<string>variable</string>
<key>settings</key>
<dict></dict>
</dict>
<dict>
<key>name</key>
<string>Keyword</string>
<key>scope</key>
<string>keyword</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Conditional/loop</string>
<key>scope</key>
<string>keyword.control.loop, keyword.control.conditional, keyword.control.c++</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8839ef</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Return</string>
<key>scope</key>
<string>keyword.control.return, keyword.control.flow.return</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea76cb</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Exception</string>
<key>scope</key>
<string>support.type.exception</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Operator</string>
<key>scope</key>
<string>keyword.operator, punctuation.accessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#04a5e5</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation separator</string>
<key>scope</key>
<string>punctuation.separator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation terminator</string>
<key>scope</key>
<string>punctuation.terminator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation bracket</string>
<key>scope</key>
<string>punctuation.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7c7f93</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Include</string>
<key>scope</key>
<string>keyword.control.import.include</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage</string>
<key>scope</key>
<string>storage</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type</string>
<key>scope</key>
<string>storage.type</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#df8e1d</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage modifier</string>
<key>scope</key>
<string>storage.modifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type namespace</string>
<key>scope</key>
<string>entity.name.namespace, meta.path</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type class</string>
<key>scope</key>
<string>storage.type.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Label</string>
<key>scope</key>
<string>entity.name.label</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Keyword class</string>
<key>scope</key>
<string>keyword.declaration.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Class name</string>
<key>scope</key>
<string>entity.name.class, meta.toc-list.full-identifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#04a5e5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Inherited class</string>
<key>scope</key>
<string>entity.other.inherited-class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#04a5e5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function name</string>
<key>scope</key>
<string>entity.name.function, variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function macro</string>
<key>scope</key>
<string>entity.name.function.preprocessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Macro directive - ifdef</string>
<key>scope</key>
<string>keyword.control.import</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Constructor</string>
<key>scope</key>
<string>entity.name.function.constructor, entity.name.function.destructor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7287fd</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function argument</string>
<key>scope</key>
<string>variable.parameter.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function declaration</string>
<key>scope</key>
<string>keyword.declaration.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e64553</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library function</string>
<key>scope</key>
<string>support.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#04a5e5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library constant</string>
<key>scope</key>
<string>support.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library class/type</string>
<key>scope</key>
<string>support.type, support.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library variable</string>
<key>scope</key>
<string>support.other.variable</string>
<key>settings</key>
<dict>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable function</string>
<key>scope</key>
<string>variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable parameter</string>
<key>scope</key>
<string>variable.parameter</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable other</string>
<key>scope</key>
<string>variable.other</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#4c4f69</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable field</string>
<key>scope</key>
<string>variable.other.member</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable language</string>
<key>scope</key>
<string>variable.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag name</string>
<key>scope</key>
<string>entity.name.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fe640b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag attribute</string>
<key>scope</key>
<string>entity.other.attribute-name</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8839ef</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag delimiter</string>
<key>scope</key>
<string>punctuation.definition.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e64553</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown URL</string>
<key>scope</key>
<string>markup.underline.link.markdown</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dc8a78</string>
<key>fontStyle</key>
<string>italic underline</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown reference</string>
<key>scope</key>
<string>meta.link.inline.description</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7287fd</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown literal</string>
<key>scope</key>
<string>comment.block.markdown, meta.code-fence, markup.raw.code-fence, markup.raw.inline</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown title</string>
<key>scope</key>
<string>punctuation.definition.heading, entity.name.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#1e66f5</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown emphasis</string>
<key>scope</key>
<string>markup.italic</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e64553</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown strong</string>
<key>scope</key>
<string>markup.bold</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#e64553</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Escape</string>
<key>scope</key>
<string>constant.character.escape</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea76cb</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash built-in function</string>
<key>scope</key>
<string>source.shell.bash meta.function.shell meta.compound.shell meta.function-call.identifier.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ea76cb</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash parameter</string>
<key>scope</key>
<string>variable.language.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua field</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.value.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7287fd</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua constructor</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dd7878</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Java constant</string>
<key>scope</key>
<string>entity.name.constant.java</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS property</string>
<key>scope</key>
<string>support.type.property-name.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#dd7878</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS constant</string>
<key>scope</key>
<string>support.constant.property-value.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#4c4f69</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS suffix</string>
<key>scope</key>
<string>constant.numeric.suffix.css, keyword.other.unit.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS variable property</string>
<key>scope</key>
<string>variable.other.custom-property.name.css, support.type.custom-property.name.css, punctuation.definition.custom-property.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SCSS tag</string>
<key>scope</key>
<string>entity.name.tag.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#7287fd</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SASS variable</string>
<key>scope</key>
<string>variable.other.sass</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#179299</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid</string>
<key>scope</key>
<string>invalid</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#4c4f69</string>
<key>background</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid deprecated</string>
<key>scope</key>
<string>invalid.deprecated</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#4c4f69</string>
<key>background</key>
<string>#8839ef</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff header</string>
<key>scope</key>
<string>meta.diff, meta.diff.header</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#9ca0b0</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff deleted</string>
<key>scope</key>
<string>markup.deleted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff inserted</string>
<key>scope</key>
<string>markup.inserted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#40a02b</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff changed</string>
<key>scope</key>
<string>markup.changed</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#df8e1d</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Message error</string>
<key>scope</key>
<string>message.error</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#d20f39</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
</array>
<key>uuid</key>
<string>4d0379b5-ef82-467b-b8b8-365889420646</string>
<key>colorSpaceName</key>
<string>sRGB</string>
<key>semanticClass</key>
<string>theme.dark.Catppuccin</string>
<key>author</key>
<string>BrunDerSchwarzmagier</string>
</dict>
</plist>

View File

@@ -1,959 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>name</key>
<string>Catppuccin</string>
<key>settings</key>
<array>
<dict>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cad3f5</string>
<key>background</key>
<string>#24273a</string>
<key>caret</key>
<string>#b8c0e0</string>
<key>invisibles</key>
<string>#a5adcb</string>
<key>gutterForeground</key>
<string>#939ab7</string>
<key>gutterForegroundHighlight</key>
<string>#a6da95</string>
<key>lineHighlight</key>
<string>#5b6078</string>
<key>selection</key>
<string>#6e738d</string>
<key>selectionBorder</key>
<string>#24273a</string>
<key>activeGuide</key>
<string>#f5a97f</string>
<key>findHighlightForeground</key>
<string>#1e2030</string>
<key>findHighlight</key>
<string>#eed49f</string>
<key>bracketsForeground</key>
<string>#939ab7</string>
<key>bracketContentsForeground</key>
<string>#939ab7</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Comment</string>
<key>scope</key>
<string>comment</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#6e738d</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String</string>
<key>scope</key>
<string>string</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6da95</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String regex</string>
<key>scope</key>
<string>string.regexp</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Number</string>
<key>scope</key>
<string>constant.numeric</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Boolean</string>
<key>scope</key>
<string>constant.language.boolean</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string>bold italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in constant</string>
<key>scope</key>
<string>constant.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b7bdf8</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in function</string>
<key>scope</key>
<string>support.function.builtin</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>User-defined constant</string>
<key>scope</key>
<string>variable.other.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable</string>
<key>scope</key>
<string>variable</string>
<key>settings</key>
<dict></dict>
</dict>
<dict>
<key>name</key>
<string>Keyword</string>
<key>scope</key>
<string>keyword</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Conditional/loop</string>
<key>scope</key>
<string>keyword.control.loop, keyword.control.conditional, keyword.control.c++</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6a0f6</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Return</string>
<key>scope</key>
<string>keyword.control.return, keyword.control.flow.return</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5bde6</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Exception</string>
<key>scope</key>
<string>support.type.exception</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Operator</string>
<key>scope</key>
<string>keyword.operator, punctuation.accessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#91d7e3</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation separator</string>
<key>scope</key>
<string>punctuation.separator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation terminator</string>
<key>scope</key>
<string>punctuation.terminator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation bracket</string>
<key>scope</key>
<string>punctuation.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#939ab7</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Include</string>
<key>scope</key>
<string>keyword.control.import.include</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage</string>
<key>scope</key>
<string>storage</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type</string>
<key>scope</key>
<string>storage.type</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eed49f</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage modifier</string>
<key>scope</key>
<string>storage.modifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type namespace</string>
<key>scope</key>
<string>entity.name.namespace, meta.path</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type class</string>
<key>scope</key>
<string>storage.type.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Label</string>
<key>scope</key>
<string>entity.name.label</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Keyword class</string>
<key>scope</key>
<string>keyword.declaration.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Class name</string>
<key>scope</key>
<string>entity.name.class, meta.toc-list.full-identifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#91d7e3</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Inherited class</string>
<key>scope</key>
<string>entity.other.inherited-class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#91d7e3</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function name</string>
<key>scope</key>
<string>entity.name.function, variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function macro</string>
<key>scope</key>
<string>entity.name.function.preprocessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Macro directive - ifdef</string>
<key>scope</key>
<string>keyword.control.import</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Constructor</string>
<key>scope</key>
<string>entity.name.function.constructor, entity.name.function.destructor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b7bdf8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function argument</string>
<key>scope</key>
<string>variable.parameter.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function declaration</string>
<key>scope</key>
<string>keyword.declaration.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ee99a0</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library function</string>
<key>scope</key>
<string>support.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#91d7e3</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library constant</string>
<key>scope</key>
<string>support.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library class/type</string>
<key>scope</key>
<string>support.type, support.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library variable</string>
<key>scope</key>
<string>support.other.variable</string>
<key>settings</key>
<dict>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable function</string>
<key>scope</key>
<string>variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable parameter</string>
<key>scope</key>
<string>variable.parameter</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable other</string>
<key>scope</key>
<string>variable.other</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cad3f5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable field</string>
<key>scope</key>
<string>variable.other.member</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable language</string>
<key>scope</key>
<string>variable.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag name</string>
<key>scope</key>
<string>entity.name.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5a97f</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag attribute</string>
<key>scope</key>
<string>entity.other.attribute-name</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#c6a0f6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag delimiter</string>
<key>scope</key>
<string>punctuation.definition.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ee99a0</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown URL</string>
<key>scope</key>
<string>markup.underline.link.markdown</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f4dbd6</string>
<key>fontStyle</key>
<string>italic underline</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown reference</string>
<key>scope</key>
<string>meta.link.inline.description</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b7bdf8</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown literal</string>
<key>scope</key>
<string>comment.block.markdown, meta.code-fence, markup.raw.code-fence, markup.raw.inline</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown title</string>
<key>scope</key>
<string>punctuation.definition.heading, entity.name.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8aadf4</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown emphasis</string>
<key>scope</key>
<string>markup.italic</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ee99a0</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown strong</string>
<key>scope</key>
<string>markup.bold</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ee99a0</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Escape</string>
<key>scope</key>
<string>constant.character.escape</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5bde6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash built-in function</string>
<key>scope</key>
<string>source.shell.bash meta.function.shell meta.compound.shell meta.function-call.identifier.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5bde6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash parameter</string>
<key>scope</key>
<string>variable.language.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua field</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.value.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b7bdf8</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua constructor</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f0c6c6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Java constant</string>
<key>scope</key>
<string>entity.name.constant.java</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS property</string>
<key>scope</key>
<string>support.type.property-name.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f0c6c6</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS constant</string>
<key>scope</key>
<string>support.constant.property-value.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cad3f5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS suffix</string>
<key>scope</key>
<string>constant.numeric.suffix.css, keyword.other.unit.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS variable property</string>
<key>scope</key>
<string>variable.other.custom-property.name.css, support.type.custom-property.name.css, punctuation.definition.custom-property.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SCSS tag</string>
<key>scope</key>
<string>entity.name.tag.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b7bdf8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SASS variable</string>
<key>scope</key>
<string>variable.other.sass</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#8bd5ca</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid</string>
<key>scope</key>
<string>invalid</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cad3f5</string>
<key>background</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid deprecated</string>
<key>scope</key>
<string>invalid.deprecated</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cad3f5</string>
<key>background</key>
<string>#c6a0f6</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff header</string>
<key>scope</key>
<string>meta.diff, meta.diff.header</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#6e738d</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff deleted</string>
<key>scope</key>
<string>markup.deleted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff inserted</string>
<key>scope</key>
<string>markup.inserted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6da95</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff changed</string>
<key>scope</key>
<string>markup.changed</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eed49f</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Message error</string>
<key>scope</key>
<string>message.error</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#ed8796</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
</array>
<key>uuid</key>
<string>4d0379b5-ef82-467b-b8b8-365889420646</string>
<key>colorSpaceName</key>
<string>sRGB</string>
<key>semanticClass</key>
<string>theme.dark.Catppuccin</string>
<key>author</key>
<string>BrunDerSchwarzmagier</string>
</dict>
</plist>

View File

@@ -1,959 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>name</key>
<string>Catppuccin</string>
<key>settings</key>
<array>
<dict>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cdd6f4</string>
<key>background</key>
<string>#1e1e2e</string>
<key>caret</key>
<string>#bac2de</string>
<key>invisibles</key>
<string>#a6adc8</string>
<key>gutterForeground</key>
<string>#9399b2</string>
<key>gutterForegroundHighlight</key>
<string>#a6e3a1</string>
<key>lineHighlight</key>
<string>#585b70</string>
<key>selection</key>
<string>#6c7086</string>
<key>selectionBorder</key>
<string>#1e1e2e</string>
<key>activeGuide</key>
<string>#fab387</string>
<key>findHighlightForeground</key>
<string>#181825</string>
<key>findHighlight</key>
<string>#f9e2af</string>
<key>bracketsForeground</key>
<string>#9399b2</string>
<key>bracketContentsForeground</key>
<string>#9399b2</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Comment</string>
<key>scope</key>
<string>comment</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#6c7086</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String</string>
<key>scope</key>
<string>string</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6e3a1</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>String regex</string>
<key>scope</key>
<string>string.regexp</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Number</string>
<key>scope</key>
<string>constant.numeric</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Boolean</string>
<key>scope</key>
<string>constant.language.boolean</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string>bold italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in constant</string>
<key>scope</key>
<string>constant.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b4befe</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Built-in function</string>
<key>scope</key>
<string>support.function.builtin</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>User-defined constant</string>
<key>scope</key>
<string>variable.other.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable</string>
<key>scope</key>
<string>variable</string>
<key>settings</key>
<dict></dict>
</dict>
<dict>
<key>name</key>
<string>Keyword</string>
<key>scope</key>
<string>keyword</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Conditional/loop</string>
<key>scope</key>
<string>keyword.control.loop, keyword.control.conditional, keyword.control.c++</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cba6f7</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Return</string>
<key>scope</key>
<string>keyword.control.return, keyword.control.flow.return</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5c2e7</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Exception</string>
<key>scope</key>
<string>support.type.exception</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Operator</string>
<key>scope</key>
<string>keyword.operator, punctuation.accessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89dceb</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation separator</string>
<key>scope</key>
<string>punctuation.separator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation terminator</string>
<key>scope</key>
<string>punctuation.terminator</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Punctuation bracket</string>
<key>scope</key>
<string>punctuation.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#9399b2</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Include</string>
<key>scope</key>
<string>keyword.control.import.include</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage</string>
<key>scope</key>
<string>storage</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type</string>
<key>scope</key>
<string>storage.type</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f9e2af</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage modifier</string>
<key>scope</key>
<string>storage.modifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type namespace</string>
<key>scope</key>
<string>entity.name.namespace, meta.path</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Storage type class</string>
<key>scope</key>
<string>storage.type.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Label</string>
<key>scope</key>
<string>entity.name.label</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Keyword class</string>
<key>scope</key>
<string>keyword.declaration.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Class name</string>
<key>scope</key>
<string>entity.name.class, meta.toc-list.full-identifier</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89dceb</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Inherited class</string>
<key>scope</key>
<string>entity.other.inherited-class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89dceb</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function name</string>
<key>scope</key>
<string>entity.name.function, variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function macro</string>
<key>scope</key>
<string>entity.name.function.preprocessor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Macro directive - ifdef</string>
<key>scope</key>
<string>keyword.control.import</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Constructor</string>
<key>scope</key>
<string>entity.name.function.constructor, entity.name.function.destructor</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b4befe</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function argument</string>
<key>scope</key>
<string>variable.parameter.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Function declaration</string>
<key>scope</key>
<string>keyword.declaration.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eba0ac</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library function</string>
<key>scope</key>
<string>support.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89dceb</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library constant</string>
<key>scope</key>
<string>support.constant</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library class/type</string>
<key>scope</key>
<string>support.type, support.class</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Library variable</string>
<key>scope</key>
<string>support.other.variable</string>
<key>settings</key>
<dict>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable function</string>
<key>scope</key>
<string>variable.function</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable parameter</string>
<key>scope</key>
<string>variable.parameter</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable other</string>
<key>scope</key>
<string>variable.other</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cdd6f4</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable field</string>
<key>scope</key>
<string>variable.other.member</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Variable language</string>
<key>scope</key>
<string>variable.language</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag name</string>
<key>scope</key>
<string>entity.name.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#fab387</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag attribute</string>
<key>scope</key>
<string>entity.other.attribute-name</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cba6f7</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Tag delimiter</string>
<key>scope</key>
<string>punctuation.definition.tag</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eba0ac</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown URL</string>
<key>scope</key>
<string>markup.underline.link.markdown</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5e0dc</string>
<key>fontStyle</key>
<string>italic underline</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown reference</string>
<key>scope</key>
<string>meta.link.inline.description</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b4befe</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown literal</string>
<key>scope</key>
<string>comment.block.markdown, meta.code-fence, markup.raw.code-fence, markup.raw.inline</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown title</string>
<key>scope</key>
<string>punctuation.definition.heading, entity.name.section</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#89b4fa</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown emphasis</string>
<key>scope</key>
<string>markup.italic</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eba0ac</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Markdown strong</string>
<key>scope</key>
<string>markup.bold</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#eba0ac</string>
<key>fontStyle</key>
<string>bold</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Escape</string>
<key>scope</key>
<string>constant.character.escape</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5c2e7</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash built-in function</string>
<key>scope</key>
<string>source.shell.bash meta.function.shell meta.compound.shell meta.function-call.identifier.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f5c2e7</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Bash parameter</string>
<key>scope</key>
<string>variable.language.shell</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua field</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.value.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b4befe</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Lua constructor</string>
<key>scope</key>
<string>source.lua meta.function.lua meta.block.lua meta.mapping.key.lua string.unquoted.key.lua</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2cdcd</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Java constant</string>
<key>scope</key>
<string>entity.name.constant.java</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS property</string>
<key>scope</key>
<string>support.type.property-name.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f2cdcd</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS constant</string>
<key>scope</key>
<string>support.constant.property-value.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cdd6f4</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS suffix</string>
<key>scope</key>
<string>constant.numeric.suffix.css, keyword.other.unit.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string>italic</string>
</dict>
</dict>
<dict>
<key>name</key>
<string>CSS variable property</string>
<key>scope</key>
<string>variable.other.custom-property.name.css, support.type.custom-property.name.css, punctuation.definition.custom-property.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SCSS tag</string>
<key>scope</key>
<string>entity.name.tag.css</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#b4befe</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>SASS variable</string>
<key>scope</key>
<string>variable.other.sass</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#94e2d5</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid</string>
<key>scope</key>
<string>invalid</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cdd6f4</string>
<key>background</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Invalid deprecated</string>
<key>scope</key>
<string>invalid.deprecated</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#cdd6f4</string>
<key>background</key>
<string>#cba6f7</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff header</string>
<key>scope</key>
<string>meta.diff, meta.diff.header</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#6c7086</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff deleted</string>
<key>scope</key>
<string>markup.deleted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff inserted</string>
<key>scope</key>
<string>markup.inserted</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#a6e3a1</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Diff changed</string>
<key>scope</key>
<string>markup.changed</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f9e2af</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
<dict>
<key>name</key>
<string>Message error</string>
<key>scope</key>
<string>message.error</string>
<key>settings</key>
<dict>
<key>foreground</key>
<string>#f38ba8</string>
<key>fontStyle</key>
<string></string>
</dict>
</dict>
</array>
<key>uuid</key>
<string>4d0379b5-ef82-467b-b8b8-365889420646</string>
<key>colorSpaceName</key>
<string>sRGB</string>
<key>semanticClass</key>
<string>theme.dark.Catppuccin</string>
<key>author</key>
<string>BrunDerSchwarzmagier</string>
</dict>
</plist>

View File

@@ -0,0 +1,158 @@
{
"$schema": "https://charm.land/crush.json",
"lsp": {
"typescript": {
"command": "typescript-language-server",
"args": [
"--stdio"
]
},
"javascript": {
"command": "typescript-language-server",
"args": [
"--stdio"
]
},
"rust": {
"command": "rust-analyzer"
},
"nix": {
"command": "nil"
}
},
"mcp": {
"context7": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@upstash/context7-mcp"
]
},
"playwright": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@playwright/mcp"
]
},
"shadcn": {
"type": "stdio",
"command": "npx",
"args": [
"@heilgar/shadcn-ui-mcp-server"
]
},
"searxng": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"mcp-searxng"
],
"env": {
"SEARXNG_URL": "http://127.0.0.1:7777"
}
},
"git": {
"type": "stdio",
"command": "uvx",
"args": [
"--python",
"/run/current-system/sw/bin/python",
"mcp-server-git"
]
},
"docker": {
"type": "stdio",
"command": "uvx",
"args": [
"--python",
"/run/current-system/sw/bin/python",
"docker-mcp"
]
},
"time": {
"type": "stdio",
"command": "uvx",
"args": [
"--python",
"/run/current-system/sw/bin/python",
"mcp-server-time"
]
},
"sequential-thinking": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sequential-thinking"
]
},
"nixos": {
"type": "stdio",
"command": "uvx",
"args": [
"--python",
"/run/current-system/sw/bin/python",
"mcp-nixos"
]
},
"k8s": {
"type": "stdio",
"command": "npx",
"args": [
"@strowk/mcp-k8s"
]
},
"filesystem": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/home/xnm"
]
},
"n8n": {
"type": "stdio",
"command": "npx",
"args": [
"n8n-mcp"
],
"env": {
"MCP_MODE": "stdio",
"LOG_LEVEL": "error",
"DISABLE_CONSOLE_OUTPUT": "true",
"N8N_API_URL": "http://localhost:5678",
"N8N_API_KEY": "your-api-key"
}
},
"coolify": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@masonator/coolify-mcp"
],
"env": {
"COOLIFY_ACCESS_TOKEN": "0|your-secret-token",
"COOLIFY_BASE_URL": "http://localhost:8000"
}
},
"appwrite": {
"type": "stdio",
"command": "uvx",
"args": [
"mcp-server-appwrite",
"--all"
],
"env": {
"APPWRITE_PROJECT_ID": "your-project-id",
"APPWRITE_API_KEY": "your-api-key",
"APPWRITE_ENDPOINT": "http://localhost:8088/v1"
}
}
}
}

View File

@@ -3,6 +3,20 @@ if status is-interactive
end end
alias cl="clear" alias cl="clear"
alias rad="rad-tui"
alias ai="aichat"
alias ai-commit="git diff --staged | ai -r commit-message | hx"
alias ai-emoji-commit="git diff --staged | ai -r emoji-commit-message | hx"
alias ai-branch="git diff --staged | ai -r git-branch | hx"
alias ai-spell="vipe | ai -r improve-writing | hx"
alias ai-email="vipe | ai -r email-answer | hx"
alias ai-linkedin="vipe | ai -r linkedin-answer | hx"
alias aic="ai-commit"
alias aiec="ai-emoji-commit"
alias aib="ai-branch"
alias ais="ai-spell"
alias aie="ai-email"
alias ail="ai-linkedin"
alias lgit="lazygit" alias lgit="lazygit"
alias ldocker="lazydocker" alias ldocker="lazydocker"
alias conf="z ~/.config" alias conf="z ~/.config"
@@ -25,6 +39,7 @@ set -gx VOLUME_STEP 5
set -gx BRIGHTNESS_STEP 5 set -gx BRIGHTNESS_STEP 5
set -gx PATH $HOME/.cargo/bin $PATH set -gx PATH $HOME/.cargo/bin $PATH
set -gx PATH $HOME/.npm-packages/bin $PATH
set fish_vi_force_cursor set fish_vi_force_cursor
set fish_cursor_default block set fish_cursor_default block

View File

@@ -1,5 +1,5 @@
function check_night_mode function check_night_mode
set target_process wlsunset set target_process hyprsunset
if pgrep $target_process >/dev/null if pgrep $target_process >/dev/null
echo "{ \"text\":\"󱩌\", \"tooltip\": \"night-mode <span color='#a6da95'>on</span>\", \"class\": \"on\" }" echo "{ \"text\":\"󱩌\", \"tooltip\": \"night-mode <span color='#a6da95'>on</span>\", \"class\": \"on\" }"

View File

@@ -2,6 +2,6 @@ function clipboard_to_wlcopy
set clip $(cliphist list | rofi -dmenu -p 'clipboard copy') set clip $(cliphist list | rofi -dmenu -p 'clipboard copy')
if not [ -z $clip ] if not [ -z $clip ]
echo $clip | cliphist decode | wl-copy echo $clip | cliphist decode | wl-copy
dunstify "Clipboard" "Clip '$clip' was copied" -t 2000 dunstify Clipboard "Clip '$clip' was copied" -t 2000
end end
end end

View File

@@ -0,0 +1,28 @@
function fish_bind_count
argparse 'h/help' 'z/zero' 'r/read' -- $argv
or return 1
if test -n "$_flag_help"
echo "Helper function to track count modifier with modal key bindings"
echo "Usage: $0 [-h] [-z] [DIGITS ...]"
return
end
if test -n "$_flag_zero" || not string match -rq '[1-9]\d*' "$fish_bind_count"
set -g fish_bind_count 0
end
# Iterate over given digits
for arg in $argv
for digit in (string split '' "$arg")
set -g fish_bind_count $(math "$fish_bind_count" \* 10 \+ "$digit")
end
end
if test -n "$_flag_read"
set -l count "$fish_bind_count"
set -g fish_bind_count 0
if test "$count" = 0
echo 1
return 1
else
echo "$count"
end
end
end

View File

@@ -0,0 +1,26 @@
function fish_default_mode_prompt --description "Display vi/helix prompt mode"
# Do nothing if not in vi mode
if test "$fish_key_bindings" = fish_vi_key_bindings
or test "$fish_key_bindings" = fish_helix_key_bindings
or test "$fish_key_bindings" = fish_hybrid_key_bindings
switch $fish_bind_mode
case default
set_color --bold red
echo '[N]'
case insert
set_color --bold green
echo '[I]'
case replace_one
set_color --bold green
echo '[R]'
case replace
set_color --bold cyan
echo '[R]'
case visual
set_color --bold magenta
echo '[V]'
end
set_color normal
echo -n ' '
end
end

View File

@@ -0,0 +1,433 @@
# FIXME this can't be called in sequence in general case,
# because of unsynchronized `commandline -f` and `commandline -C`
function fish_helix_command
argparse h/help -- $argv
or return 1
if test -n "$_flag_help"
echo "Helper function to handle modal key bindings mostly outside of insert mode"
return
end
# TODO only single command allowed really yet,
# because `commandline -f` queues actions, while `commandline -C` is immediate
for command in $argv
set -f count (fish_bind_count -r)
set -f count_defined $status
switch $command
case {move,extend}_char_left
commandline -C (math max\(0, (commandline -C) - $count\))
__fish_helix_extend_by_command $command
case {move,extend}_char_right
commandline -C (math (commandline -C) + $count)
__fish_helix_extend_by_command $command
case char_up
__fish_helix_char_up $fish_bind_mode $count
case char_down
__fish_helix_char_down $fish_bind_mode $count
case next_word_start
# https://regex101.com/r/KXrl1x/1
set -l regex (string join '' \
'(?:.?\\n+|' \
'[[:alnum:]_](?=[^[:alnum:]_\\s])|' \
'[^[:alnum:]_\\s](?=[[:alnum:]_])|' \
'[^\\S\\n](?=[\\S\\n])|)' \
'((?:[[:alnum:]_]+|[^[:alnum:]_\\s]+|)[^\\S\\n]*)' \
)
__fish_helix_next_word $fish_bind_mode $count $regex
case next_long_word_start
set -l regex (string join '' \
'(?:.?\\n+|' \
'[^\\S\\n](?=[\\S\\n])|)' \
'(\\S*[^\\S\\n]*)' \
)
__fish_helix_next_word $fish_bind_mode $count $regex
case next_word_end
# https://regex101.com/r/Gl0KP2/1
set -l regex ' (?:
.?\\n+ |
[[:alnum:]_](?=[^[:alnum:]_]) |
[^[:alnum:]_\\s](?=[[:alnum:]_\\s]) | )
( [^\\S\\n]*
(?: [[:alnum:]_]+ | [^[:alnum:]_\\s]+ | ) ) '
__fish_helix_next_word $fish_bind_mode $count $regex
case next_long_word_end
set -l regex ' (?: .?\\n+ | \\S(?=\\s) | )
( [^\\S\\n]* \\S* ) '
__fish_helix_next_word $fish_bind_mode $count $regex
case prev_word_start
set -l regex ' ( (?:
[[:alnum:]_]+ |
[^[:alnum:]_\\s]+ | )
[^\\S\\n]* )
(?: \\n+.? |
(?<=[^[:alnum:]_])[[:alnum:]_] |
(?<=[[:alnum:]_\\s])[^[:alnum:]_\\s] | ) '
__fish_helix_prev_word $fish_bind_mode $count $regex
case prev_long_word_start
set -l regex '
( \\S* [^\\S\\n]* )
(?: \\n+.? | (?<=\\s)\\S | ) '
__fish_helix_prev_word $fish_bind_mode $count $regex
case till_next_char
__fish_helix_find_char $fish_bind_mode $count forward-jump-till forward-char
case find_next_char
__fish_helix_find_char $fish_bind_mode $count forward-jump
case till_prev_char
__fish_helix_find_char $fish_bind_mode $count backward-jump-till backward-char
case find_prev_char
__fish_helix_find_char $fish_bind_mode $count backward-jump
case till_next_cr
__fish_helix_find_next_cr $fish_bind_mode $count 2
case find_next_cr
__fish_helix_find_next_cr $fish_bind_mode $count 1
case till_prev_cr
__fish_helix_find_prev_cr $fish_bind_mode $count 1
case find_prev_cr
__fish_helix_find_prev_cr $fish_bind_mode $count 0
case goto_line_start
commandline -f beginning-of-line
__fish_helix_extend_by_mode
case goto_line_end
__fish_helix_goto_line_end
__fish_helix_extend_by_mode
case goto_first_nonwhitespace
__fish_helix_goto_first_nonwhitespace
__fish_helix_extend_by_mode
case goto_file_start
__fish_helix_goto_line $count
case goto_line
if test "$count_defined" = 0 # if true
__fish_helix_goto_line $count
end
case goto_last_line
commandline -f end-of-buffer beginning-of-line
__fish_helix_extend_by_mode
case insert_mode
set fish_bind_mode insert
commandline -f end-selection repaint-mode
case append_mode
commandline -C (commandline -E)
set fish_bind_mode insert
commandline -f end-selection repaint-mode
case prepend_to_line
__fish_helix_goto_first_nonwhitespace
set fish_bind_mode insert
commandline -f end-selection repaint-mode
case append_to_line
set fish_bind_mode insert
commandline -f end-selection end-of-line repaint-mode
case delete_selection
commandline -f kill-selection begin-selection
case delete_selection_noyank
__fish_helix_delete_selection
case yank
__fish_helix_yank
case paste_before
__fish_helix_paste_before "commandline -f yank"
case paste_after
__fish_helix_paste_after "commandline -f yank"
case replace_selection
__fish_helix_replace_selection "$fish_killring[1]" true
case paste_before_clip
__fish_helix_paste_before fish_clipboard_paste
case paste_after_clip
__fish_helix_paste_after fish_clipboard_paste --clip
case replace_selection_clip
__fish_helix_replace_selection "" fish_clipboard_paste --clip
case select_all
commandline -f beginning-of-buffer begin-selection end-of-buffer end-of-line backward-char
case select_line
commandline -f beginning-of-line begin-selection end-of-line
case '*'
echo "[fish-helix]" Unknown command $command >&2
end
end
end
function __fish_helix_extend_by_command -a piece
if not string match -qr extend_ $piece
commandline -f begin-selection
end
end
function __fish_helix_extend_by_mode
if test $fish_bind_mode = default
commandline -f begin-selection
end
end
function __fish_helix_find_char -a mode count fish_cmdline till
# FIXME don't reset selection if N/A
if test $mode = default
commandline -f begin-selection
end
commandline -f $till $fish_cmdline
for i in (seq 2 $count)
commandline -f $till repeat-jump
end
end
function __fish_helix_find_next_cr -a mode count skip
set -l cursor (commandline -C)
commandline | # Include endling newline intentionally
# Skip until cursor:
sed -z 's/^.\{'(math $cursor + $skip)'\}\(.*\)$/\\1/' |
# Count characters up to the target newline:
sed -z 's/^\(\([^\\n]*\\n\)\{0,'$count'\}\).*/\\1/' |
read -zl chars
if test $mode = default -a -n "$chars"
commandline -f begin-selection
end
for i in (seq 1 (string length -- "$chars"))
commandline -f forward-char
end
end
function __fish_helix_find_prev_cr -a mode count skip
set -l cursor (commandline -C)
commandline --cut-at-cursor |
sed -z 's/.\{'$skip'\}\n$//' |
read -zl buffer
echo -n $buffer |
# Drop characters up to the target newline:
sed -z 's/\(\(\\n[^\\n]*\)\{0,'$count'\}\)$//' |
read -zl chars
set -l n_chars (math (string length -- "$buffer") - (string length -- "$chars"))
if test $mode = default -a $n_chars != 0
commandline -f begin-selection
end
for i in (seq 1 $n_chars)
commandline -f backward-char
end
end
function __fish_helix_goto_line_end
# check if we are on an empty line first
commandline | sed -n (commandline -L)'!b;/^$/q;q5' && return
commandline -f end-of-line backward-char
end
function __fish_helix_goto_first_nonwhitespace
# check if we are on whitespace line first
commandline | sed -n (commandline -L)'!b;/^\\s*$/q;q5' && return
commandline -f beginning-of-line forward-bigword backward-bigword
end
function __fish_helix_goto_line -a number
set -l lines (math min\($number, (commandline | wc -l)\))
commandline -f beginning-of-buffer
for i in (seq 2 $lines)
commandline -f down-line
end
__fish_helix_extend_by_mode
end
function __fish_helix_char_up -a mode count
if commandline --paging-mode && not commandline --search-mode
for i in (seq 1 $count)
commandline -f up-line
end
return
end
set -l line (commandline -L)
if commandline --search-mode || test $line = 1
for i in (seq 1 (math min \($count, (count $history)\)))
commandline -f history-search-backward
end
return
end
set -l count (math min\($count, $line-1\))
for i in (seq 1 $count)
commandline -f up-line
end
__fish_helix_extend_by_mode
end
function __fish_helix_char_down -a mode count
if commandline --paging-mode && not commandline --search-mode
for i in (seq 1 $count)
commandline -f down-line
end
return
end
set -l line (commandline -L)
set -l total (count (commandline))
if commandline --search-mode || test $line = $total
for i in (seq 1 (math min \($count, (count $history)\)))
commandline -f history-search-forward
end
return
end
set -l count (math min\($count, $total - $line\))
for i in (seq 1 $count)
commandline -f down-line
end
__fish_helix_extend_by_mode
end
function __fish_helix_next_word -a mode count regex
set -f cursor (commandline -C)
commandline |
perl -e '
use open qw(:std :utf8);
do { local $/; substr <>, '$cursor' } =~ m/(?:'$regex'){0,'$count'}/ux;
print $-[1], " ", $+[1];' |
read -f left right
test "$left" = "$right" && return
if test $mode = default
commandline -C (math $cursor + $left)
commandline -f begin-selection
for i in (seq $left (math $right - 2))
commandline -f forward-char
end
else
commandline -C (math $cursor + $right - 1)
end
end
function __fish_helix_prev_word -a mode count regex
set -f left (math (commandline -C) + 1)
set -f updated 0
for i in (seq 1 $count)
commandline |
perl -e '
use open qw(:std :utf8);
do { local $/; substr <>, 0, '$left' } =~ /(?:'$regex')$/ux;
print $-[1], " ", $+[1];' |
read -l l r
test "$l" = "$r" -o "$l" = 0 -a "$r" = 1 && break
set -f left $l
set -f right $r
set -f updated 1
end
test $updated -eq 0; and return
if test $mode = default
commandline -C (math $right - 1)
commandline -f begin-selection
for i in (seq $left (math $right - 2))
commandline -f backward-char
end
else
commandline -C (math $left)
end
end
function __fish_helix_delete_selection
set start (commandline -B)
set end (commandline -E)
commandline |
sed -zE 's/^(.{'$start'})(.{0,'(math $end - $start)'})(.*)\\n$/\\1\\3/' |
read -l result
commandline "$result"
commandline -C $start
commandline -f begin-selection
end
function __fish_helix_yank
set -l end (commandline -E)
set -l cursor (commandline -C)
commandline -f kill-selection yank backward-char
for i in (seq $cursor (math $end - 2))
commandline -f backward-char
end
end
function __fish_helix_paste_before -a cmd_paste
set -l cmd_paste $(string split " " $cmd_paste)
set -l cursor (commandline -C)
set -l start (commandline -B)
set -l end (commandline -E)
commandline -C $start
$cmd_paste
commandline -f begin-selection
for i in (seq $start (math $end - 2))
commandline -f forward-char
end
if test $cursor = $start
commandline -f swap-selection-start-stop
end
end
function __fish_helix_paste_after -a cmd_paste
set -l cmd_paste $(string split " " $cmd_paste)
set -l cursor (commandline -C)
set -l start (commandline -B)
set -l end (commandline -E)
commandline -C $end
$cmd_paste
if test "$argv[2]" = --clip
commandline -C (math $end - 1)
else
for i in (seq 0 (string length "$fish_killring[1]"))
commandline -f backward-char
end
end
commandline -f begin-selection
for i in (seq $start (math $end - 2))
commandline -f backward-char
end
if test $cursor != $start
commandline -f swap-selection-start-stop
end
end
function __fish_helix_replace_selection -a replacement cmd_paste
set -l cmd_paste $(string split " " $cmd_paste)
set cursor (commandline -C)
set start (commandline -B)
set end (commandline -E)
commandline |
sed -zE 's/^(.{'$start'})(.{0,'(math $end - $start)'})(.*)\\n$/\\1'"$(string escape --style=regex "$replacement")"'\\3/' |
read -l result
commandline "$result"
commandline -C $start
$cmd_paste
if test "$argv[3]" = --clip
commandline -f backward-char begin-selection
for i in (seq (math $start + 2) (commandline -C))
commandline -f backward-char
end
if test $cursor != $start
commandline -f swap-selection-start-stop
end
else
commandline -f begin-selection
for i in (seq 2 (string length "$replacement"))
commandline -f forward-char
end
if test $cursor = $start
commandline -f swap-selection-start-stop
end
end
end

View File

@@ -0,0 +1,291 @@
# IMPORTANT!!!
#
# When defining your own bindings using fish_helix_command, be aware that it can break
# stuff sometimes.
#
# It is safe to define a binding consisting of a lone call to fish_helix_command.
# Calls to other functions and executables are allowed along with it, granted they don't mess
# with fish's commandline buffer.
#
# Mixing multiple fish_helix_commandline and commandline calls in one binding MAY trigger issues.
# Nothing serious, but don't be surprised. Just test it.
function fish_helix_key_bindings --description 'helix-like key bindings for fish'
if contains -- -h $argv
or contains -- --help $argv
echo "Sorry but this function doesn't support -h or --help"
return 1
end
# Erase all bindings if not explicitly requested otherwise to
# allow for hybrid bindings.
# This needs to be checked here because if we are called again
# via the variable handler the argument will be gone.
set -l rebind true
if test "$argv[1]" = --no-erase
set rebind false
set -e argv[1]
else
bind --erase --all --preset # clear earlier bindings, if any
end
# Allow just calling this function to correctly set the bindings.
# Because it's a rather discoverable name, users will execute it
# and without this would then have subtly broken bindings.
if test "$fish_key_bindings" != fish_helix_key_bindings
and test "$rebind" = true
# Allow the user to set the variable universally.
set -q fish_key_bindings
or set -g fish_key_bindings
# This triggers the handler, which calls us again and ensures the user_key_bindings
# are executed.
set fish_key_bindings fish_helix_key_bindings
return
end
set -l init_mode insert
if contains -- $argv[1] insert default visual
set init_mode $argv[1]
else if set -q argv[1]
# We should still go on so the bindings still get set.
echo "Unknown argument $argv" >&2
end
# Inherit shared key bindings.
# Do this first so helix-bindings win over default.
for mode in insert default visual
__fish_shared_key_bindings -s -M $mode
end
bind -s --preset -M insert \r execute
bind -s --preset -M insert \n execute
bind -s --preset -M insert "" self-insert
# Space and other command terminators expand abbrs _and_ inserts itself.
bind -s --preset -M insert " " self-insert expand-abbr
bind -s --preset -M insert ";" self-insert expand-abbr
bind -s --preset -M insert "|" self-insert expand-abbr
bind -s --preset -M insert "&" self-insert expand-abbr
bind -s --preset -M insert "^" self-insert expand-abbr
bind -s --preset -M insert ">" self-insert expand-abbr
bind -s --preset -M insert "<" self-insert expand-abbr
# Closing a command substitution expands abbreviations
bind -s --preset -M insert ")" self-insert expand-abbr
# Ctrl-space inserts space without expanding abbrs
bind -s --preset -M insert -k nul 'commandline -i " "'
# Switching to insert mode
for mode in default visual
bind -s --preset -M $mode -m insert \cc end-selection cancel-commandline repaint-mode
bind -s --preset -M $mode -m insert \n end-selection execute
bind -s --preset -M $mode -m insert \r end-selection execute
bind -s --preset -M $mode -m insert o end-selection insert-line-under repaint-mode
bind -s --preset -M $mode -m insert O end-selection insert-line-over repaint-mode
# FIXME i/a should keep selection, maybe
bind -s --preset -M $mode i "fish_helix_command insert_mode"
bind -s --preset -M $mode I "fish_helix_command prepend_to_line"
bind -s --preset -M $mode a "fish_helix_command append_mode"
bind -s --preset -M $mode A "fish_helix_command append_to_line"
end
# Switching from insert mode
# Note if we are paging, we want to stay in insert mode
# See #2871
bind -s --preset -M insert \e "if commandline -P; commandline -f cancel; else; set fish_bind_mode default; commandline -f begin-selection repaint-mode; end"
# Switching between normal and visual mode
bind -s --preset -M default -m visual v repaint-mode
for key in v \e
bind -s --preset -M visual -m default $key repaint-mode
end
# Motion and actions in normal/select mode
for mode in default visual
if test $mode = default
set -f n_begin_selection begin-selection # only begin-selection if current mode is Normal
set -f ns_move_extend move
set -f commandline_v_repaint ""
else
set -f n_begin_selection
set -f ns_move_extend extend
set -f commandline_v_repaint "commandline -f repaint-mode"
end
for key in (seq 0 9)
bind -s --preset -M $mode $key "fish_bind_count $key"
# FIXME example to bind 0
# FIXME backspace to edit count
end
for key in h \e\[D \eOD "-k left"
bind -s --preset -M $mode $key "fish_helix_command "$ns_move_extend"_char_left"
end
for key in l \e\[C \eOC "-k right"
bind -s --preset -M $mode $key "fish_helix_command "$ns_move_extend"_char_right"
end
for key in k \e\[A \eOA "-k up"
bind -s --preset -M $mode $key "fish_helix_command char_up"
end
for key in j \e\[B \eOB "-k down"
bind -s --preset -M $mode $key "fish_helix_command char_down"
end
bind -s --preset -M $mode w "fish_helix_command next_word_start"
bind -s --preset -M $mode b "fish_helix_command prev_word_start"
bind -s --preset -M $mode e "fish_helix_command next_word_end"
bind -s --preset -M $mode W "fish_helix_command next_long_word_start"
bind -s --preset -M $mode B "fish_helix_command prev_long_word_start"
bind -s --preset -M $mode E "fish_helix_command next_long_word_end"
bind -s --preset -M $mode t "fish_helix_command till_next_char"
bind -s --preset -M $mode f "fish_helix_command find_next_char"
bind -s --preset -M $mode T "fish_helix_command till_prev_char"
bind -s --preset -M $mode F "fish_helix_command find_prev_char"
bind -s --preset -M $mode t\e ""
bind -s --preset -M $mode f\e ""
bind -s --preset -M $mode T\e ""
bind -s --preset -M $mode F\e ""
for enter in \r \n
bind -s --preset -M $mode t$enter "fish_helix_command till_next_cr"
bind -s --preset -M $mode f$enter "fish_helix_command find_next_cr"
bind -s --preset -M $mode T$enter "fish_helix_command till_prev_cr"
bind -s --preset -M $mode F$enter "fish_helix_command find_prev_cr"
end
for key in gh \e\[H \eOH "-k home"
bind -s --preset -M $mode $key "fish_helix_command goto_line_start"
end
for key in gl \e\[F \eOF "-k end"
bind -s --preset -M $mode $key "fish_helix_command goto_line_end"
end
bind -s --preset -M $mode gs "fish_helix_command goto_first_nonwhitespace"
bind -s --preset -M $mode gg "fish_helix_command goto_file_start"
bind -s --preset -M $mode G "fish_helix_command goto_line"
bind -s --preset -M $mode ge "fish_helix_command goto_last_line"
# FIXME alt-. doesn't work with t/T
# FIXME alt-. doesn't work with [ftFT][\n\r]
bind -s --preset -M $mode \e. repeat-jump
# FIXME reselect after undo/redo
bind -s --preset -M $mode u undo begin-selection
bind -s --preset -M $mode U redo begin-selection
bind -s --preset -M $mode -m replace_one r repaint-mode
# FIXME registers
# bind -s --preset -M $mode y fish_clipboard_copy
# bind -s --preset -M $mode P fish_clipboard_paste
# bind -s --preset -M $mode R kill-selection begin-selection yank-pop yank
bind -s --preset -M $mode -m default d "fish_helix_command delete_selection; $commandline_v_repaint"
bind -s --preset -M $mode -m default \ed "fish_helix_command delete_selection_noyank; $commandline_v_repaint"
bind -s --preset -M $mode -m insert c "fish_helix_command delete_selection; commandline -f end-selection repaint-mode"
bind -s --preset -M $mode -m insert \ec "fish_helix_command delete_selection_noyank; commandline -f end-selection repaint-mode"
bind -s --preset -M $mode -m default y "fish_helix_command yank"
bind -s --preset -M $mode p "fish_helix_command paste_after"
bind -s --preset -M $mode P "fish_helix_command paste_before"
bind -s --preset -M $mode R "fish_helix_command replace_selection"
bind -s --preset -M $mode -m default " y" "fish_clipboard_copy; $commandline_v_repaint"
bind -s --preset -M $mode " p" "fish_helix_command paste_after_clip"
bind -s --preset -M $mode " P" "fish_helix_command paste_before_clip"
bind -s --preset -M $mode " R" "fish_helix_command replace_selection_clip"
# FIXME keep selection
bind -s --preset -M $mode ~ togglecase-selection
# FIXME ` and \e`
# FIXME .
# FIXME < and >
# FIXME =
# FIXME \ca \cx
# FIXME Qq
## Shell
# FIXME
## Selection manipulation
# FIXME & _
bind -s --preset -M $mode \; begin-selection
bind -s --preset -M $mode \e\; swap-selection-start-stop
# FIXME \e:
bind -s --preset -M $mode % "fish_helix_command select_all"
bind -s --preset -M $mode x "fish_helix_command select_line"
# FIXME x X \ex
# FIXME J
# FIXME \cc
## Search
# FIXME
## FIXME minor modes: g, m, space
## FIXME [ and ] motions
end
# FIXME should replace the whole selection
# FIXME should be able to go back to visual mode
bind -s --preset -M replace_one -m default '' delete-char self-insert backward-char repaint-mode
bind -s --preset -M replace_one -m default \r 'commandline -f delete-char; commandline -i \n; commandline -f backward-char; commandline -f repaint-mode'
bind -s --preset -M replace_one -m default \e cancel repaint-mode
## FIXME Insert mode keys
## Old config from vi:
# Vi moves the cursor back if, after deleting, it is at EOL.
# To emulate that, move forward, then backward, which will be a NOP
# if there is something to move forward to.
bind -s --preset -M insert -k dc delete-char forward-single-char backward-char
bind -s --preset -M default -k dc delete-char forward-single-char backward-char
# Backspace deletes a char in insert mode, but not in normal/default mode.
bind -s --preset -M insert -k backspace backward-delete-char
bind -s --preset -M default -k backspace backward-char
bind -s --preset -M insert \ch backward-delete-char
bind -s --preset -M default \ch backward-char
bind -s --preset -M insert \x7f backward-delete-char
bind -s --preset -M default \x7f backward-char
bind -s --preset -M insert -k sdc backward-delete-char # shifted delete
bind -s --preset -M default -k sdc backward-delete-char # shifted delete
# bind -s --preset '~' togglecase-char forward-single-char
# bind -s --preset gu downcase-word
# bind -s --preset gU upcase-word
#
# bind -s --preset J end-of-line delete-char
# bind -s --preset K 'man (commandline -t) 2>/dev/null; or echo -n \a'
#
# same vim 'pasting' note as upper
bind -s --preset '"*p' forward-char "commandline -i ( xsel -p; echo )[1]"
bind -s --preset '"*P' "commandline -i ( xsel -p; echo )[1]"
#
# visual mode
#
# bind -s --preset -M visual -m insert c kill-selection end-selection repaint-mode
# bind -s --preset -M visual -m insert s kill-selection end-selection repaint-mode
bind -s --preset -M visual -m default '"*y' "fish_clipboard_copy; commandline -f end-selection repaint-mode"
bind -s --preset -M visual -m default '~' togglecase-selection end-selection repaint-mode
# Set the cursor shape
# After executing once, this will have defined functions listening for the variable.
# Therefore it needs to be before setting fish_bind_mode.
fish_vi_cursor
set -g fish_cursor_selection_mode inclusive
set fish_bind_mode $init_mode
end

View File

@@ -1,4 +1,6 @@
function fish_user_key_bindings function fish_user_key_bindings
fzf_key_bindings
# Execute this once per mode that emacs bindings should be used in # Execute this once per mode that emacs bindings should be used in
fish_default_key_bindings -M insert fish_default_key_bindings -M insert
@@ -6,7 +8,7 @@ function fish_user_key_bindings
# Without --no-erase fish_vi_key_bindings will default to # Without --no-erase fish_vi_key_bindings will default to
# resetting all bindings. # resetting all bindings.
# The argument specifies the initial mode (insert, "default" or visual). # The argument specifies the initial mode (insert, "default" or visual).
fish_vi_key_bindings --no-erase insert fish_helix_key_bindings --no-erase insert
# Nullify fzf default keybindings # Nullify fzf default keybindings
bind \cT '' -M insert bind \cT '' -M insert

View File

@@ -0,0 +1,231 @@
### key-bindings.fish ###
# ____ ____
# / __/___ / __/
# / /_/_ / / /_
# / __/ / /_/ __/
# /_/ /___/_/ key-bindings.fish
#
# - $FZF_TMUX_OPTS
# - $FZF_CTRL_T_COMMAND
# - $FZF_CTRL_T_OPTS
# - $FZF_CTRL_R_OPTS
# - $FZF_ALT_C_COMMAND
# - $FZF_ALT_C_OPTS
# Key bindings
# ------------
# The oldest supported fish version is 3.1b1. To maintain compatibility, the
# command substitution syntax $(cmd) should never be used, even behind a version
# check, otherwise the source command will fail on fish versions older than 3.4.0.
function fzf_key_bindings
# Check fish version
set -l fish_ver (string match -r '^(\d+).(\d+)' $version 2> /dev/null; or echo 0\n0\n0)
if test \( "$fish_ver[2]" -lt 3 \) -o \( "$fish_ver[2]" -eq 3 -a "$fish_ver[3]" -lt 1 \)
echo "This script requires fish version 3.1b1 or newer." >&2
return 1
else if not type -q fzf
echo "fzf was not found in path." >&2
return 1
end
function __fzf_defaults
# $argv[1]: Prepend to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
# $argv[2..]: Append to FZF_DEFAULT_OPTS_FILE and FZF_DEFAULT_OPTS
test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
string join ' ' -- \
"--height $FZF_TMUX_HEIGHT --min-height=20+ --bind=ctrl-z:ignore" $argv[1] \
(test -r "$FZF_DEFAULT_OPTS_FILE"; and string join -- ' ' <$FZF_DEFAULT_OPTS_FILE) \
$FZF_DEFAULT_OPTS $argv[2..-1]
end
function __fzfcmd
test -n "$FZF_TMUX_HEIGHT"; or set -l FZF_TMUX_HEIGHT 40%
if test -n "$FZF_TMUX_OPTS"
echo "fzf-tmux $FZF_TMUX_OPTS -- "
else if test "$FZF_TMUX" = 1
echo "fzf-tmux -d$FZF_TMUX_HEIGHT -- "
else
echo fzf
end
end
function __fzf_parse_commandline -d 'Parse the current command line token and return split of existing filepath, fzf query, and optional -option= prefix'
set -l fzf_query ''
set -l prefix ''
set -l dir '.'
# Set variables containing the major and minor fish version numbers, using
# a method compatible with all supported fish versions.
set -l -- fish_major (string match -r -- '^\d+' $version)
set -l -- fish_minor (string match -r -- '^\d+\.(\d+)' $version)[2]
# fish v3.3.0 and newer: Don't use option prefix if " -- " is preceded.
set -l -- match_regex '(?<fzf_query>[\s\S]*?(?=\n?$)$)'
set -l -- prefix_regex '^-[^\s=]+=|^-(?!-)\S'
if test "$fish_major" -eq 3 -a "$fish_minor" -lt 3
or string match -q -v -- '* -- *' (string sub -l (commandline -Cp) -- (commandline -p))
set -- match_regex "(?<prefix>$prefix_regex)?$match_regex"
end
# Set $prefix and expanded $fzf_query with preserved trailing newlines.
if test "$fish_major" -ge 4
# fish v4.0.0 and newer
string match -q -r -- $match_regex (commandline --current-token --tokens-expanded | string collect -N)
else if test "$fish_major" -eq 3 -a "$fish_minor" -ge 2
# fish v3.2.0 - v3.7.1 (last v3)
string match -q -r -- $match_regex (commandline --current-token --tokenize | string collect -N)
eval set -- fzf_query (string escape -n -- $fzf_query | string replace -r -a '^\\\(?=~)|\\\(?=\$\w)' '')
else
# fish older than v3.2.0 (v3.1b1 - v3.1.2)
set -l -- cl_token (commandline --current-token --tokenize | string collect -N)
set -- prefix (string match -r -- $prefix_regex $cl_token)
set -- fzf_query (string replace -- "$prefix" '' $cl_token | string collect -N)
eval set -- fzf_query (string escape -n -- $fzf_query | string replace -r -a '^\\\(?=~)|\\\(?=\$\w)|\\\n\\\n$' '')
end
if test -n "$fzf_query"
# Normalize path in $fzf_query, set $dir to the longest existing directory.
if test \( "$fish_major" -ge 4 \) -o \( "$fish_major" -eq 3 -a "$fish_minor" -ge 5 \)
# fish v3.5.0 and newer
set -- fzf_query (path normalize -- $fzf_query)
set -- dir $fzf_query
while not path is -d $dir
set -- dir (path dirname $dir)
end
else
# fish older than v3.5.0 (v3.1b1 - v3.4.1)
if test "$fish_major" -eq 3 -a "$fish_minor" -ge 2
# fish v3.2.0 - v3.4.1
string match -q -r -- '(?<fzf_query>^[\s\S]*?(?=\n?$)$)' \
(string replace -r -a -- '(?<=/)/|(?<!^)/+(?!\n)$' '' $fzf_query | string collect -N)
else
# fish v3.1b1 - v3.1.2
set -- fzf_query (string replace -r -a -- '(?<=/)/|(?<!^)/+(?!\n)$' '' $fzf_query | string collect -N)
eval set -- fzf_query (string escape -n -- $fzf_query | string replace -r '\\\n$' '')
end
set -- dir $fzf_query
while not test -d "$dir"
set -- dir (dirname -z -- "$dir" | string split0)
end
end
if not string match -q -- '.' $dir; or string match -q -r -- '^\./|^\.$' $fzf_query
# Strip $dir from $fzf_query - preserve trailing newlines.
if test "$fish_major" -ge 4
# fish v4.0.0 and newer
string match -q -r -- '^'(string escape --style=regex -- $dir)'/?(?<fzf_query>[\s\S]*)' $fzf_query
else if test "$fish_major" -eq 3 -a "$fish_minor" -ge 2
# fish v3.2.0 - v3.7.1 (last v3)
string match -q -r -- '^/?(?<fzf_query>[\s\S]*?(?=\n?$)$)' \
(string replace -- "$dir" '' $fzf_query | string collect -N)
else
# fish older than v3.2.0 (v3.1b1 - v3.1.2)
set -- fzf_query (string replace -- "$dir" '' $fzf_query | string collect -N)
eval set -- fzf_query (string escape -n -- $fzf_query | string replace -r -a '^/?|\\\n$' '')
end
end
end
string escape -n -- "$dir" "$fzf_query" "$prefix"
end
# Store current token in $dir as root for the 'find' command
function fzf-file-widget -d "List files and folders"
set -l commandline (__fzf_parse_commandline)
set -lx dir $commandline[1]
set -l fzf_query $commandline[2]
set -l prefix $commandline[3]
set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
"--reverse --walker=file,dir,follow,hidden --scheme=path" \
"$FZF_CTRL_T_OPTS --multi --print0")
set -lx FZF_DEFAULT_COMMAND "$FZF_CTRL_T_COMMAND"
set -lx FZF_DEFAULT_OPTS_FILE
set -l result (eval (__fzfcmd) --walker-root=$dir --query=$fzf_query | string split0)
and commandline -rt -- (string join -- ' ' $prefix(string escape -- $result))' '
commandline -f repaint
end
function fzf-history-widget -d "Show command history"
set -l -- command_line (commandline)
set -l -- current_line (commandline -L)
set -l -- total_lines (count $command_line)
set -l -- fzf_query (string escape -- $command_line[$current_line])
set -lx FZF_DEFAULT_OPTS (__fzf_defaults '' \
'--nth=2..,.. --scheme=history --multi --wrap-sign="\t↳ "' \
'--bind=\'shift-delete:execute-silent(eval history delete --exact --case-sensitive -- (string escape -n -- {+} | string replace -r -a "^\d*\\\\\\t|(?<=\\\\\\n)\\\\\\t" ""))+reload(eval $FZF_DEFAULT_COMMAND)\'' \
"--bind=ctrl-r:toggle-sort --highlight-line $FZF_CTRL_R_OPTS" \
'--accept-nth=2.. --read0 --print0 --with-shell='(status fish-path)\\ -c)
set -lx FZF_DEFAULT_OPTS_FILE
set -lx FZF_DEFAULT_COMMAND
if type -q perl
set -a FZF_DEFAULT_OPTS --tac
set FZF_DEFAULT_COMMAND 'builtin history -z --reverse | command perl -0 -pe \'s/^/$.\t/g; s/\n/\n\t/gm\''
else
set FZF_DEFAULT_COMMAND \
'set -l h (builtin history -z --reverse | string split0);' \
'for i in (seq (count $h) -1 1);' \
'string join0 -- $i\t(string replace -a -- \n \n\t $h[$i] | string collect);' \
end
end
# Merge history from other sessions before searching
test -z "$fish_private_mode"; and builtin history merge
if set -l result (eval $FZF_DEFAULT_COMMAND \| (__fzfcmd) --query=$fzf_query | string split0)
if test "$total_lines" -eq 1
commandline -- (string replace -a -- \n\t \n $result)
else
set -l a (math $current_line - 1)
set -l b (math $current_line + 1)
commandline -- $command_line[1..$a] (string replace -a -- \n\t \n $result)
commandline -a -- '' $command_line[$b..-1]
end
end
commandline -f repaint
end
function fzf-cd-widget -d "Change directory"
set -l commandline (__fzf_parse_commandline)
set -lx dir $commandline[1]
set -l fzf_query $commandline[2]
set -l prefix $commandline[3]
set -lx FZF_DEFAULT_OPTS (__fzf_defaults \
"--reverse --walker=dir,follow,hidden --scheme=path" \
"$FZF_ALT_C_OPTS --no-multi --print0")
set -lx FZF_DEFAULT_OPTS_FILE
set -lx FZF_DEFAULT_COMMAND "$FZF_ALT_C_COMMAND"
if set -l result (eval (__fzfcmd) --query=$fzf_query --walker-root=$dir | string split0)
cd -- $result
commandline -rt -- $prefix
end
commandline -f repaint
end
bind \cr fzf-history-widget
bind -M insert \cr fzf-history-widget
if not set -q FZF_CTRL_T_COMMAND; or test -n "$FZF_CTRL_T_COMMAND"
bind \ct fzf-file-widget
bind -M insert \ct fzf-file-widget
end
if not set -q FZF_ALT_C_COMMAND; or test -n "$FZF_ALT_C_COMMAND"
bind \ec fzf-cd-widget
bind -M insert \ec fzf-cd-widget
end
end
### end: key-bindings.fish ###

View File

@@ -0,0 +1,27 @@
function night_mode_temp_down
set target_process hyprsunset
set temp_file ~/.cache/hyprsunset_temp
set decrement 100
if not pgrep $target_process >/dev/null
return
end
if test -f $temp_file
set current_temp (cat $temp_file)
else
set current_temp 4000
end
set new_temp (math $current_temp - $decrement)
if test $new_temp -lt 2000
set new_temp 2000
end
echo $new_temp >$temp_file
killall -s SIGINT $target_process
sleep 0.5
$target_process -t $new_temp
end

View File

@@ -0,0 +1,27 @@
function night_mode_temp_up
set target_process hyprsunset
set temp_file ~/.cache/hyprsunset_temp
set increment 100
if not pgrep $target_process >/dev/null
return
end
if test -f $temp_file
set current_temp (cat $temp_file)
else
set current_temp 4000
end
set new_temp (math $current_temp + $increment)
if test $new_temp -gt 6500
set new_temp 6500
end
echo $new_temp >$temp_file
killall -s SIGINT $target_process
sleep 0.5
$target_process -t $new_temp
end

View File

@@ -1,9 +1,16 @@
function night_mode_toggle function night_mode_toggle
set target_process wlsunset set target_process hyprsunset
set temp_file ~/.cache/hyprsunset_temp
if pgrep $target_process >/dev/null if pgrep $target_process >/dev/null
killall -s SIGINT wlsunset killall -s SIGINT $target_process
else else
wlsunset if test -f $temp_file
set temp (cat $temp_file)
else
set temp 4000
echo $temp >$temp_file
end
$target_process -t $temp
end end
end end

View File

@@ -40,3 +40,4 @@ S-h = ":bp"
S-right = ":bn" S-right = ":bn"
S-left = ":bp" S-left = ":bp"
A-w = ":w" A-w = ":w"
A-r = ":rl"

View File

@@ -259,7 +259,7 @@ bind = $mainMod, Z, exec, pypr zoom
# bind = $mainMod, T, exec, wezterm start --always-new-process # bind = $mainMod, T, exec, wezterm start --always-new-process
bind = $mainMod, T, exec, nvidia-offload kitty bind = $mainMod, T, exec, nvidia-offload kitty
bind = $mainMod SHIFT, T, exec, telegram-desktop bind = $mainMod SHIFT, T, exec, Telegram
bind = $mainMod, B, exec, qutebrowser bind = $mainMod, B, exec, qutebrowser
bind = $mainMod SHIFT, B, exec, brave bind = $mainMod SHIFT, B, exec, brave
bind = $mainMod, F, exec, thunar bind = $mainMod, F, exec, thunar

View File

@@ -17,7 +17,7 @@ from kittens.tui.operations import (
) )
from kitty.config import cached_values_for from kitty.config import cached_values_for
from kitty.key_encoding import EventType from kitty.key_encoding import EventType
from kitty.typing import KeyEventType, ScreenSize from kitty.typing_compat import KeyEventType, ScreenSize
NON_SPACE_PATTERN = re.compile(r"\S+") NON_SPACE_PATTERN = re.compile(r"\S+")
SPACE_PATTERN = re.compile(r"\s+") SPACE_PATTERN = re.compile(r"\s+")

View File

@@ -1,19 +1,24 @@
theme: gui:
lightTheme: false theme:
activeBorderColor: activeBorderColor:
- "#a6da95" # Green - '#8bd5ca'
- bold - bold
inactiveBorderColor: inactiveBorderColor:
- "#cad3f5" # Text - '#a5adcb'
optionsTextColor: optionsTextColor:
- "#8aadf4" # Blue - '#8aadf4'
selectedLineBgColor: selectedLineBgColor:
- "#363a4f" # Surface0 - '#363a4f'
selectedRangeBgColor:
- "#363a4f" # Surface0
cherryPickedCommitBgColor: cherryPickedCommitBgColor:
- "#8bd5ca" # Teal - '#494d64'
cherryPickedCommitFgColor: cherryPickedCommitFgColor:
- "#8aadf4" # Blue - '#8bd5ca'
unstagedChangesColor: unstagedChangesColor:
- red # Red - '#ed8796'
defaultFgColor:
- '#cad3f5'
searchingActiveBorderColor:
- '#eed49f'
authorColors:
'*': '#b7bdf8'

View File

@@ -0,0 +1,102 @@
{
"$schema": "https://opencode.ai/config.json",
"model": "z/glm-4.5",
"theme": "catppuccin",
"provider": {
"moonshot": {
"name": "Moonshot",
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "https://api.moonshot.ai/v1"
},
"models": {
"kimi-k2-0711-preview": {
"name": "Kimi-K2"
}
}
},
"z": {
"name": "Z",
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "https://api.z.ai/api/paas/v4"
},
"models": {
"glm-4.5": {
"name": "GLM-4.5"
}
}
}
},
"mcp": {
"context7": {
"type": "local",
"command": [
"npx",
"-y",
"@upstash/context7-mcp"
],
"enabled": true
},
"playwright": {
"type": "local",
"command": [
"npx",
"-y",
"@playwright/mcp"
],
"enabled": true
},
"searxng": {
"type": "local",
"command": [
"npx",
"-y",
"mcp-searxng"
],
"enabled": true,
"environment": {
"SEARXNG_URL": "http://127.0.0.1:7777"
}
},
"mcp-server-git": {
"type": "local",
"command": [
"uvx",
"--python",
"/run/current-system/sw/bin/python",
"mcp-server-git"
],
"enabled": true
},
"time": {
"type": "local",
"command": [
"uvx",
"--python",
"/run/current-system/sw/bin/python",
"mcp-server-time"
],
"enabled": true
},
"sequential-thinking": {
"type": "local",
"command": [
"npx",
"-y",
"@modelcontextprotocol/server-sequential-thinking"
],
"enabled": true
},
"filesystem": {
"type": "local",
"command": [
"npx",
"-y",
"@modelcontextprotocol/server-filesystem",
"/home/xnm"
],
"enabled": true
}
}
}

View File

@@ -0,0 +1 @@
theme: "catppuccin-macchiato-teal"

View File

@@ -223,7 +223,10 @@
"custom/night_mode": { "custom/night_mode": {
"return-type": "json", "return-type": "json",
"interval": 1, "restart-interval": 1,
"on-scroll-down": "fish -c night_mode_temp_up",
"on-scroll-up": "fish -c night_mode_temp_down",
"smooth-scrolling-threshold": 2.0,
"exec": "fish -c check_night_mode", "exec": "fish -c check_night_mode",
"on-click": "fish -c night_mode_toggle", "on-click": "fish -c night_mode_toggle",
}, },
@@ -287,8 +290,8 @@
// "numlock": true, // "numlock": true,
"format": "{name} {icon}", "format": "{name} {icon}",
"format-icons": { "format-icons": {
"locked": "", "locked": "󰌾",
"unlocked": "" "unlocked": "󰍀"
} }
}, },
@@ -343,7 +346,7 @@
}, },
"memory": { "memory": {
"format": "{percentage}%", "format": "󰍛{percentage}%",
"tooltip-format": "Main: ({used} GiB/{total} GiB)({percentage}%), available {avail} GiB\nSwap: ({swapUsed} GiB/{swapTotal} GiB)({swapPercentage}%), available {swapAvail} GiB", "tooltip-format": "Main: ({used} GiB/{total} GiB)({percentage}%), available {avail} GiB\nSwap: ({swapUsed} GiB/{swapTotal} GiB)({swapPercentage}%), available {swapAvail} GiB",
"states": { "states": {
"high": 90, "high": 90,

View File

@@ -7,6 +7,9 @@
[includeIf "gitdir:~/work/"] [includeIf "gitdir:~/work/"]
path = ~/work/.gitconfig.work path = ~/work/.gitconfig.work
[includeIf "gitdir:~/radicle-local-hub/"]
path = ~/radicle-local-hub/.gitconfig.radicle
[core] [core]
excludesfile = ~/.gitignore excludesfile = ~/.gitignore
pager = delta pager = delta
@@ -21,4 +24,94 @@
diffFilter = delta --color-only diffFilter = delta --color-only
[delta] [delta]
side-by-side = true
line-numbers = true
navigate = true
hyperlinks = true
hyperlinks-file-link-format = "file://{path}#{line}"
features = catppuccin-macchiato features = catppuccin-macchiato
whitespace-error-style = 22 reverse
conflict-style = zebibt
# Fancy visual enhancements
file-added-label = [added]
file-copied-label = [copied]
file-modified-label = [modified]
file-removed-label = [removed]
file-renamed-label = [renamed]
# Commit decorations
commit-decoration-style = bold box ul
commit-style = raw
# File decorations
file-decoration-style = bold yellow ul
file-style = bold blue
# Hunk headers
hunk-header-style = file line-number syntax
hunk-header-decoration-style = bold box ul
# Word diff highlighting
word-diff-regex = .
max-line-distance = 0.6
max-line-length = 512
# Line highlighting
line-numbers-left-format = "{nm:>4}┊"
line-numbers-right-format = "{np:>4}│"
line-numbers-left-style = blue
line-numbers-right-style = blue
# Blame enhancements
blame-code-style = syntax
blame-format = "{author:<18} ({commit:>7}) {timestamp:<16} │ "
blame-timestamp-format = "%Y-%m-%d %H:%M"
# Performance
inspect-raw-lines = false
# Additional fancy features
color-moved = default
color-moved-ws = allow-indent-change
# Show line numbers in context
line-numbers-minus-style = bold red
line-numbers-plus-style = bold green
line-numbers-zero-style = dim
# Better context display
minus-empty-line-marker-style = normal
plus-empty-line-marker-style = normal
# File icons (if available)
file-icon = true
# Syntax highlighting improvements
syntax-theme = Catppuccin Macchiato
keep-plus-minus-markers = false
# Show commit stats
show-syntax-themes = false
show-themes = false
# Git integration
git-config = true
[diff]
tool = delta
[difftool]
prompt = false
[difftool "delta"]
cmd = delta "$LOCAL" "$REMOTE"
[merge]
tool = delta
[mergetool]
prompt = false
[mergetool "delta"]
cmd = delta "$LOCAL" "$MERGED" "$REMOTE" --side-by-side

View File

@@ -0,0 +1,38 @@
name: "catppuccin-macchiato-mauve"
primary: "#c6a0f6" # buttons, fixed table columns
secondary: "#c6a0f6" # method selector, some minor labels
accent: "#e3cffb" # header text, scrollbars, cursors, focus highlights
background: "#24273a" # background colors
surface: "#363a4f" # panels, etc
error: "#ed8796" # error messages
success: "#a6da95" # success messages
warning: "#eed49f" # warning messages
dark: "true"
text_area:
cursor: "reverse #f4dbd6"
cursor_line: "underline #cad3f5"
selection: "reverse #939ab7"
gutter: "bold #a6da95"
matched_bracket: "reverse #b8c0e0"
url:
base: "italic #8aadf4"
protocol: "bold #8bd5ca"
separator: "#cad3f5"
syntax:
json_key: "italic #8aadf4"
json_number: "#f5a97f"
json_string: "#a6da95"
json_boolean: "#91d7e3"
json_null: "#939ab7"
method:
get: "bold #8aadf4"
post: "bold #a6da95"
put: "bold #eed49f"
delete: "bold #ed8796"
patch: "bold #8bd5ca"
options: "bold #b7bdf8"
head: "bold #c6a0f6"

View File

@@ -0,0 +1,38 @@
name: "catppuccin-macchiato-teal"
primary: "#8bd5ca" # buttons, fixed table columns
secondary: "#8bd5ca" # method selector, some minor labels
accent: "#b1e3db" # header text, scrollbars, cursors, focus highlights
background: "#24273a" # background colors
surface: "#363a4f" # panels, etc
error: "#ed8796" # error messages
success: "#a6da95" # success messages
warning: "#eed49f" # warning messages
dark: "true"
text_area:
cursor: "reverse #f4dbd6"
cursor_line: "underline #cad3f5"
selection: "reverse #939ab7"
gutter: "bold #a6da95"
matched_bracket: "reverse #b8c0e0"
url:
base: "italic #8aadf4"
protocol: "bold #8bd5ca"
separator: "#cad3f5"
syntax:
json_key: "italic #8aadf4"
json_number: "#f5a97f"
json_string: "#a6da95"
json_boolean: "#91d7e3"
json_null: "#939ab7"
method:
get: "bold #8aadf4"
post: "bold #a6da95"
put: "bold #eed49f"
delete: "bold #ed8796"
patch: "bold #8bd5ca"
options: "bold #b7bdf8"
head: "bold #c6a0f6"

2
home/.npmrc Normal file
View File

@@ -0,0 +1,2 @@
strict-ssl=true
prefix = ${HOME}/.npm-packages

View File

@@ -0,0 +1,7 @@
[user]
email = artem.shv@proton.me
name = xnm
signingkey = ~/.radicle/keys/radicle.pub
[core]
sshCommand = "ssh -i ~/.radicle/keys/radicle"

View File

@@ -5,6 +5,7 @@
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
rust-overlay.url = "github:oxalica/rust-overlay"; rust-overlay.url = "github:oxalica/rust-overlay";
wezterm.url = "github:wez/wezterm?dir=nix"; wezterm.url = "github:wez/wezterm?dir=nix";
radicle-tui.url = "git+https://seed.radicle.xyz/z39mP9rQAaGmERfUMPULfPUi473tY.git?rev=dcc51b96a90d6e63cd69fae7f29e896f13816a1f";
}; };
outputs = { nixpkgs, ... } @ inputs: outputs = { nixpkgs, ... } @ inputs:
@@ -56,6 +57,7 @@
./programming-languages.nix ./programming-languages.nix
./lsp.nix ./lsp.nix
./rust.nix ./rust.nix
./radicle.nix
./wasm.nix ./wasm.nix
./info-fetchers.nix ./info-fetchers.nix
./utils.nix ./utils.nix

View File

@@ -19,6 +19,8 @@
hyprlock hyprlock
hypridle hypridle
hyprpaper hyprpaper
hyprsunset
hyprpolkitagent
inputs.wezterm.packages.${pkgs.system}.default inputs.wezterm.packages.${pkgs.system}.default
kitty kitty

View File

@@ -4,7 +4,7 @@
services.ollama = { services.ollama = {
enable = true; enable = true;
loadModels = [ "llama3.2:3b" "llama3.2-vision:11b" "phi4-reasoning:14b" "deepseek-r1:7b" "dolphin3:8b" "smallthinker:3b" "nomic-embed-text" "gemma3:12b" "gemma3:27b" "deepcoder:14b" "qwen3:14b" ]; loadModels = [ "llama3.2:3b" "phi4-reasoning:14b" "dolphin3:8b" "smallthinker:3b" "gemma3n:e4b" "deepcoder:14b" "qwen3:14b" "qwen3-coder:30b" "nomic-embed-text" ];
acceleration = "cuda"; acceleration = "cuda";
}; };
@@ -23,6 +23,10 @@
environmentFile = "${config.users.users.xnm.home}/.config/.env.searxng"; # FIXME: The location of the `.env` file where you need to set up the key environmentFile = "${config.users.users.xnm.home}/.config/.env.searxng"; # FIXME: The location of the `.env` file where you need to set up the key
}; };
services.n8n = {
enable = true;
};
services.open-webui = { services.open-webui = {
enable = true; enable = true;
port = 8888; port = 8888;
@@ -32,12 +36,19 @@
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
oterm oterm
alpaca alpaca
aichat aichat
fabric-ai
aider-chat aider-chat
opencode
# tgpt # tgpt
# smartcat # smartcat
# nextjs-ollama-llm-ui # nextjs-ollama-llm-ui
# open-webui # open-webui
chromium
playwright
]; ];
} }

View File

@@ -2,7 +2,7 @@
{ {
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
python311Packages.python-lsp-server python313Packages.python-lsp-server
nodePackages_latest.nodemon nodePackages_latest.nodemon
nodePackages_latest.typescript nodePackages_latest.typescript
nodePackages_latest.typescript-language-server nodePackages_latest.typescript-language-server

View File

@@ -3,7 +3,8 @@
{ {
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
go go
(python312Full.withPackages(ps: with ps; [ pygobject3 gobject-introspection pyqt6-sip])) (python313Full.withPackages(ps: with ps; [ pygobject3 gobject-introspection pyqt6-sip]))
uv
nodePackages_latest.nodejs nodePackages_latest.nodejs
nodePackages_latest.pnpm nodePackages_latest.pnpm
bun bun

13
nixos/radicle.nix Normal file
View File

@@ -0,0 +1,13 @@
{ inputs, pkgs, ... }:
{
services.radicle = {
enable = false;
checkConfig = false;
};
environment.systemPackages = with pkgs; [
inputs.radicle-tui.packages.${pkgs.system}.default
radicle-node
];
}

View File

@@ -4,7 +4,6 @@
programs.light.enable = true; programs.light.enable = true;
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
wlsunset
brightnessctl brightnessctl
]; ];
} }

View File

@@ -10,6 +10,11 @@
# }; # };
# Enable Security Services # Enable Security Services
security.sudo-rs = {
enable = true;
execWheelOnly = true;
};
security.sudo.enable = false;
users.users.root.hashedPassword = "!"; users.users.root.hashedPassword = "!";
security.tpm2 = { security.tpm2 = {
enable = true; enable = true;
@@ -28,7 +33,7 @@
security.pam.services = { security.pam.services = {
login.enableAppArmor = true; login.enableAppArmor = true;
sshd.enableAppArmor = true; sshd.enableAppArmor = true;
sudo.enableAppArmor = true; sudo-rs.enableAppArmor = true;
su.enableAppArmor = true; su.enableAppArmor = true;
greetd.enableAppArmor = true; greetd.enableAppArmor = true;
u2f.enableAppArmor = true; u2f.enableAppArmor = true;
@@ -69,9 +74,9 @@
executable = "${lib.getBin pkgs.slack}/bin/slack"; executable = "${lib.getBin pkgs.slack}/bin/slack";
profile = "${pkgs.firejail}/etc/firejail/slack.profile"; profile = "${pkgs.firejail}/etc/firejail/slack.profile";
}; };
telegram-desktop = { Telegram = {
executable = "${lib.getBin pkgs.tdesktop}/bin/telegram-desktop"; executable = "${lib.getBin pkgs.tdesktop}/bin/Telegram";
profile = "${pkgs.firejail}/etc/firejail/telegram-desktop.profile"; profile = "${pkgs.firejail}/etc/firejail/Telegram.profile";
}; };
brave = { brave = {
executable = "${lib.getBin pkgs.brave}/bin/brave"; executable = "${lib.getBin pkgs.brave}/bin/brave";

View File

@@ -2,16 +2,23 @@
{ {
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
moreutils
file file
upx upx
dotenvx
git git
lazygit lazygit
delta delta
sqlx-cli
mermaid-cli
posting
license-generator license-generator
git-ignore git-ignore
gitleaks gitleaks
git-secrets # git-secrets
pass-git-helper pass-git-helper
jujutsu
jjui
just just
xh xh
process-compose process-compose
@@ -27,11 +34,18 @@
tealdeer tealdeer
# skim #fzf better alternative in rust # skim #fzf better alternative in rust
monolith monolith
# taskwarrior3
asciinema
asciinema-agg
aria aria
# wormhole-william
magic-wormhole-rs
# macchina #neofetch alternative in rust # macchina #neofetch alternative in rust
dogdns
sd sd
ouch ouch
duf duf
ncdu
du-dust du-dust
fd fd
jq jq

View File

@@ -18,5 +18,7 @@
}; };
# Change runtime directory size # Change runtime directory size
services.logind.extraConfig = "RuntimeDirectorySize=8G"; services.logind.settings.Login = {
RuntimeDirectorySize="8G";
};
} }

View File

@@ -14,6 +14,5 @@
surrealdb-migrations surrealdb-migrations
surrealist surrealist
trunk trunk
sqlx-cli
]; ];
} }

View File

@@ -4,12 +4,14 @@
environment.systemPackages = with pkgs; [ environment.systemPackages = with pkgs; [
slack slack
aws-sam-cli aws-sam-cli
google-cloud-sdk
awscli2 awscli2
ssm-session-manager-plugin ssm-session-manager-plugin
cargo-lambda cargo-lambda
gnumake gnumake
cmake cmake
redli
firebase-tools firebase-tools
redli
android-studio
]; ];
} }

View File

@@ -14,7 +14,7 @@
security.pam.services = { security.pam.services = {
greetd.u2fAuth = true; greetd.u2fAuth = true;
sudo.u2fAuth = true; sudo-rs.u2fAuth = true;
hyprlock.u2fAuth = true; hyprlock.u2fAuth = true;
}; };