logiglyph 0.1.0__tar.gz

logiglyph-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Augusto
+
+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.
+

logiglyph-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: logiglyph
+Version: 0.1.0
+Summary: Agglutinative language toolkit with logical symbols, translator, and font generator.
+Author: Augusto
+License-Expression: MIT
+Keywords: conlang,translator,font,agglutinative-language
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: g4f>=0.3.2.7
+Requires-Dist: fonttools>=4.56.0
+Dynamic: license-file
+
+# Agglutinative Language Toolkit
+
+This project bootstraps a synthetic agglutinative language with:
+
+- A GPT-powered dictionary generator and translator (`g4f` API)
+- A logical symbol system where glyph form encodes meaning + sound
+- A font generator that compiles symbols into a `.ttf` font
+
+## 1) Setup
+
+```powershell
+python -m venv .venv
+.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+pip install -e .
+```
+
+After editable install, you can use:
+
+- `logiglyph ...` (console command)
+- `python -m logiglyph ...`
+- `from logiglyph import LanguageModule`
+
+## 2) Generate dictionary
+
+```powershell
+python -m src.tool generate-dictionary --count 96 --out data/dictionary.json
+```
+
+This calls `g4f` (`gpt-5-mini`) and enriches each root with:
+
+- `semantic_class`
+- `onset`, `vowel`, `coda` (sound parts)
+- `symbol_id` (logical glyph key)
+- `char` (Private Use Area codepoint)
+
+If API output is malformed/unavailable, the tool falls back to deterministic local roots.
+
+## 3) Build font
+
+```powershell
+python -m src.tool build-font --dict data/dictionary.json --out dist/LogiGlyph.ttf
+```
+
+This creates:
+
+- `dist/LogiGlyph.ttf`
+- `dist/glyph_map.json`
+
+## 4) Translate text
+
+```powershell
+python -m src.tool translate --dict data/dictionary.json --text "the person builds a house"
+python -m src.tool translate --dict data/dictionary.json --text "" --reverse
+```
+
+## 5) Build specimen (visual check)
+
+```powershell
+python -m src.tool build-specimen --dict data/dictionary.json --font dist/LogiGlyph.ttf --out dist/specimen.html
+```
+
+Open `dist/specimen.html` in a browser. Keep `LogiGlyph.ttf` in the same folder so `@font-face` can load it.
+
+## Font rendering troubleshooting
+
+These symbols are in Private Use Area (`U+E100+`), so they only render when your app uses `LogiGlyph.ttf`.
+
+- Terminal/editor showing squares or fallback chars: set font family to include `LogiGlyph`.
+- Browser: use CSS `@font-face` and set `font-family: 'LogiGlyph'` on the target element.
+- Windows app: install `dist/LogiGlyph.ttf` and select that font in the control/widget.
+
+Example VS Code setting:
+
+```json
+{
+  "editor.fontFamily": "LogiGlyph, Consolas, 'Courier New', monospace"
+}
+```
+
+## Use as a Python module
+
+```python
+from logiglyph import LanguageModule
+
+lang = LanguageModule("data/dictionary.json")
+res = lang.translate("person_0 house_1 water_2")
+print(res.text)        # e.g.   
+print(res.codepoints)  # ['U+E100', 'U+E101', 'U+E102']
+
+print(lang.reverse(res.text))  # person_0 house_1 water_2
+print(lang.install_note())
+```
+
+## Logical symbol design
+
+Each glyph is compositional and fully rule-driven:
+
+- Semantic radical (base shape):
+  - `entity`: box
+  - `action`: diagonal cross
+  - `quality`: diamond
+  - `relation`: bridge bar
+  - `abstract`: circle-ish octagon
+- Onset class adds a stem direction.
+- Vowel places a dot mark in one of 5 anchor positions.
+- Coda adds a terminal notch/tick style.
+
+So related meanings and sounds share visible structure.
+
+## Direct g4f usage
+
+The dictionary generator internally uses this same API pattern:
+
+```python
+from g4f.client import Client
+
+client = Client()
+response = client.chat.completions.create(
+    model="gpt-5-mini",
+    messages=[{"role": "user", "content": "..." }],
+    web_search=False
+)
+print(response.choices[0].message.content)
+```

logiglyph-0.1.0/README.md

@@ -0,0 +1,125 @@
+# Agglutinative Language Toolkit
+
+This project bootstraps a synthetic agglutinative language with:
+
+- A GPT-powered dictionary generator and translator (`g4f` API)
+- A logical symbol system where glyph form encodes meaning + sound
+- A font generator that compiles symbols into a `.ttf` font
+
+## 1) Setup
+
+```powershell
+python -m venv .venv
+.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+pip install -e .
+```
+
+After editable install, you can use:
+
+- `logiglyph ...` (console command)
+- `python -m logiglyph ...`
+- `from logiglyph import LanguageModule`
+
+## 2) Generate dictionary
+
+```powershell
+python -m src.tool generate-dictionary --count 96 --out data/dictionary.json
+```
+
+This calls `g4f` (`gpt-5-mini`) and enriches each root with:
+
+- `semantic_class`
+- `onset`, `vowel`, `coda` (sound parts)
+- `symbol_id` (logical glyph key)
+- `char` (Private Use Area codepoint)
+
+If API output is malformed/unavailable, the tool falls back to deterministic local roots.
+
+## 3) Build font
+
+```powershell
+python -m src.tool build-font --dict data/dictionary.json --out dist/LogiGlyph.ttf
+```
+
+This creates:
+
+- `dist/LogiGlyph.ttf`
+- `dist/glyph_map.json`
+
+## 4) Translate text
+
+```powershell
+python -m src.tool translate --dict data/dictionary.json --text "the person builds a house"
+python -m src.tool translate --dict data/dictionary.json --text "" --reverse
+```
+
+## 5) Build specimen (visual check)
+
+```powershell
+python -m src.tool build-specimen --dict data/dictionary.json --font dist/LogiGlyph.ttf --out dist/specimen.html
+```
+
+Open `dist/specimen.html` in a browser. Keep `LogiGlyph.ttf` in the same folder so `@font-face` can load it.
+
+## Font rendering troubleshooting
+
+These symbols are in Private Use Area (`U+E100+`), so they only render when your app uses `LogiGlyph.ttf`.
+
+- Terminal/editor showing squares or fallback chars: set font family to include `LogiGlyph`.
+- Browser: use CSS `@font-face` and set `font-family: 'LogiGlyph'` on the target element.
+- Windows app: install `dist/LogiGlyph.ttf` and select that font in the control/widget.
+
+Example VS Code setting:
+
+```json
+{
+  "editor.fontFamily": "LogiGlyph, Consolas, 'Courier New', monospace"
+}
+```
+
+## Use as a Python module
+
+```python
+from logiglyph import LanguageModule
+
+lang = LanguageModule("data/dictionary.json")
+res = lang.translate("person_0 house_1 water_2")
+print(res.text)        # e.g.   
+print(res.codepoints)  # ['U+E100', 'U+E101', 'U+E102']
+
+print(lang.reverse(res.text))  # person_0 house_1 water_2
+print(lang.install_note())
+```
+
+## Logical symbol design
+
+Each glyph is compositional and fully rule-driven:
+
+- Semantic radical (base shape):
+  - `entity`: box
+  - `action`: diagonal cross
+  - `quality`: diamond
+  - `relation`: bridge bar
+  - `abstract`: circle-ish octagon
+- Onset class adds a stem direction.
+- Vowel places a dot mark in one of 5 anchor positions.
+- Coda adds a terminal notch/tick style.
+
+So related meanings and sounds share visible structure.
+
+## Direct g4f usage
+
+The dictionary generator internally uses this same API pattern:
+
+```python
+from g4f.client import Client
+
+client = Client()
+response = client.chat.completions.create(
+    model="gpt-5-mini",
+    messages=[{"role": "user", "content": "..." }],
+    web_search=False
+)
+print(response.choices[0].message.content)
+```

logiglyph-0.1.0/logiglyph/__init__.py

@@ -0,0 +1,6 @@
+"""Public package API for LogiGlyph."""
+
+from src.api import LanguageModule, TranslationResult
+
+__all__ = ["LanguageModule", "TranslationResult"]
+

logiglyph-0.1.0/logiglyph/__main__.py

@@ -0,0 +1,6 @@
+from src.tool import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

logiglyph-0.1.0/logiglyph/cli.py

@@ -0,0 +1,4 @@
+from src.tool import main
+
+__all__ = ["main"]
+

logiglyph-0.1.0/logiglyph.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: logiglyph
+Version: 0.1.0
+Summary: Agglutinative language toolkit with logical symbols, translator, and font generator.
+Author: Augusto
+License-Expression: MIT
+Keywords: conlang,translator,font,agglutinative-language
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: g4f>=0.3.2.7
+Requires-Dist: fonttools>=4.56.0
+Dynamic: license-file
+
+# Agglutinative Language Toolkit
+
+This project bootstraps a synthetic agglutinative language with:
+
+- A GPT-powered dictionary generator and translator (`g4f` API)
+- A logical symbol system where glyph form encodes meaning + sound
+- A font generator that compiles symbols into a `.ttf` font
+
+## 1) Setup
+
+```powershell
+python -m venv .venv
+.venv\Scripts\Activate.ps1
+pip install -r requirements.txt
+pip install -e .
+```
+
+After editable install, you can use:
+
+- `logiglyph ...` (console command)
+- `python -m logiglyph ...`
+- `from logiglyph import LanguageModule`
+
+## 2) Generate dictionary
+
+```powershell
+python -m src.tool generate-dictionary --count 96 --out data/dictionary.json
+```
+
+This calls `g4f` (`gpt-5-mini`) and enriches each root with:
+
+- `semantic_class`
+- `onset`, `vowel`, `coda` (sound parts)
+- `symbol_id` (logical glyph key)
+- `char` (Private Use Area codepoint)
+
+If API output is malformed/unavailable, the tool falls back to deterministic local roots.
+
+## 3) Build font
+
+```powershell
+python -m src.tool build-font --dict data/dictionary.json --out dist/LogiGlyph.ttf
+```
+
+This creates:
+
+- `dist/LogiGlyph.ttf`
+- `dist/glyph_map.json`
+
+## 4) Translate text
+
+```powershell
+python -m src.tool translate --dict data/dictionary.json --text "the person builds a house"
+python -m src.tool translate --dict data/dictionary.json --text "" --reverse
+```
+
+## 5) Build specimen (visual check)
+
+```powershell
+python -m src.tool build-specimen --dict data/dictionary.json --font dist/LogiGlyph.ttf --out dist/specimen.html
+```
+
+Open `dist/specimen.html` in a browser. Keep `LogiGlyph.ttf` in the same folder so `@font-face` can load it.
+
+## Font rendering troubleshooting
+
+These symbols are in Private Use Area (`U+E100+`), so they only render when your app uses `LogiGlyph.ttf`.
+
+- Terminal/editor showing squares or fallback chars: set font family to include `LogiGlyph`.
+- Browser: use CSS `@font-face` and set `font-family: 'LogiGlyph'` on the target element.
+- Windows app: install `dist/LogiGlyph.ttf` and select that font in the control/widget.
+
+Example VS Code setting:
+
+```json
+{
+  "editor.fontFamily": "LogiGlyph, Consolas, 'Courier New', monospace"
+}
+```
+
+## Use as a Python module
+
+```python
+from logiglyph import LanguageModule
+
+lang = LanguageModule("data/dictionary.json")
+res = lang.translate("person_0 house_1 water_2")
+print(res.text)        # e.g.   
+print(res.codepoints)  # ['U+E100', 'U+E101', 'U+E102']
+
+print(lang.reverse(res.text))  # person_0 house_1 water_2
+print(lang.install_note())
+```
+
+## Logical symbol design
+
+Each glyph is compositional and fully rule-driven:
+
+- Semantic radical (base shape):
+  - `entity`: box
+  - `action`: diagonal cross
+  - `quality`: diamond
+  - `relation`: bridge bar
+  - `abstract`: circle-ish octagon
+- Onset class adds a stem direction.
+- Vowel places a dot mark in one of 5 anchor positions.
+- Coda adds a terminal notch/tick style.
+
+So related meanings and sounds share visible structure.
+
+## Direct g4f usage
+
+The dictionary generator internally uses this same API pattern:
+
+```python
+from g4f.client import Client
+
+client = Client()
+response = client.chat.completions.create(
+    model="gpt-5-mini",
+    messages=[{"role": "user", "content": "..." }],
+    web_search=False
+)
+print(response.choices[0].message.content)
+```

logiglyph-0.1.0/logiglyph.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+logiglyph/__init__.py
+logiglyph/__main__.py
+logiglyph/cli.py
+logiglyph.egg-info/PKG-INFO
+logiglyph.egg-info/SOURCES.txt
+logiglyph.egg-info/dependency_links.txt
+logiglyph.egg-info/entry_points.txt
+logiglyph.egg-info/requires.txt
+logiglyph.egg-info/top_level.txt
+src/__init__.py
+src/api.py
+src/dictionary_tool.py
+src/font_builder.py
+src/specimen.py
+src/symbol_logic.py
+src/tool.py
+src/translator.py

logiglyph-0.1.0/logiglyph.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

logiglyph-0.1.0/logiglyph.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+logiglyph = logiglyph.cli:main

logiglyph-0.1.0/logiglyph.egg-info/requires.txt

@@ -0,0 +1,2 @@
+g4f>=0.3.2.7
+fonttools>=4.56.0

logiglyph-0.1.0/logiglyph.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+logiglyph
+src

logiglyph-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "logiglyph"
+version = "0.1.0"
+description = "Agglutinative language toolkit with logical symbols, translator, and font generator."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Augusto" }]
+keywords = ["conlang", "translator", "font", "agglutinative-language"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Operating System :: OS Independent",
+  "Topic :: Text Processing :: Linguistic",
+]
+dependencies = [
+  "g4f>=0.3.2.7",
+  "fonttools>=4.56.0",
+]
+
+[project.scripts]
+logiglyph = "logiglyph.cli:main"
+
+[tool.setuptools]
+packages = ["src", "logiglyph"]

logiglyph-0.1.0/setup.cfg

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

logiglyph-0.1.0/src/__init__.py

@@ -0,0 +1,5 @@
+"""Agglutinative language toolkit package."""
+
+from .api import LanguageModule, TranslationResult
+
+__all__ = ["LanguageModule", "TranslationResult"]

logiglyph-0.1.0/src/api.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List
+
+from .dictionary_tool import load_dictionary
+from .symbol_logic import RootSpec
+from .translator import translate_en_to_lang, translate_lang_to_en
+
+
+@dataclass
+class TranslationResult:
+    text: str
+    codepoints: List[str]
+
+
+class LanguageModule:
+    """Reusable API for integrating translation in other Python programs."""
+
+    def __init__(self, dictionary_path: str | Path = "data/dictionary.json"):
+        self.dictionary_path = Path(dictionary_path)
+        self.specs: List[RootSpec] = load_dictionary(self.dictionary_path)
+        self.char_to_gloss: Dict[str, str] = {s.char: s.gloss for s in self.specs}
+        self.gloss_to_char: Dict[str, str] = {s.gloss: s.char for s in self.specs}
+
+    def translate(self, text: str) -> TranslationResult:
+        out = translate_en_to_lang(text, self.specs)
+        cps = [f"U+{ord(ch):04X}" for ch in out if not ch.isspace()]
+        return TranslationResult(text=out, codepoints=cps)
+
+    def reverse(self, text: str) -> str:
+        return translate_lang_to_en(text, self.specs)
+
+    def install_note(self) -> str:
+        return (
+            "Install/use LogiGlyph.ttf in the target app and ensure the rendered field uses that font. "
+            "Symbols are in the Unicode Private Use Area (U+E100+)."
+        )
+

logiglyph-0.1.0/src/dictionary_tool.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from g4f.client import Client
+
+from .symbol_logic import (
+    PUA_START,
+    RootSpec,
+    compose_root,
+    enumerate_symbol_space,
+    symbol_id,
+)
+
+
+def _extract_json(text: str) -> List[Dict[str, str]]:
+    text = text.strip()
+    try:
+        data = json.loads(text)
+        if isinstance(data, list):
+            return data
+    except json.JSONDecodeError:
+        pass
+    match = re.search(r"\[[\s\S]*\]", text)
+    if not match:
+        raise ValueError("No JSON list found in model response.")
+    data = json.loads(match.group(0))
+    if not isinstance(data, list):
+        raise ValueError("JSON payload is not a list.")
+    return data
+
+
+def _fallback_entries(count: int) -> List[Dict[str, str]]:
+    glosses = [
+        "person",
+        "house",
+        "water",
+        "fire",
+        "earth",
+        "sky",
+        "day",
+        "night",
+        "eat",
+        "drink",
+        "go",
+        "come",
+        "see",
+        "know",
+        "make",
+        "give",
+        "big",
+        "small",
+        "good",
+        "bad",
+        "inside",
+        "outside",
+        "near",
+        "far",
+        "mind",
+        "time",
+        "name",
+        "group",
+        "path",
+        "tool",
+    ]
+    out: List[Dict[str, str]] = []
+    i = 0
+    while len(out) < count:
+        out.append({"gloss": glosses[i % len(glosses)] + f"_{i}", "semantic_class": ""})
+        i += 1
+    return out
+
+
+def _semantic_guess(gloss: str) -> str:
+    g = gloss.lower()
+    action_hints = ("eat", "drink", "go", "come", "see", "know", "make", "give", "do", "build")
+    quality_hints = ("big", "small", "good", "bad", "hot", "cold", "new", "old")
+    relation_hints = ("inside", "outside", "near", "far", "with", "from", "to", "between")
+    abstract_hints = ("mind", "time", "name", "idea", "rule", "number")
+    if any(k in g for k in action_hints):
+        return "action"
+    if any(k in g for k in quality_hints):
+        return "quality"
+    if any(k in g for k in relation_hints):
+        return "relation"
+    if any(k in g for k in abstract_hints):
+        return "abstract"
+    return "entity"
+
+
+def generate_dictionary(count: int = 96, model: str = "gpt-5-mini") -> List[RootSpec]:
+    prompt = (
+        f"Create {count} base roots for a tiny agglutinative language.\n"
+        "Return ONLY JSON list. Each item: "
+        '{"gloss":"english concept", "semantic_class":"entity|action|quality|relation|abstract"}.\n'
+        "Concepts must be common and concrete when possible."
+    )
+
+    entries: List[Dict[str, str]]
+    try:
+        client = Client()
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            web_search=False,
+        )
+        content = response.choices[0].message.content
+        entries = _extract_json(content)
+    except Exception:
+        entries = _fallback_entries(count)
+
+    slots = enumerate_symbol_space(max(count, len(entries)))
+    out: List[RootSpec] = []
+
+    for idx, raw in enumerate(entries[:count]):
+        gloss = str(raw.get("gloss", f"concept_{idx}")).strip().lower().replace(" ", "_")
+        sc = str(raw.get("semantic_class", "")).strip().lower()
+        if sc not in {"entity", "action", "quality", "relation", "abstract"}:
+            sc = _semantic_guess(gloss)
+
+        _, onset, vowel, coda = slots[idx]
+        root = compose_root(onset, vowel, coda)
+        out.append(
+            RootSpec(
+                root=root,
+                gloss=gloss,
+                semantic_class=sc,
+                onset=onset,
+                vowel=vowel,
+                coda=coda,
+                symbol_id=symbol_id(sc, onset, vowel, coda),
+                codepoint=PUA_START + idx,
+            )
+        )
+    return out
+
+
+def save_dictionary(specs: List[RootSpec], out_path: Path) -> None:
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = [
+        {
+            "root": s.root,
+            "gloss": s.gloss,
+            "semantic_class": s.semantic_class,
+            "onset": s.onset,
+            "vowel": s.vowel,
+            "coda": s.coda,
+            "symbol_id": s.symbol_id,
+            "codepoint": f"U+{s.codepoint:04X}",
+            "char": s.char,
+        }
+        for s in specs
+    ]
+    out_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def load_dictionary(path: Path) -> List[RootSpec]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    out: List[RootSpec] = []
+    for item in data:
+        cp_str = str(item["codepoint"]).replace("U+", "")
+        cp = int(cp_str, 16)
+        out.append(
+            RootSpec(
+                root=item["root"],
+                gloss=item["gloss"],
+                semantic_class=item["semantic_class"],
+                onset=item["onset"],
+                vowel=item["vowel"],
+                coda=item["coda"],
+                symbol_id=item["symbol_id"],
+                codepoint=cp,
+            )
+        )
+    return out
+
+
+def build_lookup(specs: List[RootSpec]) -> Dict[str, RootSpec]:
+    return {s.gloss: s for s in specs}
+
+
+def build_reverse_lookup(specs: List[RootSpec]) -> Dict[str, RootSpec]:
+    out: Dict[str, RootSpec] = {}
+    for s in specs:
+        out[s.root] = s
+        out[s.char] = s
+    return out
+

logiglyph-0.1.0/src/font_builder.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, Iterable, List, Tuple
+
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+
+from .dictionary_tool import load_dictionary
+from .symbol_logic import RootSpec, coda_style, onset_vector, vowel_anchor
+
+
+UNITS_PER_EM = 1000
+ASCENT = 820
+DESCENT = -180
+
+
+def _draw_octagon(pen: TTGlyphPen, cx: int, cy: int, r: int) -> None:
+    pts = [
+        (cx, cy + r),
+        (cx + int(r * 0.7), cy + int(r * 0.7)),
+        (cx + r, cy),
+        (cx + int(r * 0.7), cy - int(r * 0.7)),
+        (cx, cy - r),
+        (cx - int(r * 0.7), cy - int(r * 0.7)),
+        (cx - r, cy),
+        (cx - int(r * 0.7), cy + int(r * 0.7)),
+    ]
+    pen.moveTo(pts[0])
+    for p in pts[1:]:
+        pen.lineTo(p)
+    pen.closePath()
+
+
+def _draw_square(pen: TTGlyphPen, x0: int, y0: int, x1: int, y1: int) -> None:
+    pen.moveTo((x0, y0))
+    pen.lineTo((x1, y0))
+    pen.lineTo((x1, y1))
+    pen.lineTo((x0, y1))
+    pen.closePath()
+
+
+def _draw_diamond(pen: TTGlyphPen, cx: int, cy: int, rx: int, ry: int) -> None:
+    pen.moveTo((cx, cy + ry))
+    pen.lineTo((cx + rx, cy))
+    pen.lineTo((cx, cy - ry))
+    pen.lineTo((cx - rx, cy))
+    pen.closePath()
+
+
+def _draw_line_box(pen: TTGlyphPen, p0: Tuple[int, int], p1: Tuple[int, int], w: int = 30) -> None:
+    x0, y0 = p0
+    x1, y1 = p1
+    dx, dy = x1 - x0, y1 - y0
+    if dx == 0 and dy == 0:
+        return
+    if abs(dx) >= abs(dy):
+        # Horizontal-ish segment.
+        _draw_square(pen, min(x0, x1), y0 - w, max(x0, x1), y0 + w)
+    else:
+        # Vertical-ish segment.
+        _draw_square(pen, x0 - w, min(y0, y1), x0 + w, max(y0, y1))
+
+
+def _semantic_base(pen: TTGlyphPen, semantic_class: str) -> None:
+    if semantic_class == "entity":
+        _draw_square(pen, 260, 260, 740, 740)
+    elif semantic_class == "action":
+        _draw_line_box(pen, (280, 300), (720, 700))
+        _draw_line_box(pen, (280, 700), (720, 300))
+    elif semantic_class == "quality":
+        _draw_diamond(pen, 500, 500, 250, 250)
+    elif semantic_class == "relation":
+        _draw_square(pen, 220, 460, 780, 540)
+        _draw_square(pen, 300, 300, 380, 700)
+        _draw_square(pen, 620, 300, 700, 700)
+    else:
+        _draw_octagon(pen, 500, 500, 240)
+
+
+def _draw_onset_stem(pen: TTGlyphPen, onset: str) -> Tuple[int, int]:
+    cx, cy = 500, 500
+    dx, dy = onset_vector(onset)
+    ex, ey = cx + dx, cy + dy
+    _draw_line_box(pen, (cx, cy), (ex, ey), w=24)
+    return ex, ey
+
+
+def _draw_vowel_mark(pen: TTGlyphPen, vowel: str) -> None:
+    x, y = vowel_anchor(vowel)
+    _draw_diamond(pen, x, y, 45, 45)
+
+
+def _draw_coda_mark(pen: TTGlyphPen, endpoint: Tuple[int, int], coda: str) -> None:
+    style = coda_style(coda)
+    x, y = endpoint
+    if style == "none":
+        return
+    if style == "short_tick":
+        _draw_square(pen, x - 20, y - 20, x + 80, y + 20)
+    elif style == "angle_tick":
+        _draw_line_box(pen, (x, y), (x + 90, y - 70), w=18)
+    elif style == "double_tick":
+        _draw_square(pen, x - 20, y - 50, x + 90, y - 10)
+        _draw_square(pen, x - 20, y + 10, x + 90, y + 50)
+    elif style == "bar":
+        _draw_square(pen, x - 70, y - 16, x + 70, y + 16)
+    elif style == "hook":
+        _draw_square(pen, x - 20, y - 20, x + 20, y + 90)
+        _draw_square(pen, x - 20, y + 50, x + 80, y + 90)
+    elif style == "cross_tick":
+        _draw_square(pen, x - 20, y - 20, x + 80, y + 20)
+        _draw_square(pen, x + 20, y - 80, x + 60, y + 80)
+
+
+def _glyph_for_root(spec: RootSpec):
+    pen = TTGlyphPen(None)
+    _semantic_base(pen, spec.semantic_class)
+    endpoint = _draw_onset_stem(pen, spec.onset)
+    _draw_vowel_mark(pen, spec.vowel)
+    _draw_coda_mark(pen, endpoint, spec.coda)
+    return pen.glyph()
+
+
+def build_font(specs: Iterable[RootSpec], out_path: Path, family_name: str = "LogiGlyph") -> Path:
+    specs = list(specs)
+    glyph_order = [".notdef", "space"] + [f"uni{spec.codepoint:04X}" for spec in specs]
+    cmap: Dict[int, str] = {32: "space"}
+    glyf = {}
+    hmtx = {}
+
+    notdef_pen = TTGlyphPen(None)
+    _draw_square(notdef_pen, 120, 120, 880, 880)
+    _draw_square(notdef_pen, 240, 240, 760, 760)
+    glyf[".notdef"] = notdef_pen.glyph()
+    hmtx[".notdef"] = (1000, 0)
+
+    space_pen = TTGlyphPen(None)
+    glyf["space"] = space_pen.glyph()
+    hmtx["space"] = (500, 0)
+
+    glyph_map = []
+    for spec in specs:
+        name = f"uni{spec.codepoint:04X}"
+        glyf[name] = _glyph_for_root(spec)
+        hmtx[name] = (1000, 0)
+        cmap[spec.codepoint] = name
+        glyph_map.append(
+            {
+                "gloss": spec.gloss,
+                "root": spec.root,
+                "char": spec.char,
+                "codepoint": f"U+{spec.codepoint:04X}",
+                "symbol_id": spec.symbol_id,
+            }
+        )
+
+    fb = FontBuilder(UNITS_PER_EM, isTTF=True)
+    fb.setupGlyphOrder(glyph_order)
+    fb.setupCharacterMap(cmap)
+    fb.setupGlyf(glyf)
+    fb.setupHorizontalMetrics(hmtx)
+    fb.setupHorizontalHeader(ascent=ASCENT, descent=DESCENT)
+    fb.setupNameTable(
+        {
+            "familyName": family_name,
+            "styleName": "Regular",
+            "fullName": f"{family_name} Regular",
+            "psName": f"{family_name}-Regular",
+            "uniqueFontIdentifier": f"{family_name}-Regular-001",
+        }
+    )
+    fb.setupOS2(
+        sTypoAscender=ASCENT,
+        sTypoDescender=DESCENT,
+        usWinAscent=ASCENT,
+        usWinDescent=abs(DESCENT),
+    )
+    fb.setupPost()
+    fb.setupMaxp()
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    fb.save(str(out_path))
+
+    map_path = out_path.with_name("glyph_map.json")
+    map_path.write_text(json.dumps(glyph_map, indent=2, ensure_ascii=False), encoding="utf-8")
+    return out_path
+
+
+def build_font_from_dictionary(dict_path: Path, out_path: Path, family_name: str = "LogiGlyph") -> Path:
+    specs = load_dictionary(dict_path)
+    return build_font(specs, out_path=out_path, family_name=family_name)
+

logiglyph-0.1.0/src/specimen.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .dictionary_tool import load_dictionary
+
+
+def build_specimen(dict_path: Path, font_path: Path, out_path: Path) -> Path:
+    specs = load_dictionary(dict_path)
+    rows = []
+    for s in specs:
+        rows.append(
+            f"<tr><td class='glyph'>{s.char}</td><td>{s.gloss}</td><td>{s.root}</td><td>{s.symbol_id}</td><td>U+{s.codepoint:04X}</td></tr>"
+        )
+    html = f"""<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <title>LogiGlyph Specimen</title>
+  <style>
+    @font-face {{
+      font-family: 'LogiGlyph';
+      src: url('{font_path.name}') format('truetype');
+    }}
+    body {{ font-family: 'Segoe UI', sans-serif; background: #f4f7f8; color: #1f2a30; margin: 24px; }}
+    h1 {{ margin: 0 0 12px; }}
+    table {{ border-collapse: collapse; width: 100%; background: #ffffff; }}
+    td, th {{ border: 1px solid #d8e1e4; padding: 8px 10px; text-align: left; }}
+    th {{ background: #ecf3f5; }}
+    .glyph {{ font-family: 'LogiGlyph', sans-serif; font-size: 34px; width: 68px; text-align: center; }}
+  </style>
+</head>
+<body>
+  <h1>LogiGlyph Specimen</h1>
+  <p>Each symbol is compositional: semantic base + onset + vowel + coda.</p>
+  <table>
+    <thead>
+      <tr><th>Glyph</th><th>Gloss</th><th>Root</th><th>Symbol ID</th><th>Codepoint</th></tr>
+    </thead>
+    <tbody>
+      {''.join(rows)}
+    </tbody>
+  </table>
+</body>
+</html>
+"""
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(html, encoding="utf-8")
+    return out_path
+

logiglyph-0.1.0/src/symbol_logic.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
+
+
+SEMANTIC_CLASSES = ["entity", "action", "quality", "relation", "abstract"]
+ONSETS = ["p", "t", "k", "m", "n", "s", "l", "r", "h", "w", "y"]
+VOWELS = ["a", "e", "i", "o", "u"]
+CODAS = ["", "n", "k", "s", "m", "l", "r"]
+
+PUA_START = 0xE100
+
+
+@dataclass(frozen=True)
+class RootSpec:
+    root: str
+    gloss: str
+    semantic_class: str
+    onset: str
+    vowel: str
+    coda: str
+    symbol_id: str
+    codepoint: int
+
+    @property
+    def char(self) -> str:
+        return chr(self.codepoint)
+
+
+def compose_root(onset: str, vowel: str, coda: str) -> str:
+    return f"{onset}{vowel}{coda}"
+
+
+def symbol_id(semantic_class: str, onset: str, vowel: str, coda: str) -> str:
+    return f"{semantic_class}:{onset}:{vowel}:{coda or '_'}"
+
+
+def enumerate_symbol_space(limit: int) -> List[Tuple[str, str, str, str]]:
+    out: List[Tuple[str, str, str, str]] = []
+    for sc in SEMANTIC_CLASSES:
+        for o in ONSETS:
+            for v in VOWELS:
+                for c in CODAS:
+                    out.append((sc, o, v, c))
+                    if len(out) >= limit:
+                        return out
+    return out
+
+
+def vowel_anchor(vowel: str) -> Tuple[int, int]:
+    anchors: Dict[str, Tuple[int, int]] = {
+        "a": (500, 760),
+        "e": (780, 500),
+        "i": (500, 240),
+        "o": (220, 500),
+        "u": (500, 500),
+    }
+    return anchors[vowel]
+
+
+def onset_vector(onset: str) -> Tuple[int, int]:
+    vecs: Dict[str, Tuple[int, int]] = {
+        "p": (0, 260),
+        "t": (260, 0),
+        "k": (0, -260),
+        "m": (-260, 0),
+        "n": (180, 180),
+        "s": (180, -180),
+        "l": (-180, -180),
+        "r": (-180, 180),
+        "h": (0, 320),
+        "w": (320, 0),
+        "y": (-320, 0),
+    }
+    return vecs[onset]
+
+
+def coda_style(coda: str) -> str:
+    styles = {
+        "": "none",
+        "n": "short_tick",
+        "k": "angle_tick",
+        "s": "double_tick",
+        "m": "bar",
+        "l": "hook",
+        "r": "cross_tick",
+    }
+    return styles[coda]
+

logiglyph-0.1.0/src/tool.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .dictionary_tool import generate_dictionary, load_dictionary, save_dictionary
+from .font_builder import build_font_from_dictionary
+from .specimen import build_specimen
+from .translator import translate_en_to_lang, translate_lang_to_en
+
+
+def _cmd_generate_dictionary(args: argparse.Namespace) -> int:
+    specs = generate_dictionary(count=args.count, model=args.model)
+    save_dictionary(specs, Path(args.out))
+    print(f"Dictionary saved: {args.out} ({len(specs)} roots)")
+    return 0
+
+
+def _cmd_build_font(args: argparse.Namespace) -> int:
+    out = build_font_from_dictionary(
+        dict_path=Path(args.dict),
+        out_path=Path(args.out),
+        family_name=args.family,
+    )
+    print(f"Font saved: {out}")
+    print(f"Glyph map: {out.with_name('glyph_map.json')}")
+    return 0
+
+
+def _cmd_translate(args: argparse.Namespace) -> int:
+    specs = load_dictionary(Path(args.dict))
+    if args.reverse:
+        translated = translate_lang_to_en(args.text, specs)
+    else:
+        translated = translate_en_to_lang(args.text, specs)
+    print(translated)
+    return 0
+
+
+def _cmd_build_specimen(args: argparse.Namespace) -> int:
+    out = build_specimen(
+        dict_path=Path(args.dict),
+        font_path=Path(args.font),
+        out_path=Path(args.out),
+    )
+    print(f"Specimen saved: {out}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="Agglutinative language toolkit")
+    sp = p.add_subparsers(dest="command", required=True)
+
+    g = sp.add_parser("generate-dictionary", help="Generate root dictionary using g4f")
+    g.add_argument("--count", type=int, default=96, help="Number of roots")
+    g.add_argument("--model", default="gpt-5-mini", help="g4f model name")
+    g.add_argument("--out", default="data/dictionary.json", help="Output dictionary JSON")
+    g.set_defaults(func=_cmd_generate_dictionary)
+
+    b = sp.add_parser("build-font", help="Build .ttf font from dictionary")
+    b.add_argument("--dict", default="data/dictionary.json", help="Input dictionary JSON")
+    b.add_argument("--out", default="dist/LogiGlyph.ttf", help="Output TTF path")
+    b.add_argument("--family", default="LogiGlyph", help="Font family name")
+    b.set_defaults(func=_cmd_build_font)
+
+    t = sp.add_parser("translate", help="Translate between English and symbol language")
+    t.add_argument("--dict", default="data/dictionary.json", help="Input dictionary JSON")
+    t.add_argument("--text", required=True, help="Text to translate")
+    t.add_argument("--reverse", action="store_true", help="Translate from language to English")
+    t.set_defaults(func=_cmd_translate)
+
+    s = sp.add_parser("build-specimen", help="Build HTML specimen for the symbol font")
+    s.add_argument("--dict", default="data/dictionary.json", help="Input dictionary JSON")
+    s.add_argument("--font", default="dist/LogiGlyph.ttf", help="Font path used in @font-face")
+    s.add_argument("--out", default="dist/specimen.html", help="Output HTML path")
+    s.set_defaults(func=_cmd_build_specimen)
+
+    return p
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

logiglyph-0.1.0/src/translator.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import re
+from typing import List
+
+from .dictionary_tool import build_lookup, build_reverse_lookup
+from .symbol_logic import RootSpec
+
+
+TOKEN_RE = re.compile(r"[A-Za-z0-9_]+|[^\sA-Za-z0-9_]")
+
+
+def _tokenize(text: str) -> List[str]:
+    return TOKEN_RE.findall(text.lower())
+
+
+def translate_en_to_lang(text: str, specs: List[RootSpec]) -> str:
+    lookup = build_lookup(specs)
+    tokens = _tokenize(text)
+    out: List[str] = []
+    for t in tokens:
+        if t in lookup:
+            out.append(lookup[t].char)
+            continue
+        # Basic morphology fallback:
+        # plural -> root + relation marker if available
+        if t.endswith("s") and t[:-1] in lookup:
+            out.append(lookup[t[:-1]].char)
+            rel = lookup.get("group_27") or next((s for s in specs if s.semantic_class == "relation"), None)
+            if rel:
+                out.append(rel.char)
+            continue
+        out.append(t)
+    return " ".join(out)
+
+
+def translate_lang_to_en(text: str, specs: List[RootSpec]) -> str:
+    reverse = build_reverse_lookup(specs)
+    out: List[str] = []
+    for ch in text:
+        if ch in reverse:
+            out.append(reverse[ch].gloss + " ")
+        elif ch.isspace():
+            out.append(" ")
+        else:
+            out.append(ch)
+    return re.sub(r"\s+", " ", "".join(out)).strip()