curl-programming-lang 1.2.1__tar.gz → 1.4.0__tar.gz

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: curl-programming-lang
-Version: 1.2.1
+Version: 1.4.0
 Summary: Curl is an open-source programming language built on Python technology
 Author: Ritvik Gautam
 License: Apache-2.0

curl_programming_lang-1.4.0/ai_module.py

@@ -0,0 +1,159 @@
+import os
+import json
+import urllib.request
+import urllib.error
+
+_DEFAULT_SYSTEM = (
+    "You are Curl-Bot, an AI assistant built into the Curl programming language. "
+    "Curl is an open-source language created by Ritvik Gautam that runs on Python. "
+    "You are helpful, concise, and friendly."
+)
+
+# Auto-compact after this many user+assistant message pairs in history
+_COMPACT_THRESHOLD = 20
+
+
+class CurlAIModule:
+    """
+    AI standard library for Curl.
+
+    Configuration via environment variables:
+      CURL_AI_KEY or OPENAI_API_KEY  — API key (not needed for local models)
+      CURL_AI_BASE_URL               — base URL (default: https://api.openai.com/v1)
+                                       set to http://localhost:11434/v1 for Ollama
+      CURL_AI_MODEL                  — model name (default: gpt-4o-mini)
+
+    Usage in Curl:
+      import{"ai", ai}\
+      ai.context{"You are a pirate who only speaks in rhymes."}\
+      var{answer, ai.ask{"What is the capital of France?"}}\
+      pcType{var{answer}}\
+    """
+
+    def __init__(self):
+        self._system = _DEFAULT_SYSTEM
+        self._history = []  # list of {"role": ..., "content": ...}
+
+    def context(self, prompt):
+        """Set a persistent system prompt (persona/context) for all subsequent AI calls."""
+        self._system = str(prompt)
+        self._history = []  # reset history when context changes
+        return ""
+
+    def reset(self, _=""):
+        """Clear conversation history (start a fresh chat while keeping context)."""
+        self._history = []
+        return ""
+
+    def _raw_request(self, messages):
+        """Send a messages list to the API and return the reply string."""
+        api_key = os.environ.get("CURL_AI_KEY") or os.environ.get("OPENAI_API_KEY", "")
+        base_url = os.environ.get("CURL_AI_BASE_URL", "https://api.openai.com/v1").rstrip("/")
+        model = os.environ.get("CURL_AI_MODEL", "gpt-4o-mini")
+
+        if not api_key and "openai.com" in base_url:
+            raise RuntimeError(
+                "No API key found. Set CURL_AI_KEY (or OPENAI_API_KEY) in your environment.\n"
+                "For a free local model, install Ollama (https://ollama.com), run a model, then set:\n"
+                "  export CURL_AI_BASE_URL=http://localhost:11434/v1\n"
+                "  export CURL_AI_MODEL=llama3.2"
+            )
+
+        payload = json.dumps({
+            "model": model,
+            "messages": messages,
+            "temperature": 0.7,
+        }).encode()
+
+        headers = {"Content-Type": "application/json"}
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+
+        req = urllib.request.Request(
+            f"{base_url}/chat/completions",
+            data=payload,
+            headers=headers,
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                result = json.loads(resp.read())
+                return result["choices"][0]["message"]["content"].strip()
+        except urllib.error.HTTPError as e:
+            body = e.read().decode(errors="ignore")
+            raise RuntimeError(f"AI request failed ({e.code}): {body}")
+        except urllib.error.URLError as e:
+            raise RuntimeError(f"AI connection failed: {e.reason}")
+
+    def _compact_history(self):
+        """Summarize old history into a single assistant message to stay within limits."""
+        summary_messages = [
+            {"role": "system", "content": self._system},
+            {
+                "role": "user",
+                "content": (
+                    "Summarize the following conversation history into 3-5 bullet points "
+                    "so it can be used as context going forward. Be concise.\n\n"
+                    + "\n".join(
+                        f"{m['role'].upper()}: {m['content']}" for m in self._history
+                    )
+                ),
+            },
+        ]
+        summary = self._raw_request(summary_messages)
+        self._history = [{"role": "assistant", "content": f"[Previous conversation summary]\n{summary}"}]
+
+    def _request(self, prompt):
+        """Send prompt with history, auto-compact when history is too long."""
+        if len(self._history) >= _COMPACT_THRESHOLD:
+            self._compact_history()
+
+        self._history.append({"role": "user", "content": str(prompt)})
+
+        messages = [{"role": "system", "content": self._system}] + self._history
+        reply = self._raw_request(messages)
+
+        self._history.append({"role": "assistant", "content": reply})
+        return reply
+
+    def ask(self, prompt):
+        """Send a prompt (with conversation history) and return the response."""
+        return self._request(prompt)
+
+    def summarize(self, text):
+        """Summarize text in 2-3 sentences (no history tracking)."""
+        messages = [
+            {"role": "system", "content": self._system},
+            {"role": "user", "content": f"Summarize the following in 2-3 sentences:\n\n{text}"},
+        ]
+        return self._raw_request(messages)
+
+    def analyze(self, text):
+        """Analyze text and return key insights (no history tracking)."""
+        messages = [
+            {"role": "system", "content": self._system},
+            {"role": "user", "content": f"Analyze the following and provide key insights:\n\n{text}"},
+        ]
+        return self._raw_request(messages)
+
+    def sentiment(self, text):
+        """Return the sentiment of text: positive, negative, or neutral (no history tracking)."""
+        messages = [
+            {"role": "system", "content": self._system},
+            {
+                "role": "user",
+                "content": (
+                    "What is the sentiment of this text? "
+                    "Reply with only one word: positive, negative, or neutral.\n\n" + text
+                ),
+            },
+        ]
+        return self._raw_request(messages)
+
+    def translate(self, text):
+        """Translate text — include the target language in the text itself (no history tracking)."""
+        messages = [
+            {"role": "system", "content": self._system},
+            {"role": "user", "content": f"Translate the following:\n\n{text}"},
+        ]
+        return self._raw_request(messages)

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/curl_programming_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: curl-programming-lang
-Version: 1.2.1
+Version: 1.4.0
 Summary: Curl is an open-source programming language built on Python technology
 Author: Ritvik Gautam
 License: Apache-2.0

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/curl_programming_lang.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+ai_module.py
 errors.py
 interpreter.py
 lexer.py

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/curl_programming_lang.egg-info/top_level.txt

@@ -1,3 +1,4 @@
+ai_module
 errors
 interpreter
 lexer

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/interpreter.py

@@ -1,4 +1,5 @@
 import importlib
+from ai_module import CurlAIModule
 
 
 def execute(ast, env=None):
@@ -54,11 +55,17 @@ def _exec_stmt(stmt, env):
         _exec_other(stmt["language"], stmt["code"], env)
 
     elif t == "import":
-        try:
-            mod = importlib.import_module(stmt["package"])
-            env["imports"][stmt["nickname"]] = mod
-        except ImportError as e:
-            raise ImportError(f"Could not import '{stmt['package']}': {e}")
+        if stmt["package"] == "ai":
+            env["imports"][stmt["nickname"]] = CurlAIModule()
+        else:
+            try:
+                mod = importlib.import_module(stmt["package"])
+                env["imports"][stmt["nickname"]] = mod
+            except ImportError as e:
+                raise ImportError(f"Could not import '{stmt['package']}': {e}")
+
+    elif t == "method_call":
+        _eval(stmt, env)  # execute and discard return value
 
     elif t == "ai":
         print(f"[pcAI — mode: {stmt['mode']} | {stmt['directions']}]")
@@ -124,6 +131,17 @@ def _eval(expr, env):
         _call_func(expr["name"], env)
         return None
 
+    if t == "method_call":
+        module_name = expr["module"]
+        method_name = expr["method"]
+        arg = _eval(expr["arg"], env)
+        if module_name not in env["imports"]:
+            raise NameError(f"'{module_name}' is not imported — use import{{\"ai\", {module_name}}}\\")
+        module = env["imports"][module_name]
+        if not hasattr(module, method_name):
+            raise AttributeError(f"'{module_name}' has no method '{method_name}'")
+        return getattr(module, method_name)(arg)
+
     raise RuntimeError(f"Unknown expression type: {t!r}")
 
 

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/lexer.py

@@ -15,6 +15,7 @@ GT = "GT"
 LTE = "LTE"
 GTE = "GTE"
 ASSIGN = "ASSIGN"
+DOT = "DOT"
 LBRACE = "LBRACE"
 RBRACE = "RBRACE"
 SEMICOLON = "SEMICOLON"
@@ -45,6 +46,7 @@ TOKEN_PATTERNS = [
     (TIMES,       r'\*'),
     (DIVIDE,      r'/'),
     (ASSIGN,      r'='),
+    (DOT,         r'\.'),
     (LBRACE,      r'\{'),
     (RBRACE,      r'\}'),
     (SEMICOLON,   r';'),

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/parser.py

@@ -2,7 +2,7 @@ from lexer import (
     KEYWORD, STRING, NUMBER, IDENTIFIER,
     PLUS, MINUS, TIMES, DIVIDE,
     EQ, NEQ, LT, GT, LTE, GTE,
-    LBRACE, RBRACE, SEMICOLON, COMMA, COLON, ARROW,
+    LBRACE, RBRACE, SEMICOLON, COMMA, COLON, ARROW, DOT,
     LINE_END, BLOCK_END, RAW_CODE
 )
 
@@ -19,6 +19,12 @@ class Parser:
             return self.tokens[self.pos]
         return None
 
+    def peek(self, offset=1):
+        idx = self.pos + offset
+        if idx < len(self.tokens):
+            return self.tokens[idx]
+        return None
+
     def consume(self, token_type, value=None):
         token = self.current()
         if token is None:
@@ -72,6 +78,10 @@ class Parser:
         if token is None:
             return None
 
+        # module.method{arg}\  — e.g. ai.ask{"prompt"}\
+        if token[0] == IDENTIFIER and self.peek() and self.peek()[0] == DOT:
+            return self.parse_method_call_stmt()
+
         if token[0] != KEYWORD:
             raise SyntaxError(f"Expected a Curl keyword, got {token[0]} {repr(token[1])}")
 
@@ -118,7 +128,7 @@ class Parser:
         if self.check(COMMA):
             # var{name, value}\  →  assignment
             self.consume(COMMA)
-            value = self.parse_expr()
+            value = self.parse_concat_expr()
             self.consume(RBRACE)
             self.consume(LINE_END)
             return {"type": "assign", "name": name, "value": value}
@@ -197,6 +207,16 @@ class Parser:
         self.consume(LINE_END)
         return {"type": "other_code", "language": lang, "code": code}
 
+    def parse_method_call_stmt(self):
+        module = self.consume(IDENTIFIER)[1]
+        self.consume(DOT)
+        method = self.consume(IDENTIFIER)[1]
+        self.consume(LBRACE)
+        arg = self.parse_concat_expr()
+        self.consume(RBRACE)
+        self.consume(LINE_END)
+        return {"type": "method_call", "module": module, "method": method, "arg": arg}
+
     def parse_import(self):
         self.consume(KEYWORD, "import")
         self.consume(LBRACE)
@@ -286,6 +306,19 @@ class Parser:
                 self.consume(RBRACE)
                 return {"type": "func_call_expr", "name": name}
 
+        # module.method{arg}  — e.g. ai.ask{"prompt"}
+        if token[0] == IDENTIFIER:
+            module = token[1]
+            self.pos += 1
+            if self.check(DOT):
+                self.consume(DOT)
+                method = self.consume(IDENTIFIER)[1]
+                self.consume(LBRACE)
+                arg = self.parse_concat_expr()
+                self.consume(RBRACE)
+                return {"type": "method_call", "module": module, "method": method, "arg": arg}
+            return {"type": "var_ref", "name": module}
+
         raise SyntaxError(f"Unexpected token in expression: {token[0]} {repr(token[1])}")
 
     def _parse_list_body(self):

{curl_programming_lang-1.2.1 → curl_programming_lang-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "curl-programming-lang"
-version = "1.2.1"
+version = "1.4.0"
 description = "Curl is an open-source programming language built on Python technology"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -29,4 +29,4 @@ Repository = "https://github.com/gautamritvik/Curl-Programming"
 curlang = "main:main"
 
 [tool.setuptools]
-py-modules = ["main", "lexer", "parser", "interpreter", "errors"]
+py-modules = ["main", "lexer", "parser", "interpreter", "errors", "ai_module"]