code2logic 1.0.30__tar.gz → 1.0.35__tar.gz

{code2logic-1.0.30 → code2logic-1.0.35}/PKG-INFO

@@ -1,30 +1,25 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.30
-Summary: Convert source code to logical representation for LLM analysis
+Version: 1.0.35
+Summary: Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support.
 License: Apache-2.0
+License-File: LICENSE
 Keywords: code-analysis,llm,ast,static-analysis,tree-sitter,code-understanding,documentation,dependency-graph,nlp
 Author: Softreck
-Author-email: info@softreck.dev
+Author-email: tom@sapletta.com
 Maintainer: Softreck
-Maintainer-email: info@softreck.dev
+Maintainer-email: tom@sapletta.com
 Requires-Python: >=3.9,<4.0
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Documentation
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Quality Assurance
-Classifier: Topic :: Text Processing :: Linguistic
-Classifier: Typing :: Typed
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: full
 Provides-Extra: graph
 Provides-Extra: llm
@@ -57,7 +52,7 @@ Description-Content-Type: text/markdown
  
 [![PyPI version](https://badge.fury.io/py/code2logic.svg)](https://badge.fury.io/py/code2logic)
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-yellow.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
  
 **Convert source code to logical representation for LLM analysis.**
@@ -561,3 +556,11 @@ python -m logic2code out/code2logic/project.c2l.yaml -o out/logic2code/generated
 - [GitHub](https://github.com/wronai/code2logic)
 - [Issues](https://github.com/wronai/code2logic/issues)
 
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)
+

{code2logic-1.0.30 → code2logic-1.0.35}/README.md

@@ -6,7 +6,7 @@
  
 [![PyPI version](https://badge.fury.io/py/code2logic.svg)](https://badge.fury.io/py/code2logic)
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
-[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-yellow.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 
  
 **Convert source code to logical representation for LLM analysis.**
@@ -509,3 +509,11 @@ python -m logic2code out/code2logic/project.c2l.yaml -o out/logic2code/generated
 - [PyPI](https://pypi.org/project/code2logic/)
 - [GitHub](https://github.com/wronai/code2logic)
 - [Issues](https://github.com/wronai/code2logic/issues)
+
+## License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+## Author
+
+Created by **Tom Sapletta** - [tom@sapletta.com](mailto:tom@sapletta.com)

{code2logic-1.0.30 → code2logic-1.0.35}/code2logic/__init__.py

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

{code2logic-1.0.30 → code2logic-1.0.35}/code2logic/cli.py

@@ -605,8 +605,14 @@ code2logic [path] [options]
         help='Detail level - columns to include (default: standard)'
     )
     parser.add_argument(
-        '-o', '--output',
-        help='Output file path (default: stdout)'
+        '-o', '--output-dir',
+        dest='output_dir',
+        help='Output directory for all generated files. If specified, files are saved instead of stdout. File names are derived from --name and format flags: {name}.{format}, {name}.functions.{ext}, {name}.{format}-schema.json'
+    )
+    parser.add_argument(
+        '--name',
+        dest='project_name',
+        help='Project name for output files (default: from CODE2LOGIC_PROJECT_NAME env or "project"). Used for auto-generating output, schema, and function-logic file names.'
     )
     parser.add_argument(
         '--function-logic',
@@ -638,7 +644,12 @@ code2logic [path] [options]
     parser.add_argument(
         '--with-schema',
         action='store_true',
-        help='Generate JSON schema alongside output'
+        help='Generate JSON schema file alongside output (uses project name for filename)'
+    )
+    parser.add_argument(
+        '--stdout',
+        action='store_true',
+        help='Write all output to stdout instead of files (including schema and function-logic). Useful for piping.'
     )
     parser.add_argument(
         '--no-install',
@@ -725,6 +736,7 @@ code2logic [path] [options]
 
     # Import after potential installation
     from .analyzer import ProjectAnalyzer, get_library_status
+    from .config import Config
     from .function_logic import FunctionLogicGenerator
     from .generators import (
         CSVGenerator,
@@ -736,6 +748,9 @@ code2logic [path] [options]
     from .logicml import LogicMLGenerator
     from .toon_format import TOONGenerator
 
+    # Load config to get project name
+    config = Config()
+
     # Status check
     if args.status:
         status = get_library_status()
@@ -844,6 +859,38 @@ code2logic [path] [options]
 
         log.separator()
 
+    # Get project name: CLI arg > env var > default
+    project_name = args.project_name if args.project_name else config.get_project_name()
+
+    # Determine output mode:
+    # - --stdout: all requested output to stdout (with section markers)
+    # - -o ./dir with --function-logic or --with-schema: only generate flagged files
+    # - -o ./dir without aux flags: generate main file only
+    # - no -o: main to stdout (auxiliary files require explicit path)
+    use_stdout = args.stdout
+    output_dir = args.output_dir
+
+    # When using output_dir with aux flags, only generate those files (not main)
+    has_aux_flags = args.function_logic or args.with_schema
+    generate_main = not has_aux_flags or use_stdout
+
+    # Build output paths based on output_dir
+    ext_map = {
+        'markdown': 'md',
+        'compact': 'txt',
+        'json': 'json',
+        'yaml': 'yaml',
+        'hybrid': 'yaml',
+        'csv': 'csv',
+        'gherkin': 'feature',
+        'toon': 'toon',
+        'logicml': 'logicml',
+    }
+    ext = ext_map.get(args.format, args.format)
+    main_output_path = None
+    if output_dir and generate_main:
+        main_output_path = os.path.join(output_dir, f"{project_name}.{ext}")
+
     # Generate output
     if args.verbose:
         log.step(f"Generating {args.format} output (detail: {args.detail})")
@@ -883,15 +930,19 @@ code2logic [path] [options]
                 schema = generator.generate_schema('hybrid')
             else:
                 schema = generator.generate_schema('compact' if compact else 'full')
-            base_name = os.path.splitext(args.output)[0] if args.output else 'output'
-            schema_path = f"{base_name}.yaml-schema.json"
-            parent_dir = os.path.dirname(schema_path)
-            if parent_dir:
-                os.makedirs(parent_dir, exist_ok=True)
-            with open(schema_path, 'w', encoding='utf-8') as f:
-                f.write(schema)
-            if args.verbose:
-                log.success(f"Schema written to: {schema_path}")
+
+            if use_stdout:
+                # Write to stdout with section marker
+                print(f"\n=== SCHEMA ===")
+                print(schema)
+            elif output_dir:
+                # Write to file in output directory
+                schema_path = os.path.join(output_dir, f"{project_name}.yaml-schema.json")
+                os.makedirs(output_dir, exist_ok=True)
+                with open(schema_path, 'w', encoding='utf-8') as f:
+                    f.write(schema)
+                if args.verbose:
+                    log.success(f"Schema written to: {schema_path}")
 
     elif args.format == 'toon':
         generator = TOONGenerator()
@@ -916,15 +967,19 @@ code2logic [path] [options]
         if args.with_schema:
             schema_type = 'ultra_compact' if use_ultra_compact else 'standard'
             schema = generator.generate_schema(schema_type)
-            base_name = os.path.splitext(args.output)[0] if args.output else 'output'
-            schema_path = f"{base_name}.toon-schema.json"
-            parent_dir = os.path.dirname(schema_path)
-            if parent_dir:
-                os.makedirs(parent_dir, exist_ok=True)
-            with open(schema_path, 'w', encoding='utf-8') as f:
-                f.write(schema)
-            if args.verbose:
-                log.success(f"Schema written to: {schema_path}")
+
+            if use_stdout:
+                # Write to stdout with section marker
+                print(f"\n=== SCHEMA ===")
+                print(schema)
+            elif output_dir:
+                # Write to file in output directory
+                schema_path = os.path.join(output_dir, f"{project_name}.toon-schema.json")
+                os.makedirs(output_dir, exist_ok=True)
+                with open(schema_path, 'w', encoding='utf-8') as f:
+                    f.write(schema)
+                if args.verbose:
+                    log.success(f"Schema written to: {schema_path}")
 
     elif args.format == 'logicml':
         generator = LogicMLGenerator()
@@ -938,20 +993,16 @@ code2logic [path] [options]
     if args.function_logic:
         logic_gen = FunctionLogicGenerator()
 
-        # Auto-generate path if 'auto' was specified (--function-logic without argument)
+        # Determine path for function logic file
         if args.function_logic == 'auto':
-            if args.output:
-                # Derive from output file: project.c2l.yaml -> project.functions.yaml
-                base = args.output.rsplit('.', 1)[0]
-                if base.endswith('.c2l'):
-                    base = base[:-4]
-                ext = args.output.rsplit('.', 1)[-1] if '.' in args.output else 'logicml'
-                logic_path = f"{base}.functions.{ext}"
+            if output_dir:
+                # Use output directory with project name
+                logic_ext = ext_map.get(args.format, 'logicml')
+                logic_path = os.path.join(output_dir, f"{project_name}.functions.{logic_ext}")
             else:
-                # Default path based on format
-                ext_map = {'json': 'json', 'yaml': 'yaml', 'toon': 'toon'}
-                ext = ext_map.get(args.format, 'logicml')
-                logic_path = f"project.functions.{ext}"
+                # No output dir - use project name in current directory
+                logic_ext = ext_map.get(args.format, 'logicml')
+                logic_path = f"{project_name}.functions.{logic_ext}"
         else:
             logic_path = str(args.function_logic)
 
@@ -965,13 +1016,17 @@ code2logic [path] [options]
         else:
             logic_out = logic_gen.generate(project, detail=args.detail)
 
-        parent_dir = os.path.dirname(logic_path)
-        if parent_dir:
-            os.makedirs(parent_dir, exist_ok=True)
-        with open(logic_path, 'w', encoding='utf-8') as f:
-            f.write(logic_out)
-        if args.verbose:
-            log.success(f"Function logic written to: {logic_path}")
+        if use_stdout:
+            # Write to stdout with section marker
+            print(f"\n=== FUNCTION_LOGIC ===")
+            print(logic_out)
+        elif output_dir:
+            # Write to file in output directory
+            os.makedirs(output_dir, exist_ok=True)
+            with open(logic_path, 'w', encoding='utf-8') as f:
+                f.write(logic_out)
+            if args.verbose:
+                log.success(f"Function logic written to: {logic_path}")
 
     gen_time = time.time() - gen_start
 
@@ -982,25 +1037,26 @@ code2logic [path] [options]
         log.stats("Size", f"{output_size:,} chars (~{tokens_approx:,} tokens)")
         log.stats("Lines", output.count('\n') + 1)
 
-    # Write output
-    if args.output:
-        parent_dir = os.path.dirname(args.output)
-        if parent_dir:
-            os.makedirs(parent_dir, exist_ok=True)
-        with open(args.output, 'w', encoding='utf-8') as f:
-            f.write(output)
-        if args.verbose:
-            log.success(f"Output written to: {args.output}")
-    else:
-        if not args.quiet:
-            try:
-                print(output, flush=True)
-            except BrokenPipeError:
+    # Write main output (only if generate_main is True)
+    if generate_main:
+        if output_dir:
+            # Write to file in output directory
+            os.makedirs(output_dir, exist_ok=True)
+            with open(main_output_path, 'w', encoding='utf-8') as f:
+                f.write(output)
+            if args.verbose:
+                log.success(f"Output written to: {main_output_path}")
+        else:
+            # Write to stdout
+            if not args.quiet:
                 try:
-                    sys.stdout.close()
-                except Exception:
-                    pass
-                os._exit(0)
+                    print(output, flush=True)
+                except BrokenPipeError:
+                    try:
+                        sys.stdout.close()
+                    except Exception:
+                        pass
+                    os._exit(0)
 
     # Final summary
     if args.verbose:

{code2logic-1.0.30 → code2logic-1.0.35}/code2logic/config.py

@@ -153,6 +153,14 @@ class Config:
         """Check if verbose mode is enabled."""
         return os.environ.get('CODE2LOGIC_VERBOSE', '').lower() in ('true', '1', 'yes')
 
+    def get_project_name(self) -> str:
+        """Get default project name for output files.
+
+        Returns:
+            Project name (default: 'project')
+        """
+        return os.environ.get('CODE2LOGIC_PROJECT_NAME', 'project')
+
     def get_cache_dir(self) -> Path:
         """Get cache directory path."""
         cache_dir = os.environ.get('CODE2LOGIC_CACHE_DIR', '~/.code2logic/cache')

{code2logic-1.0.30 → code2logic-1.0.35}/code2logic/generators.py

@@ -329,6 +329,18 @@ class CompactGenerator:
             if hubs:
                 lines.append(f"HUBS: {' '.join(hubs[:5])}")
 
+        # Dependency edges (compact call flow for LLM)
+        deps = {k: v for k, v in project.dependency_graph.items() if v}
+        if deps:
+            lines.append("")
+            lines.append("DEPS:")
+            for src, targets in sorted(deps.items())[:20]:
+                short_src = Path(src).stem
+                short_targets = ','.join(Path(t).stem for t in targets[:5])
+                if len(targets) > 5:
+                    short_targets += f"+{len(targets)-5}"
+                lines.append(f"  {short_src}->{short_targets}")
+
         lines.append("")
 
         curr_dir = None
@@ -350,6 +362,17 @@ class CompactGenerator:
             if fn_s:
                 parts.append(f"F:{fn_s}")
 
+            # Add method signatures with return types for classes
+            for c in m.classes[:3]:
+                pub_methods = [mt for mt in c.methods if not mt.is_private or mt.name == '__init__']
+                if pub_methods:
+                    sigs = []
+                    for mt in pub_methods[:6]:
+                        p = ','.join(remove_self_from_params(mt.params or [])[:3])
+                        ret = f"->{mt.return_type}" if mt.return_type else ""
+                        sigs.append(f"{mt.name}({p}){ret}")
+                    parts.append(f"{c.name}:{{{';'.join(sigs)}}}")
+
             content = ' | '.join(parts) if parts else '-'
             lines.append(f"  {fn} ({m.lines_code}L) {content}")
 

{code2logic-1.0.30 → code2logic-1.0.35}/code2logic/parsers.py

@@ -2039,12 +2039,81 @@ class UniversalParser:
         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 @@ class UniversalParser:
             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,

code2logic-1.0.35/code2logic/project_comparison.md

@@ -0,0 +1,16 @@
+# Project Comparison Analysis
+
+Generated on: $(date)
+
+## Project Statistics
+
+| Project | Modules | Functions | Total Items | Main Language |
+|---------|---------|-----------|-------------|---------------|
+
+## Detailed Analysis
+
+### Projects by Size (Total Items)
+
+
+### Projects by Language Distribution
+

{code2logic-1.0.30 → code2logic-1.0.35}/pyproject.toml

@@ -4,12 +4,15 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.30"
-description = "Convert source code to logical representation for LLM analysis"
+version = "1.0.35"
+description = "Code2Logic - Source code to logical representation converter for LLM analysis, featuring Tree-sitter parsing, dependency graph analysis, and multi-language support."
 readme = "README.md"
 license = "Apache-2.0"
-authors = ["Softreck <info@softreck.dev>"]
-maintainers = ["Softreck <info@softreck.dev>"]
+authors = [
+    "Softreck <tom@sapletta.com>",
+    "Tom Sapletta <tom@sapletta.com>",
+]
+maintainers = ["Softreck <tom@sapletta.com>"]
 keywords = [
     "code-analysis",
     "llm",
@@ -22,21 +25,8 @@ keywords = [
     "nlp",
 ]
 classifiers = [
-    "Development Status :: 4 - Beta",
-    "Environment :: Console",
+    "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: Apache Software License",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development :: Documentation",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Topic :: Software Development :: Quality Assurance",
-    "Topic :: Text Processing :: Linguistic",
-    "Typing :: Typed",
 ]
 packages = [{ include = "code2logic" }]