@riflo/ryte 1.0.0

package/.github/pull_request_template.md

@@ -0,0 +1,21 @@
+## Description
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context.
+
+Fixes # (issue)
+
+## Type of Change
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Documentation update
+
+## How Has This Been Tested?
+Please describe the tests that you ran to verify your changes. 
+
+## Checklist:
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my own code
+- [ ] I have commented my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have committed using `pact c`

package/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to Pact-AI
+
+First off, thank you for considering contributing to Pact-AI! It's people like you that make it a great tool.
+
+## Code of Conduct
+
+By participating in this project, you agree to abide by our Code of Conduct (standard Contributor Covenant).
+
+## How Can I Contribute?
+
+### Reporting Bugs
+- Use the GitHub issue tracker.
+- Describe the bug and include steps to reproduce it.
+
+### Suggesting Enhancements
+- Open an issue with the "enhancement" label.
+- Explain why the feature would be useful.
+
+### Pull Requests
+1. Fork the repository.
+2. Create a new branch (`git checkout -b feature/amazing-feature`).
+3. Make your changes.
+4. **Important**: Use `pact c` to commit your changes. This helps us maintain a clean, semantic history.
+5. Push to the branch (`git push origin feature/amazing-feature`).
+6. Open a Pull Request.
+
+## Development Setup
+
+1. Clone your fork.
+2. Install dependencies: `npm install`.
+3. Link the package for local testing: `npm link`.
+4. Run with `pact`.
+
+## Style Guide
+- Follow the [Conventional Commits](https://www.conventionalcommits.org/) specification.
+- Keep the code clean and well-documented.
+
+Happy coding!

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Riflo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# RYTE
+
+> **Write it right.** AI-powered Git workflow CLI for developers who care about clean history and velocity.
+
+[![npm version](https://img.shields.io/npm/v/@riflo/ryte.svg?style=flat-square)](https://www.npmjs.com/package/@riflo/ryte)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![Node Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg?style=flat-square)](https://nodejs.org)
+
+---
+
+## Introduction
+
+Writing meaningful commit messages and well-structured Pull Requests is critical for team collaboration, but it’s often a friction point in a fast-paced development cycle. 
+
+**ryte** is your CLI companion that bridge the gap between "coding" and "documenting". It reads your git diffs, understands the context of your changes, and generates professional, semantic-compliant messages in seconds.
+
+### Core Value
+- **Zero Friction**: Stay in the terminal. No Web UI, no heavy extensions.
+- **Semantic by Default**: Automatically follows [Conventional Commits](https://www.conventionalcommits.org/).
+- **Intelligent Context**: Infers motivation from diffs and branch names.
+- **Interactive Control**: You are always in charge with an `Accept/Edit/Regenerate` workflow.
+
+---
+
+## ⚡ Quick Start
+
+```bash
+# 1. Install globally
+npm install -g @riflo/ryte
+
+# 2. Set your free AI key (get one at console.groq.com)
+export GROQ_API_KEY="gsk_..."
+
+# 3. Stage your changes and go
+git add .
+ryte c
+```
+
+---
+
+## The Problem It Solves
+
+Your git log shouldn't look like this:
+```bash
+❌  update auth
+❌  fix bug
+❌  changes
+❌  wip
+```
+
+With `ryte c`, it looks like this:
+```bash
+✅  feat(auth): implement JWT refresh token rotation
+✅  fix(cart): resolve crash on empty product array
+✅  refactor(db): extract query builder to repository layer
+✅  chore: update dependencies to remove security vulnerabilities
+```
+
+One command. Same diff. Zero manual thinking.
+
+---
+
+## Installation
+
+### Via NPM (Recommended)
+```bash
+npm install -g @riflo/ryte
+```
+
+### Via PNPM / Yarn
+```bash
+pnpm add -g @riflo/ryte
+# or
+yarn global add @riflo/ryte
+```
+
+---
+
+## Usage
+
+### 1. Generate Semantic Commit
+Stage your files first, then let AI write the message.
+```bash
+git add .
+ryte c
+```
+**Interactive Workflow:**
+- `[A]ccept`: Applies the commit immediately.
+- `[E]dit`: Opens your default editor (Vim/Notepad/Nano) to refine the message.
+- `[R]egenerate`: Ask AI for another suggestion.
+- `[C]ancel`: Abort the process.
+
+### 2. Generate PR Draft
+Summarize your entire branch history into a clean Markdown description.
+```bash
+ryte pr
+```
+**Example Output:**
+```markdown
+# 🔥 Feat: User Authentication Flow
+
+## 📋 Summary
+Introduces a complete JWT-based authentication system, including login, registration, and automatic token refresh via HTTP-only cookies.
+
+## 🚀 Key Changes
+- Implement `AuthMiddleware` for route protection
+- Add `RefreshTokenRepository` for token rotation
+- Create `LoginScreen` and `RegisterScreen` UI components
+
+## ⚠️ Important Notes/Impact
+- **Requires DB Migration**: Run `php artisan migrate` for the new `personal_access_tokens` table.
+- **Dependency Added**: Added `firebase/php-jwt` package.
+
+## 🔍 Reviewer Checklist
+- [ ] Logic health & edge cases
+- [ ] Performance considerations
+- [ ] Code style & standard conformity
+```
+
+---
+
+## How It Works
+
+1. **Extraction**: Runs `git diff --staged` to capture your latest changes.
+2. **Analysis**: Filters out lockfiles and noise, then sends the core diff to high-performance AI models (Groq Llama 3 or OpenAI GPT-4o-mini).
+3. **Generation**: Crafts a semantic message (feat, fix, chore, etc.) based on the actual logic changes.
+4. **Interaction**: Presents a TUI (Terminal UI) for you to review and finalize the entry.
+
+---
+
+## Why Not Just Use GitHub Copilot?
+
+Fair question. Here's an honest comparison:
+
+| Feature | GitHub Copilot | **RYTE** |
+|---|---|---|
+| Works natively in terminal | ❌ | ✅ |
+| Diff-aware (reads what you actually changed) | ❌ | ✅ |
+| Enforces Conventional Commits format | ❌ | ✅ |
+| No IDE required | ❌ | ✅ |
+| Free tier available | ❌ | ✅ (via Groq) |
+| BYOK (Bring Your Own Key) | ❌ | ✅ |
+
+Copilot is great for writing code. RYTE is for **documenting the intent** behind it.
+
+---
+
+## 🔒 Security & Privacy
+
+We understand that sending code to an external API is a sensitive decision. Here's exactly what RYTE does and does *not* do:
+
+| What we send | What we do NOT send |
+|---|---|
+| `git diff --staged` output only | Full file contents |
+| Truncated to max ~16k chars | Binary files |
+| Nothing from untracked files | `.env` or secret files |
+
+- ✅ No data is stored or logged by RYTE itself.
+- ✅ Lockfiles (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`) are auto-excluded.
+- ✅ Minified files (`*.min.js`, `*.min.css`) are auto-excluded.
+- ✅ You can use your own API key (BYOK) for complete control over data flow.
+- ✅ Supports local AI models via Ollama (on roadmap).
+
+---
+
+## Configuration
+
+**ryte** requires an API key to function. We support two providers:
+
+### Groq (Recommended - Free & Instant)
+Get your free key at [console.groq.com](https://console.groq.com/keys).
+```powershell
+# Windows
+$env:GROQ_API_KEY="gsk_..."
+
+# Linux / Mac / Git Bash
+export GROQ_API_KEY="gsk_..."
+```
+
+### OpenAI 
+Get your key at [platform.openai.com](https://platform.openai.com/api-keys).
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+> [!TIP]
+> Add these to your system environment variables to avoid setting them in every new session.
+
+---
+
+## Philosophy
+
+We believe that **every commit should be written right**. A clean git history is not just about aesthetics; it's about debuggability, revertability, and understanding the "why" behind the code months after it was written.
+
+---
+
+## Roadmap
+
+- [ ] **Context-Aware Radius**: Analyze importing files to suggest impact warnings.
+- [ ] **JIRA / Linear / GitHub Issues**: Automatic ticket status sync.
+- [ ] **Custom Rulesets**: Define your own commit linting rules for the AI.
+- [ ] **Local LLM Support**: Support for Ollama/Llama.cpp for offline-only environments.
+
+---
+
+Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+Please see [CONTRIBUTING.md](file:///d:/pact/CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests.
+
+---
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/Rifuroo/ryte/blob/main/LICENSE) for more information.
+
+---
+
+## FAQ
+
+**Q: Does it send my whole code to the AI?**  
+A: No. It only sends the `git diff` of your staged changes. It automatically ignores binary files and common lockfiles.
+
+**Q: Is it free?**  
+A: The tool itself is free. If you use Groq, the API usage is currently free. If you use OpenAI, you pay for what you use (extremely cheap, ~$0.01 for dozens of commits).
+
+---
+
+Developed with ❤️ by **Riflo**

package/bin/ryte.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/index.js";

package/install-pact.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Simple install script for pact CLI
+echo "Installing PACT CLI globally..."
+npm install -g .
+
+echo ""
+echo "Adding aliases to ~/.bashrc or ~/.zshrc is recommended:"
+echo "alias c='pact c'"
+echo "alias pr='pact pr'"
+echo ""
+echo "Don't forget to set OPENAI_API_KEY in your environment!"

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@riflo/ryte",
+  "version": "1.0.0",
+  "description": "AI Git Workflow Assistant - Generate semantic commits and PRs",
+  "main": "src/index.js",
+  "bin": {
+    "ryte": "bin/ryte.js"
+  },
+  "type": "module",
+  "keywords": [
+    "git",
+    "ai",
+    "commit",
+    "conventional-commits",
+    "workflow",
+    "automation"
+  ],
+  "author": "Riflo <rifloahmad@gmail.com>",
+  "license": "MIT",
+  "scripts": {
+    "start": "node bin/ryte.js"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rifuroo/ryte.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rifuroo/ryte/issues"
+  },
+  "homepage": "https://github.com/Rifuroo/ryte#readme"
+}

package/src/ai.js

@@ -0,0 +1,67 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+export async function generateAIResponse(messages) {
+    const groqKey = process.env.GROQ_API_KEY;
+    const openAiKey = process.env.OPENAI_API_KEY;
+
+    if (!groqKey && !openAiKey) {
+        console.error("Error: Please set either GROQ_API_KEY (for free AI) or OPENAI_API_KEY in your environment variables.");
+        process.exit(1);
+    }
+
+    const isGroq = !!groqKey;
+    const apiKey = isGroq ? groqKey : openAiKey;
+
+    // Groq API is 100% compatible with OpenAI's format! Just changing URL & Model.
+    const apiUrl = isGroq
+        ? "https://api.groq.com/openai/v1/chat/completions"
+        : "https://api.openai.com/v1/chat/completions";
+
+    // llama-3.1-8b-instant: 14,400 TPM (6x higher than llama-3.3-70b-versatile)
+    // Still very capable for commit messages and PR summaries
+    const model = isGroq
+        ? "llama-3.1-8b-instant"
+        : "gpt-4o-mini";
+
+    const MAX_RETRIES = 3;
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const response = await fetch(apiUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: model,
+                    messages: messages,
+                    temperature: 0.5,
+                })
+            });
+
+            if (response.status === 429) {
+                // Rate limited — parse retry-after header or use exponential backoff
+                const retryAfter = parseInt(response.headers.get("retry-after") || "15", 10);
+                const waitMs = (retryAfter + 1) * 1000;
+                console.warn(`\x1b[33m⚠ Rate limit hit. Waiting ${retryAfter + 1}s before retry (${attempt}/${MAX_RETRIES})...\x1b[0m`);
+                await new Promise(r => setTimeout(r, waitMs));
+                continue;
+            }
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.error?.message || "API request failed");
+            }
+
+            const data = await response.json();
+            return data.choices[0].message.content.trim();
+        } catch (e) {
+            if (attempt === MAX_RETRIES) {
+                console.error("AI Generation failed:", e.message);
+                process.exit(1);
+            }
+        }
+    }
+}

package/src/git.js

@@ -0,0 +1,68 @@
+import { execSync } from "child_process";
+
+export function getStagedDiff() {
+    try {
+        const diff = execSync(
+            'git diff --staged -- . ' +
+            '":(exclude)package-lock.json" ' +
+            '":(exclude)pnpm-lock.yaml" ' +
+            '":(exclude)yarn.lock" ' +
+            '":(exclude)*.lock" ' +
+            '":(exclude)*.min.js" ' +
+            '":(exclude)*.min.css"',
+            { encoding: "utf-8" }
+        );
+
+        const trimmed = diff.trim();
+
+        // llama-3.1-8b-instant: 14,400 TPM. 1 token ≈ 4 chars.
+        // Cap at ~16,000 chars (~4,000 tokens), leaving budget for the system prompt.
+        const MAX_CHARS = 16000;
+
+        if (trimmed.length > MAX_CHARS) {
+            console.warn(
+                `\x1b[33m⚠ Diff is large (${trimmed.length} chars). Truncating to fit AI token limit.\x1b[0m`
+            );
+            return trimmed.slice(0, MAX_CHARS) + "\n\n[... diff truncated to fit AI token limit ...]";
+        }
+
+        return trimmed;
+    } catch (e) {
+        console.error("Failed to get staged git diff. Are you in a git repository?");
+        process.exit(1);
+    }
+}
+
+export function getCurrentBranch() {
+    try {
+        const branch = execSync("git branch --show-current", { encoding: "utf-8" });
+        return branch.trim();
+    } catch (e) {
+        return "";
+    }
+}
+
+export function getBranchCommits(baseBranch = "main") {
+    try {
+        // get commits on current branch that are not on main
+        const commits = execSync(`git log ${baseBranch}..HEAD --oneline`, { encoding: "utf-8" });
+        return commits.trim();
+    } catch (e) {
+        // Fallback to latest 10 commits if main branch doesn't exist
+        try {
+            const commits = execSync(`git log -n 10 --oneline`, { encoding: "utf-8" });
+            return commits.trim();
+        } catch (err) {
+            return "";
+        }
+    }
+}
+
+export function applyCommit(message) {
+    try {
+        // write message to a temp file or pass via -m safely
+        execSync(`git commit -m ${JSON.stringify(message)}`, { stdio: "inherit" });
+    } catch (e) {
+        console.error("Failed to commit.");
+    }
+}

package/src/index.js

@@ -0,0 +1,148 @@
+import readline from "readline";
+import { execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { getStagedDiff, getCurrentBranch, getBranchCommits, applyCommit } from "./git.js";
+import { generateAIResponse } from "./ai.js";
+import { COMMIT_SYSTEM_PROMPT, PR_SYSTEM_PROMPT } from "./prompt.js";
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+async function question(query) {
+    return new Promise(resolve => rl.question(query, resolve));
+}
+
+// Ensure the user doesn't just hit enter for empty edits
+function editInteractively(initialText) {
+    return new Promise((resolve) => {
+        const tmpFile = path.join(os.tmpdir(), `ryte_edit_${Date.now()}.txt`);
+        fs.writeFileSync(tmpFile, initialText, "utf-8");
+
+        const editor = process.env.EDITOR || "vim";
+        console.log(`\nOpening in ${editor}... Close the editor to save.`);
+        try {
+            execSync(`${editor} ${tmpFile}`, { stdio: "inherit" });
+            const result = fs.readFileSync(tmpFile, "utf-8").trim();
+            fs.unlinkSync(tmpFile);
+            resolve(result);
+        } catch (e) {
+            console.error("Editor closed with error.");
+            fs.unlinkSync(tmpFile);
+            resolve(initialText);
+        }
+    });
+}
+
+async function interactiveLoop(initialResult, type) {
+    let currentResult = initialResult;
+
+    while (true) {
+        console.log("\n" + "=".repeat(40));
+        console.log(`\x1b[36mSuggested ${type}:\x1b[0m\n`);
+        console.log(currentResult);
+        console.log("=".repeat(40) + "\n");
+
+        const answer = await question("Choose action: \x1b[32m[A]ccept\x1b[0m, \x1b[33m[E]dit\x1b[0m, \x1b[34m[R]egenerate\x1b[0m, \x1b[31m[C]ancel\x1b[0m : ");
+
+        const mode = answer.trim().toUpperCase();
+
+        if (mode === "A") {
+            return currentResult;
+        } else if (mode === "C") {
+            console.log("Cancelled.");
+            process.exit(0);
+        } else if (mode === "E") {
+            currentResult = await editInteractively(currentResult);
+        } else if (mode === "R") {
+            console.log("\nRegenerating...");
+            return "REGENERATE";
+        } else {
+            console.log("Invalid option. Please type A, E, R, or C.");
+        }
+    }
+}
+
+async function handleCommit() {
+    const diff = getStagedDiff();
+    if (!diff) {
+        console.log("No staged changes found. Use `git add` to stage files.");
+        process.exit(0);
+    }
+
+    const branch = getCurrentBranch();
+
+    while (true) {
+        console.log("\nAnalyzing staged diff...");
+        const result = await generateAIResponse([
+            { role: "system", content: COMMIT_SYSTEM_PROMPT },
+            { role: "user", content: `Branch: ${branch}\n\nDiff:\n${diff}` }
+        ]);
+
+        const finalAction = await interactiveLoop(result, "Commit Message");
+
+        if (finalAction !== "REGENERATE") {
+            applyCommit(finalAction);
+            console.log("\n\x1b[32m✔ Commit applied successfully!\x1b[0m");
+            break;
+        }
+    }
+}
+
+async function handlePR() {
+    const commits = getBranchCommits();
+    if (!commits) {
+        console.log("No recent commits found distinct from main branch.");
+        process.exit(0);
+    }
+    const branch = getCurrentBranch();
+
+    while (true) {
+        console.log("\nAnalyzing recent commits...");
+        const result = await generateAIResponse([
+            { role: "system", content: PR_SYSTEM_PROMPT },
+            { role: "user", content: `Branch: ${branch}\n\nCommits:\n${commits}` }
+        ]);
+
+        const finalAction = await interactiveLoop(result, "PR Markdown Description");
+
+        if (finalAction !== "REGENERATE") {
+            console.log("\n\x1b[32mFinal PR Content:\x1b[0m\n");
+            console.log(finalAction);
+            console.log("\n(You can copy-paste the above into your pull request or we can pipe it to the clipboard later)");
+            break;
+        }
+    }
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0]?.toLowerCase();
+
+    if (cmd === "c" || cmd === "commit") {
+        await handleCommit();
+    } else if (cmd === "pr") {
+        await handlePR();
+    } else {
+        console.log(`
+\x1b[36mRYTE - AI Git Workflow Assistant\x1b[0m
+Author: Riflo
+
+Usage:
+  ryte c    Generate semantic commit from staged diff
+  ryte pr   Generate PR markdown description from branch commits
+
+Set GROQ_API_KEY (Free) or OPENAI_API_KEY environment variable.
+        `);
+    }
+
+    rl.close();
+}
+
+main().catch(err => {
+    console.error("Unhandled error:", err);
+    process.exit(1);
+});

package/src/prompt.js

@@ -0,0 +1,52 @@
+export const COMMIT_SYSTEM_PROMPT = `
+You are an expert developer assistant specialized in Git workflows and the Conventional Commits specification.
+Your goal is to generate a concise, meaningful, and technically accurate commit message based on provided git diffs.
+
+RULES:
+1. OUTPUT ONLY THE COMMIT MESSAGE. No markdown, no "Here is your commit", no backticks.
+2. Follow Conventional Commits: <type>(<scope>): <subject>
+3. Use types: feat (new feature), fix (bug fix), docs (documentation), style (formatting), refactor (code cleanup), perf (performance), test (adding tests), chore (maintenance).
+4. Subject line:
+   - Use imperative mood ("add", not "adds" or "added").
+   - Max 50 characters.
+   - Do not end with a period.
+   - Focus on the "why" or the core "what", not every trivial change.
+5. Breaking Changes: If the diff shows breaking changes, use "!" after the type (e.g., "feat!: delete deprecated api").
+6. Scope: If the diff is localized, infer a scope (e.g., "auth", "ui", "config").
+7. Body (Optional): If the change is complex, add a brief body after 1 blank line to explain technical nuances.
+8. Context: If a branch name or ticket is provided, incorporate it into the scope or footer if applicable.
+
+Example:
+feat(ui): add loading state to checkout button
+`;
+
+export const PR_SYSTEM_PROMPT = `
+You are a technical writer for a high-performing engineering team. 
+Write a clear, professional Pull Request summary based on the provided commit history and branch context.
+
+OUTPUT STRUCTURE:
+# <Brief & Punchy PR Title>
+
+## 📋 Summary
+Provide a high-level overview (2-3 sentences) of what this PR solves. Focus on the value to the project.
+
+## 🚀 Key Changes
+- List the most important technical changes in bullet points.
+- Group related changes if possible.
+- Highlight any refactoring or performance improvements.
+
+## ⚠️ Important Notes/Impact
+- Mention any database migrations, new dependencies, or potential breaking changes.
+- If no critical impact, state "Standard incremental update".
+
+## 🔍 Reviewer Checklist
+- [ ] Logic health & edge cases
+- [ ] Performance considerations
+- [ ] Code style & standard conformity
+
+INSTRUCTIONS:
+- Use clean Markdown.
+- DO NOT use markdown code block wrappers ( \`\`\` ) for the whole output.
+- Be objective and technical.
+- No conversational filler.
+`;