feat(config): deep code analysis engine with 6 supporting modules

changes:
  - file: parsers.py
    area: analyzer
    added: [_find_matching_brace, _get_or_create_class, _parse_rust_fn]
    modified: [_parse_rust, UniversalParser]
  - file: test_formats.py
    area: test
    added: [rust_sample_project, TestRustSupport]
    new_tests: 2

testing:
  new_tests: 2
  scenarios:
    - rust_shows_up_in_toon_and_function_logic
    - rust_parsing_finds_top_level_and_impl_methods

stats:
  lines: "+186/-47 (net +139)"
  files: 3
  complexity: "Large structural change (normalized)"

Author: tom-sapletta-com

CHANGELOG.md

@@ -1,3 +1,25 @@
+## [1.0.33] - 2026-02-23
+
+### Summary
+
+feat(config): deep code analysis engine with 6 supporting modules
+
+### Test
+
+- update tests/test_formats.py
+
+### Build
+
+- update pyproject.toml
+
+### Other
+
+- update code2logic/parsers.py
+- update logic2code/pyproject.toml
+- update logic2test/pyproject.toml
+- update lolm/pyproject.toml
+
+
 ## [1.0.32] - 2026-02-15
 
 ### Summary

VERSION

@@ -1 +1 @@
-1.0.32
+1.0.33

code2logic/__init__.py

@@ -18,7 +18,7 @@
     >>> print(output)
 """
 
-__version__ = "1.0.30"
+__version__ = "1.0.33"
 __author__ = "Softreck"
 __email__ = "info@softreck.dev"
 __license__ = "MIT"

code2logic/parsers.py

@@ -2039,12 +2039,81 @@ def _parse_rust(self, filepath: str, content: str) -> ModuleInfo:
         constants: List[str] = []
         exports: List[str] = []
 
+        def _get_or_create_class(name: str) -> ClassInfo:
+            for c in classes:
+                if c.name == name:
+                    return c
+            c = ClassInfo(name=name)
+            classes.append(c)
+            return c
+
+        def _find_matching_brace(src: str, start_idx: int) -> int:
+            depth = 0
+            in_str = False
+            str_ch = ''
+            i = start_idx
+            while i < len(src):
+                ch = src[i]
+                if in_str:
+                    if ch == '\\' and i + 1 < len(src):
+                        i += 2
+                        continue
+                    if ch == str_ch:
+                        in_str = False
+                        str_ch = ''
+                    i += 1
+                    continue
+                if ch in ('\"', "'"):
+                    in_str = True
+                    str_ch = ch
+                    i += 1
+                    continue
+                if ch == '{':
+                    depth += 1
+                elif ch == '}':
+                    depth -= 1
+                    if depth == 0:
+                        return i
+                i += 1
+            return -1
+
+        def _parse_rust_fn(match: re.Match, *, is_method: bool) -> FunctionInfo:
+            name = match.group('name')
+            params_raw = (match.group('params') or '').strip()
+            ret = (match.group('ret') or '').strip()
+            sig = (match.group(0) or '')
+
+            params = [p.strip() for p in params_raw.split(',') if p.strip()]
+            params = params[:8]
+
+            is_pub = bool(re.search(r'\bpub\b', sig))
+            return FunctionInfo(
+                name=name,
+                params=params,
+                return_type=ret,
+                docstring=None,
+                docstring_full=None,
+                calls=[],
+                raises=[],
+                decorators=[],
+                complexity=1,
+                lines=1,
+                is_async=False,
+                is_static=False,
+                is_classmethod=False,
+                is_property=False,
+                intent=self.intent_gen.generate(name),
+                start_line=0,
+                end_line=0,
+                is_private=not is_pub,
+            )
+
         for m in re.finditer(r'^use\s+([^;]+);', content, re.MULTILINE):
             imports.append(m.group(1).strip())
 
         for m in re.finditer(r'^(?:pub\s+)?struct\s+(\w+)', content, re.MULTILINE):
             name = m.group(1)
-            classes.append(ClassInfo(name=name))
+            _get_or_create_class(name)
             types.append(TypeInfo(name=name, kind='struct', definition=''))
             exports.append(name)
 
@@ -2058,35 +2127,64 @@ def _parse_rust(self, filepath: str, content: str) -> ModuleInfo:
             types.append(TypeInfo(name=name, kind='trait', definition=''))
             exports.append(name)
 
-        for m in re.finditer(r'^(?:pub\s+)?fn\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^\s{]+))?', content, re.MULTILINE):
+        for m in re.finditer(r'^(?:pub\s+)?type\s+(\w+)\s*=', content, re.MULTILINE):
             name = m.group(1)
-            params = [p.strip() for p in (m.group(2) or '').split(',') if p.strip()][:8]
-            ret = (m.group(3) or '').strip()
-            functions.append(FunctionInfo(
-                name=name,
-                params=params,
-                return_type=ret,
-                docstring=None,
-                docstring_full=None,
-                calls=[],
-                raises=[],
-                decorators=[],
-                complexity=1,
-                lines=1,
-                is_async='async' in m.group(0),
-                is_static=False,
-                is_classmethod=False,
-                is_property=False,
-                intent=self.intent_gen.generate(name),
-                start_line=0,
-                end_line=0,
-                is_private=False,
-            ))
+            types.append(TypeInfo(name=name, kind='type', definition=''))
+            exports.append(name)
+
+        for m in re.finditer(r'^(?:pub\s+)?mod\s+(\w+)\s*;', content, re.MULTILINE):
+            name = m.group(1)
+            types.append(TypeInfo(name=name, kind='module', definition=''))
             exports.append(name)
 
+        fn_pat = re.compile(
+            r'^\s*(?P<sig>(?:pub(?:\([^)]*\))?\s+)?fn)\s+(?P<name>\w+)\s*\((?P<params>[^)]*)\)\s*(?:->\s*(?P<ret>[^\s{]+))?',
+            re.MULTILINE,
+        )
+
+        for m in fn_pat.finditer(content):
+            functions.append(_parse_rust_fn(m, is_method=False))
+            exports.append(m.group('name'))
+
+        impl_pat = re.compile(
+            r'^impl\b[^\{]*\{',
+            re.MULTILINE,
+        )
+
+        for m in impl_pat.finditer(content):
+            hdr = content[m.start():m.end()]
+            type_name = ''
+            m_for = re.search(r'\bfor\s+(\w+)\b', hdr)
+            if m_for:
+                type_name = m_for.group(1)
+            else:
+                m_type = re.search(r'^impl\b[^\{]*?\b(\w+)\b\s*\{', hdr)
+                if m_type:
+                    type_name = m_type.group(1)
+
+            if not type_name:
+                continue
+
+            open_idx = content.find('{', m.start(), m.end())
+            if open_idx < 0:
+                continue
+            close_idx = _find_matching_brace(content, open_idx)
+            if close_idx < 0:
+                continue
+
+            body = content[open_idx + 1:close_idx]
+            cls = _get_or_create_class(type_name)
+            for fm in fn_pat.finditer(body):
+                cls.methods.append(_parse_rust_fn(fm, is_method=True))
+
+            exports.append(type_name)
+
         for m in re.finditer(r'^(?:pub\s+)?const\s+([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
             constants.append(m.group(1))
 
+        for m in re.finditer(r'^(?:pub\s+)?static\s+(?:mut\s+)?([A-Z][A-Z0-9_]*)\b', content, re.MULTILINE):
+            constants.append(m.group(1))
+
         lines = content.split('\n')
         return ModuleInfo(
             path=filepath,

logic2code/__init__.py

@@ -14,5 +14,5 @@
 from .generator import CodeGenerator, GeneratorConfig, GenerationResult
 from .renderers import PythonRenderer
 
-__version__ = '0.1.9'
+__version__ = '1.0.33'
 __all__ = ['CodeGenerator', 'GeneratorConfig', 'GenerationResult', 'PythonRenderer']

logic2code/pyproject.toml

@@ -7,7 +7,7 @@ name = "logic2code"
 version = "0.1.9"
 description = "Generate source code from Code2Logic output files"
 readme = "README.md"
-license = {text = "Apache-2.0"}
+license = "Apache-2.0"
 requires-python = ">=3.9"
 authors = [
     {name = "WronAI", email = "contact@wronai.com"}
@@ -23,7 +23,6 @@ keywords = [
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",

logic2test/__init__.py

@@ -15,5 +15,5 @@
 from .parsers import LogicParser
 from .templates import TestTemplate
 
-__version__ = '0.1.10'
+__version__ = '1.0.33'
 __all__ = ['TestGenerator', 'GeneratorConfig', 'GenerationResult', 'LogicParser', 'TestTemplate']

logic2test/pyproject.toml

@@ -7,7 +7,7 @@ name = "logic2test"
 version = "0.1.10"
 description = "Generate test scaffolds from Code2Logic output files"
 readme = "README.md"
-license = {text = "Apache-2.0"}
+license = "Apache-2.0"
 requires-python = ">=3.9"
 authors = [
     {name = "WronAI", email = "contact@wronai.com"}
@@ -23,7 +23,6 @@ keywords = [
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",

lolm/__init__.py

@@ -76,7 +76,7 @@
 )
 from .clients import LLMRateLimitError
 
-__version__ = '0.1.10'
+__version__ = '1.0.33'
 __all__ = [
     # Config
     'LLMConfig',

lolm/pyproject.toml

@@ -7,7 +7,7 @@ name = "lolm"
 version = "0.1.10"
 description = "Lightweight Orchestrated LLM Manager - Multi-provider LLM configuration and management"
 readme = "README.md"
-license = {text = "Apache-2.0"}
+license = "Apache-2.0"
 requires-python = ">=3.9"
 authors = [
     {name = "WronAI", email = "contact@wronai.com"}
@@ -25,7 +25,6 @@ keywords = [
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",