code2logic 1.0.34__tar.gz → 1.0.36__tar.gz

{code2logic-1.0.34 → code2logic-1.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2logic
-Version: 1.0.34
+Version: 1.0.36
 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.34 → code2logic-1.0.36}/code2logic/__init__.py

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

{code2logic-1.0.34 → code2logic-1.0.36}/code2logic/cli.py

@@ -605,8 +605,9 @@ 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',
@@ -643,7 +644,29 @@ 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-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',
@@ -856,23 +879,34 @@ code2logic [path] [options]
     # Get project name: CLI arg > env var > default
     project_name = args.project_name if args.project_name else config.get_project_name()
 
-    # Determine default output path when using --function-logic or --with-schema without -o
-    default_output = None
-    if (args.function_logic or args.with_schema) and not args.output:
-        # Use project name with appropriate extension
-        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)
-        default_output = f"{project_name}.{ext}"
+    # 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:
@@ -913,16 +947,19 @@ code2logic [path] [options]
                 schema = generator.generate_schema('hybrid')
             else:
                 schema = generator.generate_schema('compact' if compact else 'full')
-            effective_output = args.output or default_output
-            base_name = os.path.splitext(effective_output)[0] if effective_output else project_name
-            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()
@@ -941,22 +978,29 @@ 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:
             schema_type = 'ultra_compact' if use_ultra_compact else 'standard'
             schema = generator.generate_schema(schema_type)
-            effective_output = args.output or default_output
-            base_name = os.path.splitext(effective_output)[0] if effective_output else project_name
-            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()
@@ -970,21 +1014,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':
-            effective_output = args.output or default_output
-            if effective_output:
-                # Derive from output file: project.c2l.yaml -> project.functions.yaml
-                base = effective_output.rsplit('.', 1)[0]
-                if base.endswith('.c2l'):
-                    base = base[:-4]
-                ext = effective_output.rsplit('.', 1)[-1] if '.' in effective_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 using project name from config
-                ext_map = {'json': 'json', 'yaml': 'yaml', 'toon': 'toon'}
-                ext = ext_map.get(args.format, 'logicml')
-                logic_path = f"{project_name}.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)
 
@@ -994,17 +1033,26 @@ 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)
 
-        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
 
@@ -1015,25 +1063,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.34 → code2logic-1.0.36}/code2logic/function_logic.py

@@ -59,7 +59,13 @@ 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()
@@ -73,21 +79,33 @@ class FunctionLogicGenerator:
 
         modules = list(project.modules or [])
         lines.append(f"modules[{len(modules)}]{{path{dm}lang{dm}items}}:")
+        prev_dir: str | None = None
         for m in modules:
             items = self._module_items(m)
-            lines.append(f"  {toon._quote(m.path)}{delim}{m.language}{delim}{len(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:")
 
+        prev_dir = None
         for m in modules:
             items = self._module_items(m)
             if not items:
                 continue
 
-            lines.append(f"  {toon._quote(m.path)}:")
+            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)}:")
 
-            header = f"name{dm}kind{dm}sig{dm}loc{dm}async{dm}lines{dm}cc"
+            header = f"line{dm}name{dm}kind{dm}sig{dm}async{dm}cc"
             if detail in ('standard', 'full'):
                 header += f"{dm}does"
             if detail == 'full':
@@ -97,15 +115,14 @@ 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)
                 row = [
+                    start_line,
                     toon._quote(qname),
                     toon._quote(kind),
                     toon._quote(sig),
-                    toon._quote(loc),
                     is_async,
-                    str(getattr(func, 'lines', 0) or 0),
                     str(getattr(func, 'complexity', 1) or 1),
                 ]
 

{code2logic-1.0.34 → code2logic-1.0.36}/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.34 → code2logic-1.0.36}/pyproject.toml

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