bsy-clippy 0.1.0__tar.gz

bsy_clippy-0.1.0/LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

bsy_clippy-0.1.0/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: bsy-clippy
+Version: 0.1.0
+Summary: Terminal client for interacting with an Ollama server
+Author: Sebas
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.28
+Dynamic: license-file
+
+# bsy-clippy
+
+`bsy-clippy` is a lightweight Python client for interacting with an [Ollama](https://ollama.ai) server.  
+
+It supports both **batch (stdin) mode** for one-shot prompts and **interactive mode** for chatting directly in the terminal.  
+You can also load **system prompts** from a file to guide the LLM’s behavior.
+
+---
+
+## Features
+
+- Connects to Ollama API over HTTP (`/api/generate`).
+- Defaults to:
+  - IP: `172.20.0.100`
+  - Port: `11434`
+  - Model: `qwen3:1.7b`
+  - Mode: `batch` (wait for full output)
+  - Bundled system prompt file that can be overridden with `--system-file`
+- Configurable parameters:
+  - `-i` / `--ip` → Ollama server IP
+  - `-p` / `--port` → Ollama server port
+  - `-M` / `--model` → model name
+  - `-m` / `--mode` → output mode (`stream` or `batch`)
+  - `-t` / `--temperature` → sampling temperature (default: `0.7`)
+  - `-s` / `--system-file` → path to a text file with system instructions
+  - `-u` / `--user-prompt` → extra user instructions prepended before the data payload
+  - `-r` / `--memory-lines` → number of conversation lines to remember in interactive mode
+  - `-c` / `--chat-after-stdin` → process stdin once, then drop into interactive chat
+- Two modes of operation:
+  - **Batch mode** (default) → waits until the answer is complete, then prints only the final result.
+  - **Stream mode** → shows response in real-time, tokens appear as they are generated.
+- Colored terminal output:
+  - **Yellow** = streaming tokens (the model’s “thinking” in progress).
+  - **Default terminal color** = final assembled answer.
+
+---
+
+## Installation
+
+### pipx (recommended)
+
+```bash
+pipx install .
+```
+
+After updating the source, reinstall with `pipx reinstall bsy-clippy`.
+
+### pip / virtual environments
+
+```bash
+pip install .
+```
+
+---
+
+## Usage
+
+### System prompt file
+
+By default, `bsy-clippy` loads a bundled prompt (`Be very brief. Be very short.`).  
+You can change this with `--system-file` or disable it via `--no-default-system`.
+
+Example **bsy-clippy.txt**:
+
+```
+You are a helpful assistant specialized in cybersecurity.
+Always explain your reasoning clearly, and avoid unnecessary markdown formatting.
+```
+
+These lines will be sent to the LLM before every user prompt.
+
+### User prompt parameter
+
+Use `--user-prompt "Classify the following log:"` when piping data so the model receives:
+
+```
+system prompt (if any)
+
+user prompt text
+
+data from stdin or interactive input
+```
+
+### Interactive memory
+
+Set `--memory-lines 6` (or `-r 6`) to keep the last six conversation lines (user + assistant) while chatting.  
+Only the final assistant reply (not the thinking traces) is stored and sent back on the next turn.
+
+### Chat after stdin
+
+Use `-c` / `--chat-after-stdin` to process piped data first and then remain in interactive mode with the response (and any configured memory) available:
+
+```bash
+cat sample.txt | bsy-clippy -u "Summarize this report" -r 6 -c
+```
+
+After the initial answer prints, you can continue the conversation while the tool remembers the piped data and the model’s reply.
+
+---
+
+### Interactive mode (default = batch)
+
+Run without piping input:
+
+```bash
+bsy-clippy
+```
+
+Example session in **batch mode**:
+
+```
+You: Hello!
+Hello! How can I assist you today? 😊
+```
+
+To force **streaming mode**:
+
+```bash
+bsy-clippy --mode stream
+```
+
+Streaming session looks like:
+
+```
+You: Hello!
+LLM (thinking): <think>
+Reasoning step by step...
+</think>
+Hello! How can I assist you today? 😊
+```
+
+---
+
+### Batch mode (stdin)
+
+Pipe input directly:
+
+```bash
+echo "Tell me a joke" | bsy-clippy
+```
+
+Output:
+
+```
+Why don’t scientists trust atoms? Because they make up everything!
+```
+
+---
+
+### Forcing modes
+
+```bash
+bsy-clippy --mode batch
+bsy-clippy --mode stream
+```
+
+---
+
+### Adjusting temperature
+
+```bash
+bsy-clippy --temperature 0.2
+bsy-clippy --temperature 1.2
+```
+
+---
+
+### Custom server and model
+
+```bash
+bsy-clippy --ip 127.0.0.1 --port 11434 --model llama2
+```
+
+---
+
+## Requirements
+
+See [`requirements.txt`](requirements.txt).

bsy_clippy-0.1.0/README.md

@@ -0,0 +1,178 @@
+# bsy-clippy
+
+`bsy-clippy` is a lightweight Python client for interacting with an [Ollama](https://ollama.ai) server.  
+
+It supports both **batch (stdin) mode** for one-shot prompts and **interactive mode** for chatting directly in the terminal.  
+You can also load **system prompts** from a file to guide the LLM’s behavior.
+
+---
+
+## Features
+
+- Connects to Ollama API over HTTP (`/api/generate`).
+- Defaults to:
+  - IP: `172.20.0.100`
+  - Port: `11434`
+  - Model: `qwen3:1.7b`
+  - Mode: `batch` (wait for full output)
+  - Bundled system prompt file that can be overridden with `--system-file`
+- Configurable parameters:
+  - `-i` / `--ip` → Ollama server IP
+  - `-p` / `--port` → Ollama server port
+  - `-M` / `--model` → model name
+  - `-m` / `--mode` → output mode (`stream` or `batch`)
+  - `-t` / `--temperature` → sampling temperature (default: `0.7`)
+  - `-s` / `--system-file` → path to a text file with system instructions
+  - `-u` / `--user-prompt` → extra user instructions prepended before the data payload
+  - `-r` / `--memory-lines` → number of conversation lines to remember in interactive mode
+  - `-c` / `--chat-after-stdin` → process stdin once, then drop into interactive chat
+- Two modes of operation:
+  - **Batch mode** (default) → waits until the answer is complete, then prints only the final result.
+  - **Stream mode** → shows response in real-time, tokens appear as they are generated.
+- Colored terminal output:
+  - **Yellow** = streaming tokens (the model’s “thinking” in progress).
+  - **Default terminal color** = final assembled answer.
+
+---
+
+## Installation
+
+### pipx (recommended)
+
+```bash
+pipx install .
+```
+
+After updating the source, reinstall with `pipx reinstall bsy-clippy`.
+
+### pip / virtual environments
+
+```bash
+pip install .
+```
+
+---
+
+## Usage
+
+### System prompt file
+
+By default, `bsy-clippy` loads a bundled prompt (`Be very brief. Be very short.`).  
+You can change this with `--system-file` or disable it via `--no-default-system`.
+
+Example **bsy-clippy.txt**:
+
+```
+You are a helpful assistant specialized in cybersecurity.
+Always explain your reasoning clearly, and avoid unnecessary markdown formatting.
+```
+
+These lines will be sent to the LLM before every user prompt.
+
+### User prompt parameter
+
+Use `--user-prompt "Classify the following log:"` when piping data so the model receives:
+
+```
+system prompt (if any)
+
+user prompt text
+
+data from stdin or interactive input
+```
+
+### Interactive memory
+
+Set `--memory-lines 6` (or `-r 6`) to keep the last six conversation lines (user + assistant) while chatting.  
+Only the final assistant reply (not the thinking traces) is stored and sent back on the next turn.
+
+### Chat after stdin
+
+Use `-c` / `--chat-after-stdin` to process piped data first and then remain in interactive mode with the response (and any configured memory) available:
+
+```bash
+cat sample.txt | bsy-clippy -u "Summarize this report" -r 6 -c
+```
+
+After the initial answer prints, you can continue the conversation while the tool remembers the piped data and the model’s reply.
+
+---
+
+### Interactive mode (default = batch)
+
+Run without piping input:
+
+```bash
+bsy-clippy
+```
+
+Example session in **batch mode**:
+
+```
+You: Hello!
+Hello! How can I assist you today? 😊
+```
+
+To force **streaming mode**:
+
+```bash
+bsy-clippy --mode stream
+```
+
+Streaming session looks like:
+
+```
+You: Hello!
+LLM (thinking): <think>
+Reasoning step by step...
+</think>
+Hello! How can I assist you today? 😊
+```
+
+---
+
+### Batch mode (stdin)
+
+Pipe input directly:
+
+```bash
+echo "Tell me a joke" | bsy-clippy
+```
+
+Output:
+
+```
+Why don’t scientists trust atoms? Because they make up everything!
+```
+
+---
+
+### Forcing modes
+
+```bash
+bsy-clippy --mode batch
+bsy-clippy --mode stream
+```
+
+---
+
+### Adjusting temperature
+
+```bash
+bsy-clippy --temperature 0.2
+bsy-clippy --temperature 1.2
+```
+
+---
+
+### Custom server and model
+
+```bash
+bsy-clippy --ip 127.0.0.1 --port 11434 --model llama2
+```
+
+---
+
+## Requirements
+
+See [`requirements.txt`](requirements.txt).

bsy_clippy-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bsy-clippy"
+version = "0.1.0"
+description = "Terminal client for interacting with an Ollama server"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    { name = "Sebas" }
+]
+dependencies = [
+    "requests>=2.28,<3",
+]
+
+[project.scripts]
+"bsy-clippy" = "bsy_clippy.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"bsy_clippy" = ["data/*.txt"]

bsy_clippy-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bsy_clippy-0.1.0/src/bsy_clippy/__init__.py

@@ -0,0 +1,5 @@
+"""bsy-clippy package for interacting with the Ollama API."""
+
+from .cli import main
+
+__all__ = ["main"]

bsy_clippy-0.1.0/src/bsy_clippy/cli.py

@@ -0,0 +1,409 @@
+"""Command-line interface for the bsy-clippy Ollama client."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from importlib import resources
+from pathlib import Path
+from typing import IO, Iterable, List, Optional, Sequence, Tuple
+
+import requests
+
+YELLOW = "\033[93m"
+ANSWER_COLOR = "\033[96m"
+RESET = "\033[0m"
+
+_DEFAULT_SYSTEM_PROMPT = "data/bsy-clippy.txt"
+
+
+def _read_default_system_prompt() -> str:
+    """Return the packaged default system prompt if it exists."""
+    try:
+        prompt_path = resources.files("bsy_clippy").joinpath(_DEFAULT_SYSTEM_PROMPT)
+    except (FileNotFoundError, ModuleNotFoundError, AttributeError):
+        return ""
+
+    try:
+        return prompt_path.read_text(encoding="utf-8").strip("\n")
+    except OSError:
+        return ""
+
+
+def load_system_prompt(path: Optional[str], allow_default: bool = True) -> str:
+    """Return the content of a system prompt file, or the packaged default."""
+    if path:
+        file_path = Path(path)
+        if not file_path.exists():
+            return _read_default_system_prompt() if allow_default else ""
+        try:
+            return file_path.read_text(encoding="utf-8").strip("\n")
+        except OSError as exc:
+            print(f"[Warning] Could not read system prompt file '{path}': {exc}", file=sys.stderr)
+            return ""
+    if allow_default:
+        return _read_default_system_prompt()
+    return ""
+
+
+def compose_prompt(system_prompt: str, user_prompt: str, data: str) -> str:
+    """Combine system prompt, user prompt, and data into a single message."""
+    parts: List[str] = []
+    for part in (system_prompt, user_prompt, data):
+        if part and part.strip():
+            parts.append(part.strip("\n"))
+    return "\n\n".join(parts)
+
+
+def strip_think_segments(text: str) -> str:
+    """Return text with <think> sections removed."""
+    if not text:
+        return ""
+
+    result: List[str] = []
+    idx = 0
+    in_think = False
+
+    while idx < len(text):
+        if in_think:
+            close_idx = text.find("</think>", idx)
+            if close_idx == -1:
+                break
+            idx = close_idx + len("</think>")
+            in_think = False
+        else:
+            open_idx = text.find("<think>", idx)
+            if open_idx == -1:
+                result.append(text[idx:])
+                break
+
+            if open_idx > idx:
+                result.append(text[idx:open_idx])
+            idx = open_idx + len("<think>")
+            in_think = True
+
+    return "".join(result).strip()
+
+
+def colorize_response(text: str) -> str:
+    """Return the response string with ANSI colors applied to think segments."""
+    if not text:
+        return ""
+
+    idx = 0
+    in_think = False
+    output: List[str] = []
+
+    while idx < len(text):
+        if in_think:
+            close_idx = text.find("</think>", idx)
+            if close_idx == -1:
+                output.append(f"{YELLOW}{text[idx:]}{RESET}")
+                break
+
+            if close_idx > idx:
+                output.append(f"{YELLOW}{text[idx:close_idx]}{RESET}")
+            output.append(f"{YELLOW}</think>{RESET}")
+            idx = close_idx + len("</think>")
+            in_think = False
+        else:
+            open_idx = text.find("<think>", idx)
+            if open_idx == -1:
+                output.append(f"{ANSWER_COLOR}{text[idx:]}{RESET}")
+                break
+
+            if open_idx > idx:
+                output.append(f"{ANSWER_COLOR}{text[idx:open_idx]}{RESET}")
+            output.append(f"{YELLOW}<think>{RESET}")
+            idx = open_idx + len("<think>")
+            in_think = True
+
+    return "".join(output)
+
+
+def print_stream_chunk(text: str, in_think: bool) -> Tuple[bool, str]:
+    """Stream a chunk of text with think/final color separation."""
+    idx = 0
+    final_parts: List[str] = []
+    while idx < len(text):
+        if in_think:
+            close_idx = text.find("</think>", idx)
+            if close_idx == -1:
+                segment = text[idx:]
+                if segment:
+                    print(f"{YELLOW}{segment}{RESET}", end="", flush=True)
+                idx = len(text)
+            else:
+                segment = text[idx:close_idx]
+                if segment:
+                    print(f"{YELLOW}{segment}{RESET}", end="", flush=True)
+                print(f"{YELLOW}</think>{RESET}", end="", flush=True)
+                idx = close_idx + len("</think>")
+                in_think = False
+        else:
+            open_idx = text.find("<think>", idx)
+            if open_idx == -1:
+                segment = text[idx:]
+                if segment:
+                    print(f"{ANSWER_COLOR}{segment}{RESET}", end="", flush=True)
+                    final_parts.append(segment)
+                idx = len(text)
+            else:
+                segment = text[idx:open_idx]
+                if segment:
+                    print(f"{ANSWER_COLOR}{segment}{RESET}", end="", flush=True)
+                    final_parts.append(segment)
+                print(f"{YELLOW}<think>{RESET}", end="", flush=True)
+                idx = open_idx + len("<think>")
+                in_think = True
+    return in_think, "".join(final_parts)
+
+
+def call_ollama_batch(api_url: str, model: str, prompt: str, temperature: float) -> Tuple[str, str]:
+    """Send a prompt to Ollama API and return response text (batch mode)."""
+    try:
+        response = requests.post(
+            f"{api_url}/api/generate",
+            json={
+                "model": model,
+                "prompt": prompt,
+                "temperature": temperature,
+            },
+            stream=True,
+            timeout=600,
+        )
+        response.raise_for_status()
+
+        output: List[str] = []
+        for line in response.iter_lines():
+            if line:
+                try:
+                    data = json.loads(line.decode("utf-8"))
+                    output.append(data.get("response", ""))
+                except Exception:
+                    pass
+        raw_text = "".join(output)
+        return colorize_response(raw_text), strip_think_segments(raw_text)
+
+    except requests.RequestException as exc:
+        error_text = f"[Error contacting Ollama API: {exc}]"
+        return error_text, ""
+
+
+def call_ollama_stream(api_url: str, model: str, prompt: str, temperature: float) -> str:
+    """Send a prompt to Ollama API and stream response with color separation."""
+    try:
+        response = requests.post(
+            f"{api_url}/api/generate",
+            json={
+                "model": model,
+                "prompt": prompt,
+                "temperature": temperature,
+            },
+            stream=True,
+            timeout=600,
+        )
+        response.raise_for_status()
+
+        in_think = False
+        final_parts: List[str] = []
+        for line in response.iter_lines():
+            if line:
+                try:
+                    data = json.loads(line.decode("utf-8"))
+                    text = data.get("response", "")
+                    if text:
+                        in_think, segment = print_stream_chunk(text, in_think)
+                        if segment:
+                            final_parts.append(segment)
+
+                    if data.get("done", False):
+                        break
+                except Exception:
+                    continue
+        print()
+        return strip_think_segments("".join(final_parts))
+
+    except requests.RequestException as exc:
+        print(f"[Error contacting Ollama API: {exc}]")
+        return ""
+
+
+def read_user_input(prompt_text: str, input_stream: Optional[IO[str]]) -> str:
+    """Read a line of input, supporting non-tty streams."""
+    if input_stream is None:
+        return input(prompt_text)
+
+    print(prompt_text, end="", flush=True)
+    line = input_stream.readline()
+    if not line:
+        raise EOFError
+    return line.rstrip("\r\n")
+
+
+def interactive_mode(
+    api_url: str,
+    model: str,
+    mode: str,
+    temperature: float,
+    system_prompt: str,
+    user_prompt: str,
+    memory_lines: int,
+    memory_seed: Optional[Sequence[str]] = None,
+    input_stream: Optional[IO[str]] = None,
+) -> None:
+    """Interactive chat mode with selectable output mode."""
+    print(f"Interactive mode with model '{model}' at {api_url}")
+    print(f"Mode: {mode}, Temperature: {temperature}")
+    print("Type 'exit' or Ctrl+C to quit.")
+    memory: List[str] = list(memory_seed) if memory_seed else []
+    if memory_lines > 0 and memory:
+        memory[:] = memory[-memory_lines:]
+    local_stream = input_stream
+    close_stream = False
+    if local_stream is None:
+        if sys.stdin.isatty():
+            local_stream = None
+        else:
+            tty_paths = ["CONIN$"] if os.name == "nt" else ["/dev/tty"]
+            for path in tty_paths:
+                try:
+                    local_stream = open(path, "r", encoding="utf-8", errors="ignore")
+                    close_stream = True
+                    break
+                except OSError:
+                    local_stream = None
+            if local_stream is None and sys.stdin.isatty():
+                local_stream = None
+            elif local_stream is None:
+                local_stream = sys.stdin
+
+    try:
+        while True:
+            try:
+                prompt = read_user_input("You: ", local_stream)
+            except EOFError:
+                if local_stream is sys.stdin and not sys.stdin.isatty():
+                    print("\n[Warning] No interactive input available; exiting.")
+                else:
+                    print("\nExiting.")
+                break
+            except KeyboardInterrupt:
+                print("\nExiting.")
+                break
+
+            user_text = prompt.strip()
+            if user_text.lower() in {"exit", "quit"}:
+                break
+            history_block = ""
+            if memory:
+                history_block = "History of Past Interaction:\n" + "\n".join(memory)
+
+            current_block = ""
+            if user_text:
+                current_block = f"Current User Message:\n{user_text}"
+
+            conversation_parts = [part for part in (history_block, current_block) if part]
+            conversation_input = "\n\n".join(conversation_parts)
+            final_prompt = compose_prompt(system_prompt, user_prompt, conversation_input)
+            if not final_prompt:
+                continue
+            final_text = ""
+            if mode == "stream":
+                print("LLM (thinking): ", end="", flush=True)
+                final_text = call_ollama_stream(api_url, model, final_prompt, temperature)
+            else:
+                response_text, final_text = call_ollama_batch(api_url, model, final_prompt, temperature)
+                print(response_text)
+
+            if memory_lines > 0:
+                if user_text:
+                    memory.append(f"User: {user_text}")
+                if final_text:
+                    memory.append(f"Assistant: {final_text.strip()}")
+                if len(memory) > memory_lines:
+                    memory[:] = memory[-memory_lines:]
+    finally:
+        if close_stream and local_stream not in {None, sys.stdin}:
+            try:
+                local_stream.close()
+            except OSError:
+                pass
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Create the argument parser for the CLI."""
+    parser = argparse.ArgumentParser(description="bsy-clippy: Ollama API Client")
+    parser.add_argument("-i", "--ip", default="172.20.0.100", help="Ollama server IP (default: 172.20.0.100)")
+    parser.add_argument("-p", "--port", default="11434", help="Ollama server port (default: 11434)")
+    parser.add_argument("-M", "--model", default="qwen3:1.7b", help="Model name (default: qwen3:1.7b)")
+    parser.add_argument("-m", "--mode", choices=["stream", "batch"], default="stream", help="Output mode: 'stream' = real-time, 'batch' = wait for final output")
+    parser.add_argument("-t", "--temperature", type=float, default=0.7, help="Sampling temperature (default: 0.7, higher = more random)")
+    parser.add_argument(
+        "-s",
+        "--system-file",
+        default=None,
+        help="Path to a system prompt file (default: packaged prompt)",
+    )
+    parser.add_argument("-u", "--user-prompt", default="", help="Additional user instructions to prepend before the data")
+    parser.add_argument("-r", "--memory-lines", type=int, default=0, help="Remember this many lines of conversation in interactive mode")
+    parser.add_argument("-c", "--chat-after-stdin", action="store_true", help="After processing stdin, continue in interactive chat mode")
+    parser.add_argument("--no-default-system", action="store_true", help="Disable the packaged default system prompt")
+    return parser
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    api_url = f"http://{args.ip}:{args.port}"
+    allow_default = not args.no_default_system
+    system_prompt = load_system_prompt(args.system_file, allow_default=allow_default)
+    user_prompt = args.user_prompt
+    memory_lines = max(0, args.memory_lines)
+    chat_after_stdin = args.chat_after_stdin
+
+    mode = args.mode
+    if mode is None:
+        if not sys.stdin.isatty():
+            mode = "batch"
+        else:
+            mode = "stream"
+
+    if not sys.stdin.isatty():
+        data = sys.stdin.read()
+        full_prompt = compose_prompt(system_prompt, user_prompt, data)
+
+        if not full_prompt:
+            interactive_mode(api_url, args.model, mode, args.temperature, system_prompt, user_prompt, memory_lines)
+            return
+
+        memory_seed: List[str] = []
+        data_text = data.strip()
+        if data_text:
+            memory_seed.append(f"User: {data_text}")
+
+        final_text = ""
+        if mode == "stream":
+            final_text = call_ollama_stream(api_url, args.model, full_prompt, args.temperature)
+        else:
+            response_text, final_text = call_ollama_batch(api_url, args.model, full_prompt, args.temperature)
+            print(response_text)
+        if chat_after_stdin:
+            if final_text:
+                memory_seed.append(f"Assistant: {final_text.strip()}")
+            if memory_lines > 0 and memory_seed:
+                memory_seed = memory_seed[-memory_lines:]
+            interactive_mode(
+                api_url,
+                args.model,
+                mode,
+                args.temperature,
+                system_prompt,
+                user_prompt,
+                memory_lines,
+                memory_seed if memory_seed else None,
+            )
+        return
+
+    interactive_mode(api_url, args.model, mode, args.temperature, system_prompt, user_prompt, memory_lines)

bsy_clippy-0.1.0/src/bsy_clippy/data/bsy-clippy.txt

@@ -0,0 +1,2 @@
+Be very brief.
+Be very short.

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/PKG-INFO

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: bsy-clippy
+Version: 0.1.0
+Summary: Terminal client for interacting with an Ollama server
+Author: Sebas
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.28
+Dynamic: license-file
+
+# bsy-clippy
+
+`bsy-clippy` is a lightweight Python client for interacting with an [Ollama](https://ollama.ai) server.  
+
+It supports both **batch (stdin) mode** for one-shot prompts and **interactive mode** for chatting directly in the terminal.  
+You can also load **system prompts** from a file to guide the LLM’s behavior.
+
+---
+
+## Features
+
+- Connects to Ollama API over HTTP (`/api/generate`).
+- Defaults to:
+  - IP: `172.20.0.100`
+  - Port: `11434`
+  - Model: `qwen3:1.7b`
+  - Mode: `batch` (wait for full output)
+  - Bundled system prompt file that can be overridden with `--system-file`
+- Configurable parameters:
+  - `-i` / `--ip` → Ollama server IP
+  - `-p` / `--port` → Ollama server port
+  - `-M` / `--model` → model name
+  - `-m` / `--mode` → output mode (`stream` or `batch`)
+  - `-t` / `--temperature` → sampling temperature (default: `0.7`)
+  - `-s` / `--system-file` → path to a text file with system instructions
+  - `-u` / `--user-prompt` → extra user instructions prepended before the data payload
+  - `-r` / `--memory-lines` → number of conversation lines to remember in interactive mode
+  - `-c` / `--chat-after-stdin` → process stdin once, then drop into interactive chat
+- Two modes of operation:
+  - **Batch mode** (default) → waits until the answer is complete, then prints only the final result.
+  - **Stream mode** → shows response in real-time, tokens appear as they are generated.
+- Colored terminal output:
+  - **Yellow** = streaming tokens (the model’s “thinking” in progress).
+  - **Default terminal color** = final assembled answer.
+
+---
+
+## Installation
+
+### pipx (recommended)
+
+```bash
+pipx install .
+```
+
+After updating the source, reinstall with `pipx reinstall bsy-clippy`.
+
+### pip / virtual environments
+
+```bash
+pip install .
+```
+
+---
+
+## Usage
+
+### System prompt file
+
+By default, `bsy-clippy` loads a bundled prompt (`Be very brief. Be very short.`).  
+You can change this with `--system-file` or disable it via `--no-default-system`.
+
+Example **bsy-clippy.txt**:
+
+```
+You are a helpful assistant specialized in cybersecurity.
+Always explain your reasoning clearly, and avoid unnecessary markdown formatting.
+```
+
+These lines will be sent to the LLM before every user prompt.
+
+### User prompt parameter
+
+Use `--user-prompt "Classify the following log:"` when piping data so the model receives:
+
+```
+system prompt (if any)
+
+user prompt text
+
+data from stdin or interactive input
+```
+
+### Interactive memory
+
+Set `--memory-lines 6` (or `-r 6`) to keep the last six conversation lines (user + assistant) while chatting.  
+Only the final assistant reply (not the thinking traces) is stored and sent back on the next turn.
+
+### Chat after stdin
+
+Use `-c` / `--chat-after-stdin` to process piped data first and then remain in interactive mode with the response (and any configured memory) available:
+
+```bash
+cat sample.txt | bsy-clippy -u "Summarize this report" -r 6 -c
+```
+
+After the initial answer prints, you can continue the conversation while the tool remembers the piped data and the model’s reply.
+
+---
+
+### Interactive mode (default = batch)
+
+Run without piping input:
+
+```bash
+bsy-clippy
+```
+
+Example session in **batch mode**:
+
+```
+You: Hello!
+Hello! How can I assist you today? 😊
+```
+
+To force **streaming mode**:
+
+```bash
+bsy-clippy --mode stream
+```
+
+Streaming session looks like:
+
+```
+You: Hello!
+LLM (thinking): <think>
+Reasoning step by step...
+</think>
+Hello! How can I assist you today? 😊
+```
+
+---
+
+### Batch mode (stdin)
+
+Pipe input directly:
+
+```bash
+echo "Tell me a joke" | bsy-clippy
+```
+
+Output:
+
+```
+Why don’t scientists trust atoms? Because they make up everything!
+```
+
+---
+
+### Forcing modes
+
+```bash
+bsy-clippy --mode batch
+bsy-clippy --mode stream
+```
+
+---
+
+### Adjusting temperature
+
+```bash
+bsy-clippy --temperature 0.2
+bsy-clippy --temperature 1.2
+```
+
+---
+
+### Custom server and model
+
+```bash
+bsy-clippy --ip 127.0.0.1 --port 11434 --model llama2
+```
+
+---
+
+## Requirements
+
+See [`requirements.txt`](requirements.txt).

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/bsy_clippy/__init__.py
+src/bsy_clippy/cli.py
+src/bsy_clippy.egg-info/PKG-INFO
+src/bsy_clippy.egg-info/SOURCES.txt
+src/bsy_clippy.egg-info/dependency_links.txt
+src/bsy_clippy.egg-info/entry_points.txt
+src/bsy_clippy.egg-info/requires.txt
+src/bsy_clippy.egg-info/top_level.txt
+src/bsy_clippy/data/bsy-clippy.txt

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bsy-clippy = bsy_clippy.cli:main

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/requires.txt

@@ -0,0 +1 @@
+requests<3,>=2.28

bsy_clippy-0.1.0/src/bsy_clippy.egg-info/top_level.txt

@@ -0,0 +1 @@
+bsy_clippy