kopipasta 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

kopipasta/import_parser.py

@@ -0,0 +1,284 @@
+import os
+import re
+import json
+import ast
+from typing import Dict, List, Optional, Set, Tuple
+
+# --- Global Cache for tsconfig.json data ---
+# Key: absolute path to tsconfig.json file
+# Value: Tuple (absolute_base_url: Optional[str], alias_paths_map: Dict[str, List[str]])
+_tsconfig_configs_cache: Dict[str, Tuple[Optional[str], Dict[str, List[str]]]] = {}
+
+
+# --- TypeScript Alias and Import Resolution ---
+
+def find_relevant_tsconfig_path(file_path_abs: str, project_root_abs: str) -> Optional[str]:
+    """
+    Finds the most relevant tsconfig.json by searching upwards from the file's directory,
+    stopping at project_root_abs.
+    Searches for 'tsconfig.json' first, then 'tsconfig.*.json' in each directory.
+    """
+    current_dir = os.path.dirname(os.path.normpath(file_path_abs))
+    project_root_abs_norm = os.path.normpath(project_root_abs)
+
+    while current_dir.startswith(project_root_abs_norm) and len(current_dir) >= len(project_root_abs_norm):
+        potential_tsconfig = os.path.join(current_dir, "tsconfig.json")
+        if os.path.isfile(potential_tsconfig):
+            return os.path.normpath(potential_tsconfig)
+
+        try:
+            variant_tsconfigs = sorted([
+                f for f in os.listdir(current_dir)
+                if f.startswith("tsconfig.") and f.endswith(".json") and
+                   os.path.isfile(os.path.join(current_dir, f))
+            ])
+            if variant_tsconfigs:
+                return os.path.normpath(os.path.join(current_dir, variant_tsconfigs[0]))
+        except OSError:
+            pass
+
+        if current_dir == project_root_abs_norm:
+            break
+        
+        parent_dir = os.path.dirname(current_dir)
+        if parent_dir == current_dir:
+            break
+        current_dir = parent_dir
+    return None
+
+
+def load_tsconfig_config(tsconfig_path_abs: str) -> Tuple[Optional[str], Dict[str, List[str]]]:
+    """
+    Loads baseUrl and paths from a specific tsconfig.json.
+    Caches results.
+    Returns (absolute_base_url, paths_map).
+    """
+    if tsconfig_path_abs in _tsconfig_configs_cache:
+        return _tsconfig_configs_cache[tsconfig_path_abs]
+
+    if not os.path.isfile(tsconfig_path_abs):
+        _tsconfig_configs_cache[tsconfig_path_abs] = (None, {})
+        return None, {}
+        
+    try:
+        with open(tsconfig_path_abs, 'r', encoding='utf-8') as f:
+            content = f.read()
+            content = re.sub(r"//.*?\n", "\n", content) 
+            content = re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
+            config = json.loads(content)
+        
+        compiler_options = config.get("compilerOptions", {})
+        tsconfig_dir = os.path.dirname(tsconfig_path_abs)
+        base_url_from_config = compiler_options.get("baseUrl", ".") 
+        abs_base_url = os.path.normpath(os.path.join(tsconfig_dir, base_url_from_config))
+        
+        paths = compiler_options.get("paths", {})
+        processed_paths = {key: (val if isinstance(val, list) else [val]) for key, val in paths.items()}
+
+        # print(f"DEBUG: Loaded config from {os.path.relpath(tsconfig_path_abs)}: effective abs_baseUrl='{abs_base_url}', {len(processed_paths)} path alias(es).")
+        _tsconfig_configs_cache[tsconfig_path_abs] = (abs_base_url, processed_paths)
+        return abs_base_url, processed_paths
+    except Exception as e:
+        print(f"Warning: Could not parse {os.path.relpath(tsconfig_path_abs)}: {e}")
+        _tsconfig_configs_cache[tsconfig_path_abs] = (None, {})
+        return None, {}
+
+
+def _probe_ts_path_candidates(candidate_base_path_abs: str) -> Optional[str]:
+    """
+    Given a candidate base absolute path, tries to find a corresponding file.
+    """
+    possible_extensions = ['.ts', '.tsx', '.js', '.jsx', '.json']
+    
+    if os.path.isfile(candidate_base_path_abs):
+        return candidate_base_path_abs
+
+    stem, original_ext = os.path.splitext(candidate_base_path_abs)
+    base_for_ext_check = stem if original_ext.lower() in possible_extensions else candidate_base_path_abs
+
+    for ext in possible_extensions:
+        path_with_ext = base_for_ext_check + ext
+        if os.path.isfile(path_with_ext):
+            return path_with_ext
+            
+    if os.path.isdir(base_for_ext_check):
+        for ext in possible_extensions:
+            index_file_path = os.path.join(base_for_ext_check, "index" + ext)
+            if os.path.isfile(index_file_path):
+                return index_file_path
+    return None
+
+
+def resolve_ts_import_path(
+    import_str: str, 
+    current_file_dir_abs: str, 
+    abs_base_url: Optional[str], 
+    alias_map: Dict[str, List[str]]
+) -> Optional[str]:
+    """
+    Resolves a TypeScript import string to an absolute file path.
+    """
+    candidate_targets_abs: List[str] = []
+    sorted_alias_keys = sorted(alias_map.keys(), key=len, reverse=True)
+    alias_matched_and_resolved = False
+
+    for alias_pattern in sorted_alias_keys:
+        alias_prefix_pattern = alias_pattern.replace("/*", "")
+        if import_str.startswith(alias_prefix_pattern):
+            import_suffix = import_str[len(alias_prefix_pattern):]
+            for mapping_path_template_list in alias_map[alias_pattern]:
+                for mapping_path_template in (mapping_path_template_list if isinstance(mapping_path_template_list, list) else [mapping_path_template_list]):
+                    if "/*" in alias_pattern :
+                        resolved_relative_to_base = mapping_path_template.replace("*", import_suffix, 1)
+                    else:
+                        resolved_relative_to_base = mapping_path_template
+                    if abs_base_url:
+                        abs_candidate = os.path.normpath(os.path.join(abs_base_url, resolved_relative_to_base))
+                        candidate_targets_abs.append(abs_candidate)
+                    else:
+                        print(f"Warning: TS Alias '{alias_pattern}' used, but no abs_base_url for context of '{current_file_dir_abs}'.")
+            if candidate_targets_abs:
+                alias_matched_and_resolved = True
+                break
+
+    if not alias_matched_and_resolved and import_str.startswith('.'):
+        abs_candidate = os.path.normpath(os.path.join(current_file_dir_abs, import_str))
+        candidate_targets_abs.append(abs_candidate)
+    elif not alias_matched_and_resolved and abs_base_url and not import_str.startswith('.'):
+        abs_candidate = os.path.normpath(os.path.join(abs_base_url, import_str))
+        candidate_targets_abs.append(abs_candidate)
+
+    for cand_abs_path in candidate_targets_abs:
+        resolved_file = _probe_ts_path_candidates(cand_abs_path)
+        if resolved_file:
+            return resolved_file
+    return None
+
+
+def parse_typescript_imports(
+    file_content: str, 
+    file_path_abs: str,
+    project_root_abs: str
+) -> Set[str]:
+    resolved_imports_abs_paths = set()
+    relevant_tsconfig_abs_path = find_relevant_tsconfig_path(file_path_abs, project_root_abs)
+    
+    abs_base_url, alias_map = None, {}
+    if relevant_tsconfig_abs_path:
+        abs_base_url, alias_map = load_tsconfig_config(relevant_tsconfig_abs_path)
+    else:
+        # print(f"Warning: No tsconfig.json found for {os.path.relpath(file_path_abs, project_root_abs)}. Import resolution might be limited.")
+        abs_base_url = project_root_abs 
+
+    import_regex = re.compile(
+        r"""
+        (?:import|export)
+        (?:\s+(?:type\s+)?(?:[\w*{}\s,\[\]:\."'`-]+)\s+from)?
+        \s*['"`]([^'"\n`]+?)['"`]
+        |require\s*\(\s*['"`]([^'"\n`]+?)['"`]\s*\)
+        |import\s*\(\s*['"`]([^'"\n`]+?)['"`]\s*\)
+        """,
+        re.VERBOSE | re.MULTILINE
+    )
+    
+    current_file_dir_abs = os.path.dirname(file_path_abs)
+
+    for match in import_regex.finditer(file_content):
+        import_str_candidate = next((g for g in match.groups() if g is not None), None)
+        if import_str_candidate:
+            is_likely_external = (
+                not import_str_candidate.startswith(('.', '/')) and
+                not any(import_str_candidate.startswith(alias_pattern.replace("/*", "")) for alias_pattern in alias_map) and
+                not (abs_base_url and os.path.exists(os.path.join(abs_base_url, import_str_candidate))) and
+                (import_str_candidate.count('/') == 0 or (import_str_candidate.startswith('@') and import_str_candidate.count('/') == 1)) and
+                '.' not in import_str_candidate.split('/')[0]
+            )
+            if is_likely_external:
+                continue
+
+            resolved_abs_path = resolve_ts_import_path(
+                import_str_candidate, 
+                current_file_dir_abs, 
+                abs_base_url, 
+                alias_map
+            )
+            
+            if resolved_abs_path:
+                norm_resolved_path = os.path.normpath(resolved_abs_path)
+                if norm_resolved_path.startswith(os.path.normpath(project_root_abs)):
+                    resolved_imports_abs_paths.add(norm_resolved_path)
+    return resolved_imports_abs_paths
+
+
+# --- Python Import Resolution ---
+
+def resolve_python_import(
+    module_name_parts: List[str], 
+    current_file_dir_abs: str, 
+    project_root_abs: str, 
+    level: int
+) -> Optional[str]:
+    base_path_to_search = ""
+    if level > 0:
+        base_path_to_search = current_file_dir_abs
+        for _ in range(level - 1):
+            base_path_to_search = os.path.dirname(base_path_to_search)
+    else:
+        base_path_to_search = project_root_abs
+
+    candidate_rel_path = os.path.join(*module_name_parts)
+    potential_abs_path = os.path.join(base_path_to_search, candidate_rel_path)
+    
+    py_file = potential_abs_path + ".py"
+    if os.path.isfile(py_file):
+        return os.path.normpath(py_file)
+    
+    init_file = os.path.join(potential_abs_path, "__init__.py")
+    if os.path.isdir(potential_abs_path) and os.path.isfile(init_file):
+        return os.path.normpath(init_file)
+
+    if level == 0 and base_path_to_search == project_root_abs:
+        src_base_path = os.path.join(project_root_abs, "src")
+        if os.path.isdir(src_base_path):
+            potential_abs_path_src = os.path.join(src_base_path, candidate_rel_path)
+            py_file_src = potential_abs_path_src + ".py"
+            if os.path.isfile(py_file_src):
+                return os.path.normpath(py_file_src)
+            init_file_src = os.path.join(potential_abs_path_src, "__init__.py")
+            if os.path.isdir(potential_abs_path_src) and os.path.isfile(init_file_src):
+                return os.path.normpath(init_file_src)
+    return None
+
+
+def parse_python_imports(file_content: str, file_path_abs: str, project_root_abs: str) -> Set[str]:
+    resolved_imports = set()
+    current_file_dir_abs = os.path.dirname(file_path_abs)
+    
+    try:
+        tree = ast.parse(file_content, filename=file_path_abs)
+    except SyntaxError:
+        # print(f"Warning: Syntax error in {file_path_abs}, cannot parse Python imports.")
+        return resolved_imports
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                module_parts = alias.name.split('.')
+                resolved = resolve_python_import(module_parts, current_file_dir_abs, project_root_abs, level=0)
+                if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                    resolved_imports.add(os.path.normpath(resolved))
+        elif isinstance(node, ast.ImportFrom):
+            level_to_resolve = node.level
+            if node.module:
+                module_parts = node.module.split('.')
+                resolved = resolve_python_import(module_parts, current_file_dir_abs, project_root_abs, level_to_resolve)
+                if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                    resolved_imports.add(os.path.normpath(resolved))
+            else:
+                for alias in node.names:
+                    item_name_parts = alias.name.split('.')
+                    resolved = resolve_python_import(item_name_parts, current_file_dir_abs, project_root_abs, level=level_to_resolve)
+                    if resolved and os.path.exists(resolved) and os.path.normpath(resolved).startswith(os.path.normpath(project_root_abs)):
+                        resolved_imports.add(os.path.normpath(resolved))
+    return resolved_imports
+

kopipasta/main.py

@@ -24,6 +24,8 @@ from google import genai
 from google.genai.types import GenerateContentConfig
 from prompt_toolkit import prompt # Added for multiline input
 
+import kopipasta.import_parser as import_parser
+
 FileTuple = Tuple[str, bool, Optional[List[str]], str]
 
 class SimplePatchItem(BaseModel):
@@ -115,6 +117,109 @@ def apply_simple_patch(patch_item: SimplePatchItem) -> bool:
         print("-" * 20)
         return False
 
+def _propose_and_add_dependencies(
+    file_just_added: str,
+    project_root_abs: str,
+    files_to_include: List[FileTuple],
+    current_char_count: int
+) -> Tuple[List[FileTuple], int]:
+    """
+    Analyzes a file for local dependencies and interactively asks the user to add them.
+    """
+    language = get_language_for_file(file_just_added)
+    if language not in ['python', 'typescript', 'javascript', 'tsx', 'jsx']:
+        return [], 0 # Only analyze languages we can parse
+
+    print(f"Analyzing {get_relative_path(file_just_added)} for local dependencies...")
+
+    try:
+        file_content = read_file_contents(file_just_added)
+        if not file_content:
+            return [], 0
+
+        resolved_deps_abs: Set[str] = set()
+        if language == 'python':
+            resolved_deps_abs = import_parser.parse_python_imports(file_content, file_just_added, project_root_abs)
+        elif language in ['typescript', 'javascript', 'tsx', 'jsx']:
+            resolved_deps_abs = import_parser.parse_typescript_imports(file_content, file_just_added, project_root_abs)
+
+        # Filter out dependencies that are already in the context
+        included_paths = {os.path.abspath(f[0]) for f in files_to_include}
+        suggested_deps = sorted([
+            dep for dep in resolved_deps_abs
+            if os.path.abspath(dep) not in included_paths and os.path.abspath(dep) != os.path.abspath(file_just_added)
+        ])
+
+        if not suggested_deps:
+            print("No new local dependencies found.")
+            return [], 0
+
+        print(f"\nFound {len(suggested_deps)} new local {'dependency' if len(suggested_deps) == 1 else 'dependencies'}:")
+        for i, dep_path in enumerate(suggested_deps):
+            print(f"  ({i+1}) {get_relative_path(dep_path)}")
+
+        while True:
+            choice = input("\nAdd dependencies? (a)ll, (n)one, or enter numbers (e.g. 1, 3-4): ").lower()
+            
+            deps_to_add_paths = None
+            if choice == 'a':
+                deps_to_add_paths = suggested_deps
+                break
+            if choice == 'n':
+                deps_to_add_paths = []
+                print(f"Skipped {len(suggested_deps)} dependencies.")
+                break
+
+            # Try to parse the input as numbers directly.
+            try:
+                selected_indices = set()
+                parts = choice.replace(' ', '').split(',')
+                if all(p.strip() for p in parts): # Ensure no empty parts like in "1,"
+                    for part in parts:
+                        if '-' in part:
+                            start_str, end_str = part.split('-', 1)
+                            start = int(start_str)
+                            end = int(end_str)
+                            if start > end:
+                                start, end = end, start
+                            selected_indices.update(range(start - 1, end))
+                        else:
+                            selected_indices.add(int(part) - 1)
+
+                    # Validate that all selected numbers are within the valid range
+                    if all(0 <= i < len(suggested_deps) for i in selected_indices):
+                        deps_to_add_paths = [
+                            suggested_deps[i] for i in sorted(list(selected_indices))
+                        ]
+                        break # Success! Exit the loop.
+                    else:
+                        print(f"Error: Invalid number selection. Please choose numbers between 1 and {len(suggested_deps)}.")
+                else:
+                    raise ValueError("Empty part detected in input.")
+
+
+            except ValueError:
+                # This will catch any input that isn't 'a', 'n', or a valid number/range.
+                print("Invalid choice. Please enter 'a', 'n', or a list/range of numbers (e.g., '1,3' or '2-4').")
+        
+        if not deps_to_add_paths:
+            return [], 0 # No dependencies were selected
+
+        newly_added_files: List[FileTuple] = []
+        char_count_delta = 0
+        for dep_path in deps_to_add_paths:
+            # Assume non-large for now for simplicity, can be enhanced later
+            file_size = os.path.getsize(dep_path)
+            newly_added_files.append((dep_path, False, None, get_language_for_file(dep_path)))
+            char_count_delta += file_size
+            print(f"Added dependency: {get_relative_path(dep_path)} ({get_human_readable_size(file_size)})")
+
+        return newly_added_files, char_count_delta
+
+    except Exception as e:
+        print(f"Warning: Could not analyze dependencies for {get_relative_path(file_just_added)}: {e}")
+        return [], 0
+
 def get_colored_code(file_path, code):
      try:
          lexer = get_lexer_for_filename(file_path)
@@ -540,7 +645,7 @@ def print_char_count(count):
     token_estimate = count // 4
     print(f"\rCurrent prompt size: {count} characters (~ {token_estimate} tokens)", flush=True)
 
-def select_files_in_directory(directory: str, ignore_patterns: List[str], current_char_count: int = 0) -> Tuple[List[FileTuple], int]:
+def select_files_in_directory(directory: str, ignore_patterns: List[str], project_root_abs: str, current_char_count: int = 0) -> Tuple[List[FileTuple], int]:
     files = [f for f in os.listdir(directory)
              if os.path.isfile(os.path.join(directory, f)) and not is_ignored(os.path.join(directory, f), ignore_patterns) and not is_binary(os.path.join(directory, f))]
 
@@ -561,7 +666,9 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
         print_char_count(current_char_count)
         choice = input("(y)es add all / (n)o ignore all / (s)elect individually / (q)uit? ").lower()
         selected_files: List[FileTuple] = []
+        char_count_delta = 0
         if choice == 'y':
+            files_to_add_after_loop = []
             for file in files:
                 file_path = os.path.join(directory, file)
                 if is_large_file(file_path):
@@ -571,14 +678,23 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                             break
                         print("Invalid choice. Please enter 'f' or 's'.")
                     if snippet_choice == 's':
-                        selected_files.append((file, True, None, get_language_for_file(file)))
-                        current_char_count += len(get_file_snippet(file_path))
+                        selected_files.append((file_path, True, None, get_language_for_file(file_path)))
+                        char_count_delta += len(get_file_snippet(file_path))
                     else:
-                        selected_files.append((file, False, None, get_language_for_file(file)))
-                        current_char_count += os.path.getsize(file_path)
+                        selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                        char_count_delta += os.path.getsize(file_path)
                 else:
-                    selected_files.append((file, False, None, get_language_for_file(file)))
-                    current_char_count += os.path.getsize(file_path)
+                    selected_files.append((file_path, False, None, get_language_for_file(file_path)))
+                    char_count_delta += os.path.getsize(file_path)
+                files_to_add_after_loop.append(file_path)
+
+            # Analyze dependencies after the loop
+            current_char_count += char_count_delta
+            for file_path in files_to_add_after_loop:
+                 new_deps, deps_char_count = _propose_and_add_dependencies(file_path, project_root_abs, selected_files, current_char_count)
+                 selected_files.extend(new_deps)
+                 current_char_count += deps_char_count
+
             print(f"Added all files from {directory}")
             return selected_files, current_char_count
         elif choice == 'n':
@@ -596,6 +712,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                         print_char_count(current_char_count)
                     file_choice = input(f"{file} ({file_size_readable}, ~{file_char_estimate} chars, ~{file_token_estimate} tokens) (y/n/p/q)? ").lower()
                     if file_choice == 'y':
+                        file_to_add = None
                         if is_large_file(file_path):
                             while True:
                                 snippet_choice = input(f"{file} is large. Use (f)ull content or (s)nippet? ").lower()
@@ -603,14 +720,21 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
                                     break
                                 print("Invalid choice. Please enter 'f' or 's'.")
                             if snippet_choice == 's':
-                                selected_files.append((file, True, None, get_language_for_file(file_path)))
+                                file_to_add = (file_path, True, None, get_language_for_file(file_path))
                                 current_char_count += len(get_file_snippet(file_path))
                             else:
-                                selected_files.append((file, False, None, get_language_for_file(file_path)))
+                                file_to_add = (file_path, False, None, get_language_for_file(file_path))
                                 current_char_count += file_char_estimate
                         else:
-                            selected_files.append((file, False, None, get_language_for_file(file_path)))
+                            file_to_add = (file_path, False, None, get_language_for_file(file_path))
                             current_char_count += file_char_estimate
+                        
+                        if file_to_add:
+                            selected_files.append(file_to_add)
+                            # Analyze dependencies immediately after adding
+                            new_deps, deps_char_count = _propose_and_add_dependencies(file_path, project_root_abs, selected_files, current_char_count)
+                            selected_files.extend(new_deps)
+                            current_char_count += deps_char_count
                         break
                     elif file_choice == 'n':
                         break
@@ -633,7 +757,7 @@ def select_files_in_directory(directory: str, ignore_patterns: List[str], curren
         else:
             print("Invalid choice. Please try again.")
 
-def process_directory(directory: str, ignore_patterns: List[str], current_char_count: int = 0) -> Tuple[List[FileTuple], Set[str], int]:
+def process_directory(directory: str, ignore_patterns: List[str], project_root_abs: str, current_char_count: int = 0) -> Tuple[List[FileTuple], Set[str], int]:
     files_to_include: List[FileTuple] = []
     processed_dirs: Set[str] = set()
 
@@ -647,10 +771,10 @@ def process_directory(directory: str, ignore_patterns: List[str], current_char_c
         print(f"\nExploring directory: {root}")
         choice = input("(y)es explore / (n)o skip / (q)uit? ").lower()
         if choice == 'y':
-            selected_files, current_char_count = select_files_in_directory(root, ignore_patterns, current_char_count)
-            for file_tuple in selected_files:
-                full_path = os.path.join(root, file_tuple[0])
-                files_to_include.append((full_path, file_tuple[1], file_tuple[2], file_tuple[3]))
+            # Pass project_root_abs down
+            selected_files, current_char_count = select_files_in_directory(root, ignore_patterns, project_root_abs, current_char_count)
+            # The paths in selected_files are already absolute now
+            files_to_include.extend(selected_files)
             processed_dirs.add(root)
         elif choice == 'n':
             dirs[:] = []  # Skip all subdirectories
@@ -763,29 +887,50 @@ def generate_prompt_template(files_to_include: List[FileTuple], ignore_patterns:
     prompt += "\n\n"
     prompt += "## Instructions for Achieving the Task\n\n"
     analysis_text = (
-        "1. **Confirm and Understand the Task**:\n"
-        "   - Rephrase the task in your own words to ensure understanding.\n"
-        "   - Ask for any necessary clarifications.\n"
-        "   - Once everything is clear, ask to proceed.\n\n"
-        "2. **Outline a Plan**:\n"
-        "   - Provide a brief plan on how to approach the task.\n"
-        "   - Make minimal incremental changes to maintain a working codebase at each step.\n"
-        "   - This is an iterative process aimed at achieving the task step by step.\n\n"
-        "3. **Implement Changes Iteratively**:\n"
-        "   - Apply changes in small, manageable increments.\n"
-        "   - Ensure the codebase remains functional after each change.\n"
-        "   - After each increment, verify stability before proceeding to the next step.\n\n"
-        "4. **Present Code Changes Clearly**:\n"
-        "   - Specify the file being modified at the beginning of each code block.\n"
-        "   - Format changes for clarity:\n"
-        "     - For small changes: Show only the changed lines with clear comments.\n"
-        "     - For larger changes: Provide the full new implementation of changed parts, using placeholders like `'// ... (rest of the function)'` for unchanged code.\n"
-        "   - Provide context by including important unchanged parts as needed.\n"
-        "   - Use clear comments to explain the changes and reference old code if helpful.\n\n"
-        "5. **Encourage User Testing and Collaboration**:\n"
-        "   - Ask the user to test the code on their machine after each change.\n"
-        "   - If debugging is needed, include debugging messages in the code.\n"
-        "   - Request the user to share any error messages or outputs from debugging to assist further.\n"
+        "### Your Operating Model: The Expert Council\n\n"
+        "You will operate as a council of expert personas in a direct, collaborative partnership with me, the user. Your entire thinking process should be externalized as a dialogue between these personas. Any persona can and should interact directly with me.\n\n"
+        "#### Core Personas\n"
+        "- **Facilitator**: The lead coordinator. You summarize discussions, ensure the team stays on track, and are responsible for presenting the final, consolidated plans and code to me.\n"
+        "- **Architect**: Focuses on high-level design, system structure, dependencies, scalability, and long-term maintainability. Asks 'Is this well-designed?'\n"
+        "- **Builder**: The hands-on engineer. Focuses on implementation details, writing clean and functional code, and debugging. Asks 'How do we build this?' **When presenting code obey Rules for Presenting Code**\n"
+        "- **Critique**: The quality advocate. Focuses on identifying edge cases, potential bugs, and security vulnerabilities. Asks 'What could go wrong?' and provides constructive critique on both the team's proposals and my (the user's) requests.\n\n"
+        "#### Dynamic Personas\n"
+        "When the task requires it, introduce other specialist personas. For example: UX Designer, DevOps Engineer, Data Scientist, etc.\n\n"
+        "### Development Workflow: A Structured Dialogue\n\n"
+        "Follow this conversational workflow. Prefix direct communication to me with the persona's name (e.g., 'Critique to User: ...').\n\n"
+        "1.  **Understand & Clarify (Dialogue)**\n"
+        "    - **Facilitator**: Start by stating the goal as you understand it.\n"
+        "    - **All**: Discuss the requirements. Any persona can directly ask me for clarification. Identify and list any missing information ([MISSING]) or assumptions ([ASSUMPTION]).\n"
+        "    - **Critique**: Directly challenge any part of my request that seems ambiguous, risky, or suboptimal.\n\n"
+        "2.  **Plan (Dialogue)**\n"
+        "    - **Architect**: Propose one or more high-level plans. Directly ask me for input on tradeoffs if necessary.\n"
+        "    - **Critique**: Challenge the plans. Point out risks or edge cases.\n"
+        "    - **Builder**: Comment on the implementation feasibility.\n"
+        "    - **Facilitator**: Synthesize the discussion, select the best plan, and present a clear, step-by-step summary to me for approval.\n\n"
+        "3.  **Implement (Code & Dialogue)**\n"
+        "    - **Facilitator**: State which step of the plan is being implemented.\n"
+        "    - **Builder**: Write the code. If you encounter an issue, you can ask me directly for more context.\n"
+        "    - **Critique**: Review the code and the underlying assumptions.\n"
+        "    - **Facilitator**: Present the final, reviewed code for that step. Ask me to test it if appropriate.\n\n"
+        "4.  **Present E2E Draft (Consolidation)**\n"
+        "    - When I ask you to consolidate, your goal is to provide a clear, unambiguous set of changes that I can directly copy and paste into my editor.\n"
+        "    - **Present changes grouped by file.** For each change, provide the **entire updated function, class, or logical block** to make replacement easy.\n"
+        "    - Use context comments to show where the new code block fits.\n"
+        "    - **Do not use a diff format (`+` or `-` lines).** Provide the final, clean code.\n\n"
+        "5.  **Validate & Iterate (Feedback Loop)**\n"
+        "    - After presenting the consolidated draft, you will explicitly prompt me for testing and wait for my feedback.\n"
+        "    - Upon receiving my feedback, the **Facilitator** will announce the next step.\n"
+        "    - If the feedback indicates a minor bug, you will return to **Step 3 (Implement)** to fix it.\n"
+        "    - If the feedback reveals a fundamental design flaw or misunderstanding, you will return to **Step 2 (Plan)** or even **Step 1 (Understand)** to re-evaluate the approach.\n\n"
+        "### Rules for Presenting Code\n\n"
+        "- **Always specify the filename** at the start of a code block (e.g., `// FILE: kopipasta/main.py`).\n"
+        "- **Incremental Changes**: During implementation, show only the changed functions or classes. Use comments like `// ... existing code ...` to represent unchanged parts.\n"
+        "- **Missing Files**: Never write placeholder code. Instead, state it's missing and request it.\n\n"
+        "### Your Permissions\n\n"
+        "- **You are empowered to interact with me directly.** Any persona can ask me questions or provide constructive feedback on my requests, assumptions, or the provided context.\n"
+        "- You MUST request any file shown in the project tree that you need but was not provided.\n"
+        "- You MUST ask me to run code, test integrations (APIs, databases), and share the output.\n"
+        "- You MUST ask for clarification instead of making risky assumptions.\n"
     )
     prompt += analysis_text
     return prompt, cursor_position
@@ -1032,6 +1177,8 @@ def main():
 
     ignore_patterns = read_gitignore()
     env_vars = read_env_file()
+    project_root_abs = os.path.abspath(os.getcwd())
+
 
     files_to_include: List[FileTuple] = []
     processed_dirs = set()
@@ -1074,53 +1221,59 @@ def main():
                 print(f"Added {'snippet of ' if is_snippet else ''}web content from: {input_path}")
                 print_char_count(current_char_count)
         elif os.path.isfile(input_path):
-            # Handle files provided directly via command line
-            if not is_ignored(input_path, ignore_patterns) and not is_binary(input_path):
-                file_size = os.path.getsize(input_path)
+            abs_input_path = os.path.abspath(input_path)
+            if not is_ignored(abs_input_path, ignore_patterns) and not is_binary(abs_input_path):
+                file_size = os.path.getsize(abs_input_path)
                 file_size_readable = get_human_readable_size(file_size)
                 file_char_estimate = file_size
-                language = get_language_for_file(input_path)
+                language = get_language_for_file(abs_input_path)
+                file_to_add = None
 
-                if is_large_file(input_path):
-                    print(f"\nFile {input_path} ({file_size_readable}, ~{file_char_estimate} chars) is large.")
+                if is_large_file(abs_input_path):
+                    print(f"\nFile {get_relative_path(abs_input_path)} ({file_size_readable}, ~{file_char_estimate} chars) is large.")
                     print("Preview (first ~50 lines or 4KB):")
-                    print(get_colored_file_snippet(input_path))
+                    print(get_colored_file_snippet(abs_input_path))
                     print("-" * 40)
                     while True:
                         print_char_count(current_char_count)
-                        choice = input(f"How to include large file {input_path}? (f)ull / (s)nippet / (p)atches / (n)o skip: ").lower()
+                        choice = input(f"How to include large file {get_relative_path(abs_input_path)}? (f)ull / (s)nippet / (p)atches / (n)o skip: ").lower()
                         if choice == 'f':
-                            files_to_include.append((input_path, False, None, language))
+                            file_to_add = (abs_input_path, False, None, language)
                             current_char_count += file_char_estimate
-                            print(f"Added full file: {input_path}")
+                            print(f"Added full file: {get_relative_path(abs_input_path)}")
                             break
                         elif choice == 's':
-                            snippet_content = get_file_snippet(input_path)
-                            files_to_include.append((input_path, True, None, language))
+                            snippet_content = get_file_snippet(abs_input_path)
+                            file_to_add = (abs_input_path, True, None, language)
                             current_char_count += len(snippet_content)
-                            print(f"Added snippet of file: {input_path}")
+                            print(f"Added snippet of file: {get_relative_path(abs_input_path)}")
                             break
                         elif choice == 'p':
-                            chunks, char_count = select_file_patches(input_path)
+                            chunks, char_count = select_file_patches(abs_input_path)
                             if chunks:
-                                files_to_include.append((input_path, False, chunks, language))
+                                file_to_add = (abs_input_path, False, chunks, language)
                                 current_char_count += char_count
-                                print(f"Added selected patches from file: {input_path}")
+                                print(f"Added selected patches from file: {get_relative_path(abs_input_path)}")
                             else:
-                                print(f"No patches selected for {input_path}. Skipping file.")
+                                print(f"No patches selected for {get_relative_path(abs_input_path)}. Skipping file.")
                             break
                         elif choice == 'n':
-                            print(f"Skipped large file: {input_path}")
+                            print(f"Skipped large file: {get_relative_path(abs_input_path)}")
                             break
                         else:
                             print("Invalid choice. Please enter 'f', 's', 'p', or 'n'.")
                 else:
-                    # Automatically include non-large files
-                    files_to_include.append((input_path, False, None, language))
+                    file_to_add = (abs_input_path, False, None, language)
                     current_char_count += file_char_estimate
-                    print(f"Added file: {input_path} ({file_size_readable})")
-
-                # Display current count after processing the file
+                    print(f"Added file: {get_relative_path(abs_input_path)} ({file_size_readable})")
+
+                if file_to_add:
+                    files_to_include.append(file_to_add)
+                    # --- NEW: Call dependency analysis ---
+                    new_deps, deps_char_count = _propose_and_add_dependencies(abs_input_path, project_root_abs, files_to_include, current_char_count)
+                    files_to_include.extend(new_deps)
+                    current_char_count += deps_char_count
+                
                 print_char_count(current_char_count)
 
             else:
@@ -1129,10 +1282,11 @@ def main():
                 elif is_binary(input_path):
                      print(f"Ignoring binary file: {input_path}")
                 else:
-                     print(f"Ignoring file: {input_path}") # Should not happen if logic is correct, but fallback.
+                     print(f"Ignoring file: {input_path}")
         elif os.path.isdir(input_path):
             print(f"\nProcessing directory specified directly: {input_path}")
-            dir_files, dir_processed, current_char_count = process_directory(input_path, ignore_patterns, current_char_count)
+            # Pass project_root_abs to process_directory
+            dir_files, dir_processed, current_char_count = process_directory(input_path, ignore_patterns, project_root_abs, current_char_count)
             files_to_include.extend(dir_files)
             processed_dirs.update(dir_processed)
         else:
@@ -1144,42 +1298,34 @@ def main():
 
     print("\nFile and web content selection complete.")
     print_char_count(current_char_count) # Print final count before prompt generation
-    print(f"Summary: Added {len(files_to_include)} files and {len(web_contents)} web sources.")
 
     added_files_count = len(files_to_include)
-    added_dirs_count = len(processed_dirs) # Count unique processed directories
+    added_dirs_count = len(processed_dirs)
     added_web_count = len(web_contents)
     print(f"Summary: Added {added_files_count} files/patches from {added_dirs_count} directories and {added_web_count} web sources.")
 
     prompt_template, cursor_position = generate_prompt_template(files_to_include, ignore_patterns, web_contents, env_vars)
 
-    # Logic branching for interactive mode vs. clipboard mode
     if args.interactive:
         print("\nPreparing initial prompt for editing...")
-        # Determine the initial content for the editor
         if args.task:
-            # Pre-populate the task section if --task was provided
             editor_initial_content = prompt_template[:cursor_position] + args.task + prompt_template[cursor_position:]
             print("Pre-populating editor with task provided via --task argument.")
         else:
-            # Use the template as is (user will add task in the editor)
             editor_initial_content = prompt_template
             print("Opening editor for you to add the task instructions.")
 
-        # Always open the editor in interactive mode
         initial_chat_prompt = open_editor_for_input(editor_initial_content, cursor_position)
         print("Editor closed. Starting interactive chat session...")
-        start_chat_session(initial_chat_prompt) # Start the chat with the edited prompt    else:
+        start_chat_session(initial_chat_prompt)
     else:
-        # Original non-interactive behavior
         if args.task:
             task_description = args.task
-            # Insert task description before "## Task Instructions"
             task_marker = "## Task Instructions\n\n"
             insertion_point = prompt_template.find(task_marker)
             if insertion_point != -1:
                 final_prompt = prompt_template[:insertion_point + len(task_marker)] + task_description + "\n\n" + prompt_template[insertion_point + len(task_marker):]
-            else: # Fallback if marker not found
+            else:
                 final_prompt = prompt_template[:cursor_position] + task_description + prompt_template[cursor_position:]
             print("\nUsing task description from -t argument.")
         else:
@@ -1191,7 +1337,6 @@ def main():
         print(final_prompt)
         print("-" * 80)
 
-        # Copy the prompt to clipboard
         try:
             pyperclip.copy(final_prompt)
             separator = "\n" + "=" * 40 + "\n☕🍝       Kopipasta Complete!       🍝☕\n" + "=" * 40 + "\n"

{kopipasta-0.25.0.dist-info → kopipasta-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kopipasta
-Version: 0.25.0
+Version: 0.27.0
 Summary: A CLI tool to generate prompts with project structure and file contents
 Home-page: https://github.com/mkorpela/kopipasta
 Author: Mikko Korpela

kopipasta-0.27.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kopipasta/import_parser.py,sha256=yLzkMlQm2avKjfqcpMY0PxbA_2ihV9gSYJplreWIPEQ,12424
+kopipasta/main.py,sha256=gTIPH5dScVKym_5QFrWE3gmChvrFaIgMJyvnTBxc_iI,62607
+kopipasta-0.27.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
+kopipasta-0.27.0.dist-info/METADATA,sha256=ubZEEhK8410J4kZ5x1MTAWfm2EXPO4NtLqbpUB44rcM,8610
+kopipasta-0.27.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+kopipasta-0.27.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
+kopipasta-0.27.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
+kopipasta-0.27.0.dist-info/RECORD,,

kopipasta-0.25.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-kopipasta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kopipasta/main.py,sha256=U4_31xXY2xzYZ-Exm1B6TYzofHfH3NU4iEq6XBHyBj0,53647
-kopipasta-0.25.0.dist-info/LICENSE,sha256=xw4C9TAU7LFu4r_MwSbky90uzkzNtRwAo3c51IWR8lk,1091
-kopipasta-0.25.0.dist-info/METADATA,sha256=03L8Zbl0k7pgrrSxL-_DsWbIT-zTRFkENabTcC1MHmo,8610
-kopipasta-0.25.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-kopipasta-0.25.0.dist-info/entry_points.txt,sha256=but54qDNz1-F8fVvGstq_QID5tHjczP7bO7rWLFkc6Y,50
-kopipasta-0.25.0.dist-info/top_level.txt,sha256=iXohixMuCdw8UjGDUp0ouICLYBDrx207sgZIJ9lxn0o,10
-kopipasta-0.25.0.dist-info/RECORD,,