code2logic 1.0.35__tar.gz → 1.0.37__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.35
+Version: 1.0.37
 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

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

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

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

@@ -651,6 +651,23 @@ code2logic [path] [options]
         action='store_true',
         help='Write all output to stdout instead of files (including schema and function-logic). Useful for piping.'
     )
+    parser.add_argument(
+        '--no-repeat-module',
+        action='store_true',
+        dest='no_repeat_module',
+        help='Reduce repeated directory prefixes in TOON outputs by using ./file for consecutive entries in the same folder (applies to function-logic TOON and TOON module lists).'
+    )
+    parser.add_argument(
+        '--no-repeat-name',
+        action='store_true',
+        dest='no_repeat_module',
+        help=argparse.SUPPRESS
+    )
+    parser.add_argument(
+        '--no-repeat-details',
+        action='store_true',
+        help='Reduce repeated directory prefixes in function-logic TOON section function_details by using ./file for consecutive entries in the same folder.'
+    )
     parser.add_argument(
         '--no-install',
         action='store_true',
@@ -961,7 +978,11 @@ code2logic [path] [options]
                 'standard': 'standard',
                 'full': 'full',
             }
-            output = generator.generate(project, detail=detail_map.get(args.detail, 'standard'))
+            output = generator.generate(
+                project,
+                detail=detail_map.get(args.detail, 'standard'),
+                no_repeat_name=args.no_repeat_module,
+            )
 
         # Generate schema if requested
         if args.with_schema:
@@ -1012,14 +1033,27 @@ code2logic [path] [options]
         elif lower.endswith(('.yaml', '.yml')):
             logic_out = logic_gen.generate_yaml(project, detail=args.detail)
         elif lower.endswith('.toon'):
-            logic_out = logic_gen.generate_toon(project, detail=args.detail)
+            logic_out = logic_gen.generate_toon(
+                project,
+                detail=args.detail,
+                no_repeat_name=args.no_repeat_module,
+                no_repeat_details=args.no_repeat_details,
+            )
         else:
             logic_out = logic_gen.generate(project, detail=args.detail)
 
+        # Generate function-logic schema if requested and format is TOON
+        func_schema = None
+        if args.with_schema and lower.endswith('.toon'):
+            func_schema = logic_gen.generate_toon_schema()
+
         if use_stdout:
             # Write to stdout with section marker
             print(f"\n=== FUNCTION_LOGIC ===")
             print(logic_out)
+            if func_schema:
+                print(f"\n=== FUNCTION_LOGIC_SCHEMA ===")
+                print(func_schema)
         elif output_dir:
             # Write to file in output directory
             os.makedirs(output_dir, exist_ok=True)
@@ -1027,6 +1061,12 @@ code2logic [path] [options]
                 f.write(logic_out)
             if args.verbose:
                 log.success(f"Function logic written to: {logic_path}")
+            if func_schema:
+                schema_path = logic_path.replace('.toon', '-schema.json')
+                with open(schema_path, 'w', encoding='utf-8') as f:
+                    f.write(func_schema)
+                if args.verbose:
+                    log.success(f"Function logic schema written to: {schema_path}")
 
     gen_time = time.time() - gen_start
 

{code2logic-1.0.35 → code2logic-1.0.37}/code2logic/function_logic.py

@@ -59,35 +59,57 @@ class FunctionLogicGenerator:
             return self.generate(project, detail)
         return yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False, width=120)
 
-    def generate_toon(self, project: ProjectInfo, detail: str = 'full') -> str:
+    def generate_toon(
+        self,
+        project: ProjectInfo,
+        detail: str = 'full',
+        no_repeat_name: bool = False,
+        no_repeat_details: bool = False,
+    ) -> str:
         if detail == 'detailed':
             detail = 'full'
         toon = TOONGenerator()
         delim = toon.delimiter
         dm = toon.delim_marker
 
+        # Pre-filter: only modules with at least one function/method
+        all_modules = list(project.modules or [])
+        modules_with_items = [(m, self._module_items(m)) for m in all_modules]
+        modules_with_items = [(m, items) for m, items in modules_with_items if items]
+
         lines: List[str] = []
+
+        # Format header — helps LLM understand the structure
+        lines.append(f"# {project.name} function-logic | {len(modules_with_items)} modules")
+        lines.append("# Convention: name with . = method, ~name = async, cc:N shown only when >1")
+
         lines.append(f"project: {toon._quote(project.name)}")
         if getattr(project, 'generated_at', None):
             lines.append(f"generated: {toon._quote(project.generated_at)}")
 
-        modules = list(project.modules or [])
-        lines.append(f"modules[{len(modules)}]{{path{dm}lang{dm}items}}:")
-        for m in modules:
-            items = self._module_items(m)
-            lines.append(f"  {toon._quote(m.path)}{delim}{m.language}{delim}{len(items)}")
+        lines.append(f"modules[{len(modules_with_items)}]{{path{dm}lang{dm}items}}:")
+        prev_dir: str | None = None
+        for m, items in modules_with_items:
+            if no_repeat_name:
+                compressed_path, prev_dir = toon._compress_module_path(m.path, prev_dir)
+                path_out = compressed_path
+            else:
+                path_out = m.path
+            lines.append(f"  {toon._quote(path_out)}{delim}{toon._short_lang(m.language)}{delim}{len(items)}")
 
         lines.append("")
         lines.append("function_details:")
 
-        for m in modules:
-            items = self._module_items(m)
-            if not items:
-                continue
+        prev_dir = None
+        for m, items in modules_with_items:
+            if no_repeat_details:
+                compressed_path, prev_dir = toon._compress_module_path(m.path, prev_dir)
+                details_key = compressed_path
+            else:
+                details_key = m.path
+            lines.append(f"  {toon._quote(details_key)}:")
 
-            lines.append(f"  {toon._quote(m.path)}:")
-
-            header = f"name{dm}kind{dm}sig{dm}loc{dm}async{dm}lines{dm}cc"
+            header = f"line{dm}name{dm}sig"
             if detail in ('standard', 'full'):
                 header += f"{dm}does"
             if detail == 'full':
@@ -97,16 +119,20 @@ class FunctionLogicGenerator:
 
             for kind, qname, func in items:
                 sig = self._build_sig(func, include_async_prefix=False, language=m.language)
-                loc = self._build_loc(func)
-                is_async = 'true' if getattr(func, 'is_async', False) else 'false'
+                start_line = str(getattr(func, 'start_line', 0) or 0)
+
+                # Encode async as ~ prefix, cc as suffix (only when >1)
+                display_name = qname
+                if getattr(func, 'is_async', False):
+                    display_name = f"~{qname}"
+                cc = getattr(func, 'complexity', 1) or 1
+                if cc > 1:
+                    display_name = f"{display_name} cc:{cc}"
+
                 row = [
-                    toon._quote(qname),
-                    toon._quote(kind),
+                    start_line,
+                    toon._quote(display_name),
                     toon._quote(sig),
-                    toon._quote(loc),
-                    is_async,
-                    str(getattr(func, 'lines', 0) or 0),
-                    str(getattr(func, 'complexity', 1) or 1),
                 ]
 
                 if detail in ('standard', 'full'):
@@ -125,6 +151,73 @@ class FunctionLogicGenerator:
 
         return "\n".join(lines).rstrip() + "\n"
 
+    def generate_toon_schema(self) -> str:
+        """Generate JSON Schema describing the function-logic TOON format."""
+        import json
+
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "title": "Code2Logic Function-Logic TOON Schema",
+            "description": (
+                "Schema for project.functions.toon — compact function/method index. "
+                "Conventions: name containing '.' = method (Class.method), "
+                "~prefix = async, 'cc:N' suffix = cyclomatic complexity (only when >1)."
+            ),
+            "type": "object",
+            "properties": {
+                "project": {"type": "string", "description": "Project name"},
+                "generated": {"type": "string", "description": "ISO timestamp"},
+                "modules": {
+                    "type": "array",
+                    "description": "Modules with at least one function/method. Rows: path,lang,items. Use ./file for same-dir compression (--no-repeat-module).",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "path": {"type": "string", "description": "Relative path or ./basename if same dir as previous"},
+                            "lang": {"type": "string", "description": "Short language code (py, js, ts, ...)"},
+                            "items": {"type": "integer", "description": "Number of functions+methods in module"}
+                        }
+                    }
+                },
+                "function_details": {
+                    "type": "object",
+                    "description": "Per-module function tables. Keys are module paths (or ./basename with --no-repeat-details).",
+                    "patternProperties": {
+                        ".*": {
+                            "type": "object",
+                            "properties": {
+                                "functions": {
+                                    "type": "array",
+                                    "description": "Tabular rows: line,name,sig[,does][,decorators,calls,raises]",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "line": {"type": "integer", "description": "Start line number"},
+                                            "name": {
+                                                "type": "string",
+                                                "description": (
+                                                    "Function or method name. "
+                                                    "Contains '.' if method (e.g. Class.method). "
+                                                    "Prefixed with ~ if async. "
+                                                    "Suffixed with ' cc:N' if cyclomatic complexity > 1."
+                                                )
+                                            },
+                                            "sig": {"type": "string", "description": "Signature: (params) [-> return_type]"},
+                                            "does": {"type": "string", "description": "Intent/purpose (standard+full detail)"},
+                                            "decorators": {"type": "string", "description": "Pipe-separated decorators (full detail)"},
+                                            "calls": {"type": "string", "description": "Pipe-separated function calls (full detail)"},
+                                            "raises": {"type": "string", "description": "Pipe-separated exceptions (full detail)"}
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return json.dumps(schema, indent=2, ensure_ascii=False)
+
     def _build_data(self, project: ProjectInfo, detail: str) -> dict:
         modules_data = []
         for m in project.modules or []:

{code2logic-1.0.35 → code2logic-1.0.37}/code2logic/toon_format.py

@@ -33,6 +33,37 @@ class TOONGenerator:
     SPECIAL_CHARS = re.compile(r'[:\"\\\[\]\{\}\n\t\r,]')
     LOOKS_LIKE_LITERAL = re.compile(r'^(true|false|null|-?\d+\.?\d*([eE][+-]?\d+)?|-)$')
 
+    LANGUAGE_ABBREVIATIONS = {
+        'python': 'py',
+        'javascript': 'js',
+        'typescript': 'ts',
+        'tsx': 'tsx',
+        'jsx': 'jsx',
+        'java': 'java',
+        'kotlin': 'kt',
+        'go': 'go',
+        'rust': 'rs',
+        'c': 'c',
+        'cpp': 'cpp',
+        'c++': 'cpp',
+        'csharp': 'cs',
+        'c#': 'cs',
+        'php': 'php',
+        'ruby': 'rb',
+        'swift': 'swift',
+        'scala': 'scala',
+        'bash': 'sh',
+        'shell': 'sh',
+        'sql': 'sql',
+        'yaml': 'yaml',
+        'json': 'json',
+        'toml': 'toml',
+        'markdown': 'md',
+        'html': 'html',
+        'css': 'css',
+        'dockerfile': 'docker',
+    }
+
     def __init__(self, delimiter: str = ',', use_tabs: bool = False):
         """
         Initialize TOON generator.
@@ -46,7 +77,27 @@ class TOONGenerator:
         # parsers/LLMs can read them. Use comma-separated headers regardless of row delimiter.
         self.delim_marker = ','
 
-    def generate(self, project: ProjectInfo, detail: str = 'standard') -> str:
+    def _short_lang(self, lang: str) -> str:
+        lang_norm = (lang or '').strip().lower()
+        return self.LANGUAGE_ABBREVIATIONS.get(lang_norm, lang)
+
+    def _compress_module_path(self, path: str, prev_dir: str | None) -> tuple[str, str]:
+        """Compress repeated directory prefixes for module summary tables.
+
+        If consecutive modules are in the same directory, emit './<basename>' instead
+        of repeating '<dir>/<basename>'. The first entry for a directory stays as the
+        full path.
+        """
+        p = (path or '')
+        if '/' not in p:
+            return p, ''
+
+        cur_dir, base = p.rsplit('/', 1)
+        if prev_dir is not None and cur_dir == prev_dir:
+            return f"./{base}", cur_dir
+        return p, cur_dir
+
+    def generate(self, project: ProjectInfo, detail: str = 'standard', no_repeat_name: bool = False) -> str:
         """
         Generate TOON format from ProjectInfo.
 
@@ -71,26 +122,33 @@ class TOONGenerator:
 
         # Languages as primitive array
         if project.languages:
-            lang_items = [f"{k}:{v}" for k, v in project.languages.items()]
+            lang_items = [f"{self._short_lang(k)}:{v}" for k, v in project.languages.items()]
             lines.append(f"  languages[{len(lang_items)}]: {self.delimiter.join(lang_items)}")
 
         # Modules - tabular format for efficiency
         if project.modules:
             lines.append("")
-            lines.extend(self._generate_modules(project.modules, detail))
+            lines.extend(self._generate_modules(project.modules, detail, no_repeat_name=no_repeat_name))
 
         return '\n'.join(lines)
 
-    def _generate_modules(self, modules: List[ModuleInfo], detail: str) -> List[str]:
+    def _generate_modules(self, modules: List[ModuleInfo], detail: str, no_repeat_name: bool = False) -> List[str]:
         """Generate modules section."""
         lines = []
 
         # Module summary as tabular array
         lines.append(f"modules[{len(modules)}]{{path{self.delim_marker}lang{self.delim_marker}lines{self.delim_marker}kb}}:")
+        prev_dir: str | None = None
         for m in modules:
-            path = self._quote(m.path)
+            if no_repeat_name:
+                path_out, prev_dir = self._compress_module_path(m.path, prev_dir)
+            else:
+                path_out = m.path
+            path = self._quote(path_out)
             kb = round((getattr(m, 'file_bytes', 0) or 0) / 1024, 1)
-            lines.append(f"  {path}{self.delimiter}{m.language}{self.delimiter}{m.lines_code}{self.delimiter}{kb}")
+            lines.append(
+                f"  {path}{self.delimiter}{self._short_lang(m.language)}{self.delimiter}{m.lines_code}{self.delimiter}{kb}"
+            )
 
         # Detailed module info
         if detail in ('standard', 'full'):

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "code2logic"
-version = "1.0.35"
+version = "1.0.37"
 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"