feat(cli): add example input support for JSON conversion

- Introduced `-e` option to accept JSON examples directly.
- Implemented `convert_example_to_schema` function for dynamic schema generation.
- Updated README with usage examples for new feature.

Author: atasoglu

README.md

@@ -50,6 +50,12 @@ and receiving free-form text, you can do this:
 ask2api -p "Where is the capital of France?" -sf schema.json
 ```
 
+Or pass an example directly without a schema file:
+
+```bash
+ask2api -p "Where is the capital of France?" -e '{"country": "string", "city": "string"}'
+```
+
 And get a structured API response:
 
 ```json
@@ -59,6 +65,44 @@ And get a structured API response:
 }
 ```
 
+For more complex structures with different data types:
+
+```bash
+ask2api -p "Analyze carbon element" -e '{
+  "symbol": "element symbol",
+  "atomic_number": 1234,
+  "atomic_weight": 12.34,
+  "is_metal": true,
+  "isotopes": ["name of the isotope"],
+  "properties": {
+    "melting_point": 1234.5,
+    "boiling_point": 2345.6,
+    "magnetic": true
+  }
+}'
+```
+
+Output:
+
+```
+{
+  "symbol": "C",
+  "atomic_number": 6,
+  "atomic_weight": 12.011,
+  "is_metal": false,
+  "isotopes": [
+    "C-12",
+    "C-13",
+    "C-14"
+  ],
+  "properties": {
+    "melting_point": 3550,
+    "boiling_point": 4827,
+    "magnetic": false
+  }
+}
+```
+
 ### Vision modality
 
 You can also analyze images and get structured JSON responses:

ask2api.py

@@ -10,6 +10,20 @@
 
 API_KEY = os.getenv("OPENAI_API_KEY")
 ENV_VAR_PREFIX = "ASK2API_"
+TYPE_HINTS = {
+    "string": "string",
+    "str": "string",
+    "number": "number",
+    "int": "integer",
+    "integer": "integer",
+    "float": "number",
+    "bool": "boolean",
+    "boolean": "boolean",
+    "array": "array",
+    "list": "array",
+    "object": "object",
+    "dict": "object",
+}
 
 
 @dataclass
@@ -91,6 +105,66 @@ def get_version():
         return "dev"
 
 
+def convert_example_to_schema(example, _cache=None):
+    """Convert a JSON example to a JSON Schema with memoization."""
+    if _cache is None:
+        _cache = {}
+
+    # Use id() for memoization key to handle nested structures
+    cache_key = id(example)
+    if cache_key in _cache:
+        return _cache[cache_key]
+
+    if isinstance(example, dict):
+        schema = {
+            "type": "object",
+            "properties": {},
+            "required": list(example.keys()),
+            "additionalProperties": False,
+        }
+
+        for key, value in example.items():
+            if isinstance(value, str):
+                schema["properties"][key] = {
+                    "type": TYPE_HINTS.get(value.lower(), "string")
+                }
+            elif isinstance(value, bool):
+                schema["properties"][key] = {"type": "boolean"}
+            elif isinstance(value, int):
+                schema["properties"][key] = {"type": "integer"}
+            elif isinstance(value, float):
+                schema["properties"][key] = {"type": "number"}
+            elif isinstance(value, list):
+                schema["properties"][key] = {
+                    "type": "array",
+                    "items": convert_example_to_schema(value[0], _cache)
+                    if value
+                    else {},
+                }
+            elif isinstance(value, dict):
+                schema["properties"][key] = convert_example_to_schema(value, _cache)
+            else:
+                schema["properties"][key] = {"type": "string"}
+
+        _cache[cache_key] = schema
+        return schema
+
+    elif isinstance(example, list):
+        schema = {
+            "type": "array",
+            "items": convert_example_to_schema(example[0], _cache) if example else {},
+        }
+        _cache[cache_key] = schema
+        return schema
+
+    else:
+        # Primitive types - use type() for faster checking
+        type_map = {str: "string", bool: "boolean", int: "integer", float: "number"}
+        schema = {"type": type_map.get(type(example), "string")}
+        _cache[cache_key] = schema
+        return schema
+
+
 def main():
     env_vars_help = """
 Environment Variables:
@@ -109,10 +183,15 @@ def main():
         required=True,
         help="Natural language prompt",
     )
-    parser.add_argument(
+    schema_group = parser.add_mutually_exclusive_group(required=True)
+    schema_group.add_argument(
+        "-e",
+        "--example",
+        help='JSON example as a string (e.g., \'{"country": "France", "city": "Paris"}\')',
+    )
+    schema_group.add_argument(
         "-sf",
         "--schema-file",
-        required=True,
         help="Path to JSON schema file",
     )
     parser.add_argument(
@@ -128,8 +207,13 @@ def main():
     )
     args = parser.parse_args()
 
-    with open(args.schema_file, "r", encoding="utf-8") as f:
-        schema = json.load(f)
+    # Load schema from file or parse from string
+    if args.schema_file:
+        with open(args.schema_file, "r", encoding="utf-8") as f:
+            schema = json.load(f)
+    else:
+        example = json.loads(args.example)
+        schema = convert_example_to_schema(example)
 
     system_prompt = """
     You are a JSON API engine.