autocoder-nano 0.1.30__py3-none-any.whl → 0.1.34__py3-none-any.whl

autocoder_nano/auto_coder_nano.py

@@ -5,16 +5,19 @@ import os
 import json
 import shutil
 import subprocess
-import textwrap
 import time
 import uuid
 
+from autocoder_nano.agent.agentic_edit import AgenticEdit
+from autocoder_nano.agent.agentic_edit_types import AgenticEditRequest
 from autocoder_nano.edit import Dispacher
 from autocoder_nano.helper import show_help
 from autocoder_nano.index.entry import build_index_and_filter_files
 from autocoder_nano.index.index_manager import IndexManager
 from autocoder_nano.index.symbols_utils import extract_symbols
 from autocoder_nano.llm_client import AutoLLM
+from autocoder_nano.rules.rules_learn import AutoRulesLearn
+from autocoder_nano.utils.completer_utils import CommandCompleter
 from autocoder_nano.version import __version__
 from autocoder_nano.llm_types import *
 from autocoder_nano.llm_prompt import prompt, extract_code
@@ -26,23 +29,20 @@ from autocoder_nano.project import PyProject, SuffixProject
 from autocoder_nano.utils.printer_utils import Printer
 
 import yaml
-# import tabulate
 from jinja2 import Template
-# from loguru import logger
 from prompt_toolkit import prompt as _toolkit_prompt, PromptSession
-from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.shortcuts import confirm
 from prompt_toolkit.styles import Style
-from rich.console import Console
+# from rich.console import Console
 from rich.live import Live
 from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.syntax import Syntax
-from rich.table import Table
+# from rich.table import Table
 from rich.text import Text
 
 
@@ -55,7 +55,8 @@ base_persist_dir = os.path.join(project_root, ".auto-coder", "plugins", "chat-au
 #                        ".vscode", ".idea", ".hg"]
 commands = [
     "/add_files", "/remove_files", "/list_files", "/conf", "/coding", "/chat", "/revert", "/index/query",
-    "/index/build", "/exclude_dirs", "/exclude_files", "/help", "/shell", "/exit", "/mode", "/models", "/commit", "/new"
+    "/index/build", "/exclude_dirs", "/exclude_files", "/help", "/shell", "/exit", "/mode", "/models", "/commit",
+    "/rules", "/auto"
 ]
 
 memory = {
@@ -177,599 +178,6 @@ def find_files_in_project(patterns: List[str]) -> List[str]:
     return list(set(matched_files))
 
 
-COMMANDS = {
-    "/add_files": {
-        "/group": {"/add": "", "/drop": "", "/reset": ""},
-        "/refresh": "",
-    },
-    "/remove_files": {"/all": ""},
-    "/coding": {"/apply": ""},
-    "/chat": {"/history": "", "/new": "", "/review": ""},
-    "/models": {
-        "/add_model": "",
-        "/remove": "",
-        "/list": "",
-        "/check": ""
-    },
-    "/help": {
-        "/add_files": "",
-        "/remove_files": "",
-        "/chat": "",
-        "/coding": "",
-        "/commit": "",
-        "/conf": "",
-        "/mode": "",
-        "/models": ""
-    },
-    "/exclude_files": {"/list": "", "/drop": ""},
-    "/exclude_dirs": {}
-}
-
-
-class CommandTextParser:
-    def __init__(self, text: str, command: str):
-        self.text = text
-        self.pos = -1
-        self.len = len(text)
-        self.is_extracted = False
-        self.current_word_start_pos = 0
-        self.current_word_end_pos = 0
-        self.in_current_sub_command = ""
-        self.completions = []
-        self.command = command
-        self.current_hiararchy = COMMANDS[command]
-        self.sub_commands = []
-        self.tags = []
-
-    def first_sub_command(self):
-        if len(self.sub_commands) == 0:
-            return None
-        return self.sub_commands[0]
-
-    def last_sub_command(self):
-        if len(self.sub_commands) == 0:
-            return None
-        return self.sub_commands[-1]
-
-    def peek(self):
-        if self.pos + 1 < self.len:
-            return self.text[self.pos + 1]
-        return None
-
-    def peek2(self):
-        if self.pos + 2 < self.len:
-            return self.text[self.pos + 2]
-        return None
-
-    def peek3(self):
-        if self.pos + 3 < self.len:
-            return self.text[self.pos + 3]
-        return None
-
-    def next(self):
-        if self.pos < self.len - 1:
-            self.pos += 1
-            char = self.text[self.pos]
-            return char
-        return None
-
-    def consume_blank(self):
-        while self.peek() == "\n" or self.peek() == " " or self.peek() == "\t" or self.peek() == "\r":
-            self.next()
-
-    def is_blank(self) -> bool:
-        return self.peek() == "\n" or self.peek() == " " or self.peek() == "\t" or self.peek() == "\r"
-
-    def is_sub_command(self) -> bool | None:
-        backup_pos = self.pos
-        self.consume_blank()
-        try:
-            if self.peek() == "/":
-                current_sub_command = ""
-                while self.peek() is not None and self.peek() != " " and self.peek() != "\n":
-                    current_sub_command += self.next()
-
-                if current_sub_command.count("/") > 1:
-                    self.pos = backup_pos
-                    return False
-                return True
-            return False
-        finally:
-            self.pos = backup_pos
-
-    def consume_sub_command(self) -> str:
-        # backup_pos = self.pos
-        self.consume_blank()
-        current_sub_command = ""
-        while self.peek() is not None and self.peek() != " " and self.peek() != "\n":
-            current_sub_command += self.next()
-
-        if self.peek() is None:
-            self.is_extracted = True
-            self.current_word_end_pos = self.pos + 1
-            self.current_word_start_pos = self.current_word_end_pos - len(
-                current_sub_command
-            )
-            self.in_current_sub_command = current_sub_command
-        else:
-            if current_sub_command in self.current_hiararchy:
-                self.current_hiararchy = self.current_hiararchy[current_sub_command]
-                self.sub_commands.append(current_sub_command)
-
-        return current_sub_command
-
-    def consume_command_value(self):
-        current_word = ""
-        while self.peek() is not None:
-            v = self.next()
-            if v == " ":
-                current_word = ""
-            else:
-                current_word += v
-        self.is_extracted = True
-        self.current_word_end_pos = self.pos + 1
-        self.current_word_start_pos = self.current_word_end_pos - len(current_word)
-
-    def previous(self):
-        if self.pos > 1:
-            return self.text[self.pos - 1]
-        return None
-
-    def is_start_tag(self) -> bool | None:
-        backup_pos = self.pos
-        tag = ""
-        try:
-            if self.peek() == "<" and self.peek2() != "/":
-                while (
-                        self.peek() is not None
-                        and self.peek() != ">"
-                        and not self.is_blank()
-                ):
-                    tag += self.next()
-                if self.peek() == ">":
-                    tag += self.next()
-                    return True
-                else:
-                    return False
-            return False
-        finally:
-            self.pos = backup_pos
-
-    def consume_tag(self):
-        start_tag = ""
-        content = ""
-        end_tag = ""
-
-        # consume start tag
-        self.current_word_start_pos = self.pos + 1
-        while self.peek() is not None and self.peek() != ">" and not self.is_blank():
-            start_tag += self.next()
-        if self.peek() == ">":
-            start_tag += self.next()
-        self.current_word_end_pos = self.pos + 1
-        tag = Tag(start_tag=start_tag, content=content, end_tag=end_tag)
-        self.tags.append(tag)
-
-        # consume content
-        self.current_word_start_pos = self.pos + 1
-        while self.peek() is not None and not (
-                self.peek() == "<" and self.peek2() == "/"
-        ):
-            content += self.next()
-
-        tag.content = content
-        self.current_word_end_pos = self.pos + 1
-
-        # consume end tag
-        self.current_word_start_pos = self.pos + 1
-        if self.peek() == "<" and self.peek2() == "/":
-            while (
-                    self.peek() is not None and self.peek() != ">" and not self.is_blank()
-            ):
-                end_tag += self.next()
-            if self.peek() == ">":
-                end_tag += self.next()
-        tag.end_tag = end_tag
-        self.current_word_end_pos = self.pos + 1
-
-        # check is finished
-        if self.peek() is None:
-            self.is_extracted = True
-
-    def consume_coding_value(self):
-        current_word = ""
-        while self.peek() is not None and not self.is_start_tag():
-            v = self.next()
-            if v == " ":
-                current_word = ""
-            else:
-                current_word += v
-        if self.peek() is None:
-            self.is_extracted = True
-
-        self.current_word_end_pos = self.pos + 1
-        self.current_word_start_pos = self.current_word_end_pos - len(current_word)
-
-    def current_word(self) -> str:
-        return self.text[self.current_word_start_pos: self.current_word_end_pos]
-
-    def get_current_word(self) -> str:
-        return self.current_word()
-
-    def get_sub_commands(self) -> list[str]:
-        if self.get_current_word() and not self.get_current_word().startswith("/"):
-            return []
-
-        if isinstance(self.current_hiararchy, str):
-            return []
-
-        return [item for item in list(self.current_hiararchy.keys()) if item]
-
-    def add_files(self):
-        """
-        for exmaple:
-        /add_files file1 file2 file3
-        /add_files /group/abc/cbd /group/abc/bc2
-        /add_files /group1 /add xxxxx
-        /add_files /group
-        /add_files /group /add <groupname>
-        /add_files /group /drop <groupname>
-        /add_files /group <groupname>,<groupname>
-        /add_files /refresh
-        """
-        while True:
-            if self.pos == self.len - 1:
-                break
-            elif self.is_extracted:
-                break
-            elif self.is_sub_command():
-                self.consume_sub_command()
-            else:
-                self.consume_command_value()
-        return self
-
-    def coding(self):
-        while True:
-            if self.pos == self.len - 1:
-                break
-            elif self.is_extracted:
-                break
-            elif self.is_sub_command():
-                self.consume_sub_command()
-            elif self.is_start_tag():
-                self.consume_tag()
-            else:
-                self.consume_coding_value()
-
-
-class CommandCompleter(Completer):
-    def __init__(self, _commands):
-        self.commands = _commands
-        self.all_file_names = get_all_file_names_in_project()
-        self.all_files = get_all_file_in_project()
-        self.all_dir_names = get_all_dir_names_in_project()
-        self.all_files_with_dot = get_all_file_in_project_with_dot()
-        self.symbol_list = get_symbol_list()
-        self.current_file_names = []
-
-    def get_completions(self, document, complete_event):
-        text = document.text_before_cursor
-        words = text.split()
-
-        if len(words) > 0:
-            if words[0] == "/mode":
-                left_word = text[len("/mode"):]
-                for mode in ["normal", "auto_detect"]:
-                    if mode.startswith(left_word.strip()):
-                        yield Completion(mode, start_position=-len(left_word.strip()))
-
-            if words[0] == "/add_files":
-                new_text = text[len("/add_files"):]
-                parser = CommandTextParser(new_text, words[0])
-                parser.add_files()
-                current_word = parser.current_word()
-
-                if parser.last_sub_command() == "/refresh":
-                    return
-
-                for command in parser.get_sub_commands():
-                    if command.startswith(current_word):
-                        yield Completion(command, start_position=-len(current_word))
-
-                if parser.first_sub_command() == "/group" and (
-                        parser.last_sub_command() == "/group"
-                        or parser.last_sub_command() == "/drop"
-                ):
-                    group_names = memory["current_files"]["groups"].keys()
-                    if "," in current_word:
-                        current_word = current_word.split(",")[-1]
-
-                    for group_name in group_names:
-                        if group_name.startswith(current_word):
-                            yield Completion(
-                                group_name, start_position=-len(current_word)
-                            )
-
-                if parser.first_sub_command() != "/group":
-                    if current_word and current_word.startswith("."):
-                        for file_name in self.all_files_with_dot:
-                            if file_name.startswith(current_word):
-                                yield Completion(file_name, start_position=-len(current_word))
-                    else:
-                        for file_name in self.all_file_names:
-                            if file_name.startswith(current_word):
-                                yield Completion(file_name, start_position=-len(current_word))
-                        for file_name in self.all_files:
-                            if current_word and current_word in file_name:
-                                yield Completion(file_name, start_position=-len(current_word))
-
-            elif words[0] in ["/chat", "/coding"]:
-                image_extensions = (
-                    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".tif", ".webp", ".svg", ".ico",
-                    ".heic", ".heif", ".raw", ".cr2", ".nef", ".arw", ".dng", ".orf", ".rw2", ".pef",
-                    ".srw", ".eps", ".ai", ".psd", ".xcf",
-                )
-                new_text = text[len(words[0]):]
-                parser = CommandTextParser(new_text, words[0])
-
-                parser.coding()
-                current_word = parser.current_word()
-
-                if len(new_text.strip()) == 0 or new_text.strip() == "/":
-                    for command in parser.get_sub_commands():
-                        if command.startswith(current_word):
-                            yield Completion(command, start_position=-len(current_word))
-
-                all_tags = parser.tags
-
-                if current_word.startswith("@"):
-                    name = current_word[1:]
-                    target_set = set()
-
-                    for file_name in self.current_file_names:
-                        base_file_name = os.path.basename(file_name)
-                        if name in base_file_name:
-                            target_set.add(base_file_name)
-                            path_parts = file_name.split(os.sep)
-                            display_name = (
-                                os.sep.join(path_parts[-3:])
-                                if len(path_parts) > 3
-                                else file_name
-                            )
-                            relative_path = os.path.relpath(
-                                file_name, project_root)
-                            yield Completion(
-                                relative_path,
-                                start_position=-len(name),
-                                display=f"{display_name} (in active files)",
-                            )
-
-                    for file_name in self.all_file_names:
-                        if file_name.startswith(name) and file_name not in target_set:
-                            target_set.add(file_name)
-
-                            path_parts = file_name.split(os.sep)
-                            display_name = (
-                                os.sep.join(path_parts[-3:])
-                                if len(path_parts) > 3
-                                else file_name
-                            )
-                            relative_path = os.path.relpath(
-                                file_name, project_root)
-
-                            yield Completion(
-                                relative_path,
-                                start_position=-len(name),
-                                display=f"{display_name}",
-                            )
-
-                    for file_name in self.all_files:
-                        if name in file_name and file_name not in target_set:
-                            path_parts = file_name.split(os.sep)
-                            display_name = (
-                                os.sep.join(path_parts[-3:])
-                                if len(path_parts) > 3
-                                else file_name
-                            )
-                            relative_path = os.path.relpath(
-                                file_name, project_root)
-                            yield Completion(
-                                relative_path,
-                                start_position=-len(name),
-                                display=f"{display_name}",
-                            )
-
-                if current_word.startswith("@@"):
-                    name = current_word[2:]
-                    for symbol in self.symbol_list:
-                        if name in symbol.symbol_name:
-                            file_name = symbol.file_name
-                            path_parts = file_name.split(os.sep)
-                            display_name = (
-                                os.sep.join(path_parts[-3:])
-                                if len(path_parts) > 3
-                                else symbol.symbol_name
-                            )
-                            relative_path = os.path.relpath(
-                                file_name, project_root)
-                            yield Completion(
-                                f"{symbol.symbol_name}(location: {relative_path})",
-                                start_position=-len(name),
-                                display=f"{symbol.symbol_name} ({display_name}/{symbol.symbol_type})",
-                            )
-
-                tags = [tag for tag in parser.tags]
-
-                if current_word.startswith("<"):
-                    name = current_word[1:]
-                    for tag in ["<img>", "</img>"]:
-                        if all_tags and all_tags[-1].start_tag == "<img>":
-                            if tag.startswith(name):
-                                yield Completion(
-                                    "</img>", start_position=-len(current_word)
-                                )
-                        elif tag.startswith(name):
-                            yield Completion(tag, start_position=-len(current_word))
-
-                if tags and tags[-1].start_tag == "<img>" and tags[-1].end_tag == "":
-                    raw_file_name = tags[0].content
-                    file_name = raw_file_name.strip()
-                    parent_dir = os.path.dirname(file_name)
-                    file_basename = os.path.basename(file_name)
-                    search_dir = parent_dir if parent_dir else "."
-                    for root, dirs, files in os.walk(search_dir):
-                        # 只处理直接子目录
-                        if root != search_dir:
-                            continue
-
-                        # 补全子目录
-                        for _dir in dirs:
-                            full_path = os.path.join(root, _dir)
-                            if full_path.startswith(file_name):
-                                relative_path = os.path.relpath(full_path, search_dir)
-                                yield Completion(relative_path, start_position=-len(file_basename))
-
-                        # 补全文件
-                        for file in files:
-                            if file.lower().endswith(
-                                    image_extensions
-                            ) and file.startswith(file_basename):
-                                full_path = os.path.join(root, file)
-                                relative_path = os.path.relpath(full_path, search_dir)
-                                yield Completion(
-                                    relative_path,
-                                    start_position=-len(file_basename),
-                                )
-
-                        # 只处理一层子目录，然后退出循环
-                        break
-
-            elif words[0] == "/remove_files":
-                new_words = text[len("/remove_files"):].strip().split(",")
-
-                is_at_space = text[-1] == " "
-                last_word = new_words[-2] if len(new_words) > 1 else ""
-                current_word = new_words[-1] if new_words else ""
-
-                if is_at_space:
-                    last_word = current_word
-                    current_word = ""
-
-                # /remove_files /all [cursor] or /remove_files /all p[cursor]
-                if not last_word and not current_word:
-                    if "/all".startswith(current_word):
-                        yield Completion("/all", start_position=-len(current_word))
-                    for file_name in self.current_file_names:
-                        yield Completion(file_name, start_position=-len(current_word))
-
-                # /remove_files /a[cursor] or /remove_files p[cursor]
-                if current_word:
-                    if "/all".startswith(current_word):
-                        yield Completion("/all", start_position=-len(current_word))
-                    for file_name in self.current_file_names:
-                        if current_word and current_word in file_name:
-                            yield Completion(
-                                file_name, start_position=-len(current_word)
-                            )
-
-            elif words[0] == "/exclude_dirs":
-                new_words = text[len("/exclude_dirs"):].strip().split(",")
-                current_word = new_words[-1]
-
-                for file_name in self.all_dir_names:
-                    if current_word and current_word in file_name:
-                        yield Completion(file_name, start_position=-len(current_word))
-
-            elif words[0] == "/exclude_files":
-                new_text = text[len("/exclude_files"):]
-                parser = CommandTextParser(new_text, words[0])
-                parser.add_files()
-                current_word = parser.current_word()
-                for command in parser.get_sub_commands():
-                    if command.startswith(current_word):
-                        yield Completion(command, start_position=-len(current_word))
-
-            elif words[0] == "/models":
-                new_text = text[len("/models"):]
-                parser = CommandTextParser(new_text, words[0])
-                parser.add_files()
-                current_word = parser.current_word()
-                for command in parser.get_sub_commands():
-                    if command.startswith(current_word):
-                        yield Completion(command, start_position=-len(current_word))
-
-            elif words[0] == "/help":
-                new_text = text[len("/help"):]
-                parser = CommandTextParser(new_text, words[0])
-                parser.add_files()
-                current_word = parser.current_word()
-                for command in parser.get_sub_commands():
-                    if command.startswith(current_word):
-                        yield Completion(command, start_position=-len(current_word))
-
-            elif words[0] == "/conf":
-                new_words = text[len("/conf"):].strip().split()
-                is_at_space = text[-1] == " "
-                last_word = new_words[-2] if len(new_words) > 1 else ""
-                current_word = new_words[-1] if new_words else ""
-                completions = []
-
-                if is_at_space:
-                    last_word = current_word
-                    current_word = ""
-
-                # /conf /drop [curor] or /conf /drop p[cursor]
-                if last_word == "/drop":
-                    completions = [
-                        field_name
-                        for field_name in memory["conf"].keys()
-                        if field_name.startswith(current_word)
-                    ]
-                # /conf [curosr]
-                elif not last_word and not current_word:
-                    completions = [
-                        "/drop"] if "/drop".startswith(current_word) else []
-                    completions += [
-                        field_name + ":"
-                        for field_name in AutoCoderArgs.model_fields.keys()
-                        if field_name.startswith(current_word)
-                    ]
-                # /conf p[cursor]
-                elif not last_word and current_word:
-                    completions = [
-                        "/drop"] if "/drop".startswith(current_word) else []
-                    completions += [
-                        field_name + ":"
-                        for field_name in AutoCoderArgs.model_fields.keys()
-                        if field_name.startswith(current_word)
-                    ]
-
-                for completion in completions:
-                    yield Completion(completion, start_position=-len(current_word))
-
-            else:
-                for command in self.commands:
-                    if command.startswith(text):
-                        yield Completion(command, start_position=-len(text))
-        else:
-            for command in self.commands:
-                if command.startswith(text):
-                    yield Completion(command, start_position=-len(text))
-
-    def update_current_files(self, files):
-        self.current_file_names = [f for f in files]
-
-    def refresh_files(self):
-        self.all_file_names = get_all_file_names_in_project()
-        self.all_files = get_all_file_in_project()
-        self.all_dir_names = get_all_dir_names_in_project()
-        self.all_files_with_dot = get_all_file_in_project_with_dot()
-        self.symbol_list = get_symbol_list()
-
-
-completer = CommandCompleter(commands)
-
-
 def save_memory():
     with open(os.path.join(base_persist_dir, "nano-memory.json"), "w") as fp:
         json_str = json.dumps(memory, indent=2, ensure_ascii=False)
@@ -783,7 +191,28 @@ def load_memory():
     if os.path.exists(memory_path):
         with open(memory_path, "r") as f:
             memory = json.load(f)
-    completer.update_current_files(memory["current_files"]["files"])
+
+
+def get_memory():
+    load_memory()
+    return memory
+
+
+completer = CommandCompleter(
+    commands=commands,
+    file_system_model=FileSystemModel(
+        project_root=project_root,
+        get_all_file_names_in_project=get_all_file_names_in_project,
+        get_all_file_in_project=get_all_file_in_project,
+        get_all_dir_names_in_project=get_all_dir_names_in_project,
+        get_all_file_in_project_with_dot=get_all_file_in_project_with_dot,
+        get_symbol_list=get_symbol_list
+    ),
+    memory_model=MemoryConfig(
+        get_memory_func=get_memory,
+        save_memory_func=save_memory
+    )
+)
 
 
 def exclude_dirs(dir_names: List[str]):
@@ -929,22 +358,6 @@ def index_import(import_path: str):
         return False
 
 
-def wrap_text_in_table(data, max_width=60):
-    """
-    Wraps text in each cell of the table to a specified width.
-
-    :param data: A list of lists, where each inner list represents a row in the table.
-    :param max_width: The maximum width of text in each cell.
-    :return: A new table data with wrapped text.
-    """
-    wrapped_data = []
-    for row in data:
-        wrapped_row = [textwrap.fill(str(cell), width=max_width) for cell in row]
-        wrapped_data.append(wrapped_row)
-
-    return wrapped_data
-
-
 def index_query_command(query: str, llm: AutoLLM):
     update_config_to_args(query=query, delete_execute_file=True)
 
@@ -1259,6 +672,7 @@ def init_project():
         return
     os.makedirs(os.path.join(args.source_dir, "actions"), exist_ok=True)
     os.makedirs(os.path.join(args.source_dir, ".auto-coder"), exist_ok=True)
+    os.makedirs(os.path.join(args.source_dir, ".auto-coder", "autocoderrules"), exist_ok=True)
     source_dir = os.path.abspath(args.source_dir)
     create_actions(
         source_dir=source_dir,
@@ -1307,7 +721,7 @@ def load_include_files(config, base_path, max_depth=10, current_depth=0):
 
         for include_file in include_files:
             abs_include_path = resolve_include_path(base_path, include_file)
-            printer.print_text(f"正在加载 Include file: {abs_include_path}", style="green")
+            # printer.print_text(f"正在加载 Include file: {abs_include_path}", style="green")
             with open(abs_include_path, "r") as f:
                 include_config = yaml.safe_load(f)
                 if not include_config:
@@ -1369,14 +783,9 @@ def coding(query: str, llm: AutoLLM):
 
     memory["conversation"].append({"role": "user", "content": query})
     conf = memory.get("conf", {})
-
     current_files = memory["current_files"]["files"]
-    current_groups = memory["current_files"].get("current_groups", [])
-    groups = memory["current_files"].get("groups", {})
-    groups_info = memory["current_files"].get("groups_info", {})
 
     prepare_chat_yaml()  # 复制上一个序号的 yaml 文件, 生成一个新的聊天 yaml 文件
-
     latest_yaml_file = get_last_yaml_file(os.path.join(args.source_dir, "actions"))
 
     if latest_yaml_file:
@@ -1398,19 +807,6 @@ def coding(query: str, llm: AutoLLM):
         yaml_config["urls"] = current_files
         yaml_config["query"] = query
 
-        if current_groups:
-            active_groups_context = "下面是对上面文件按分组给到的一些描述，当用户的需求正好匹配描述的时候，参考描述来做修改：\n"
-            for group in current_groups:
-                group_files = groups.get(group, [])
-                query_prefix = groups_info.get(group, {}).get("query_prefix", "")
-                active_groups_context += f"组名: {group}\n"
-                active_groups_context += f"文件列表:\n"
-                for file in group_files:
-                    active_groups_context += f"- {file}\n"
-                active_groups_context += f"组描述: {query_prefix}\n\n"
-
-            yaml_config["context"] = active_groups_context + "\n"
-
         if is_apply:
             memory_dir = os.path.join(args.source_dir, ".auto-coder", "memory")
             os.makedirs(memory_dir, exist_ok=True)
@@ -1441,6 +837,19 @@ def coding(query: str, llm: AutoLLM):
                     yaml_config["context"] += f"你: {conv['content']}\n"
             yaml_config["context"] += "</history>\n"
 
+        if args.enable_rules:
+            rules_dir_path = os.path.join(project_root, ".auto-coder", "autocoderrules")
+            printer.print_text("已开启 Rules 模式", style="green")
+            yaml_config["context"] += f"下面是我们对代码进行深入分析,提取具有通用价值的功能模式和设计模式,可在其他需求中复用的Rules\n"
+            yaml_config["context"] += "你在编写代码时可以参考以下Rules\n"
+            yaml_config["context"] += "<rules>\n"
+            for rules_name in os.listdir(rules_dir_path):
+                printer.print_text(f"正在加载 Rules:{rules_name}", style="green")
+                rules_file_path = os.path.join(rules_dir_path, rules_name)
+                with open(rules_file_path, "r") as fp:
+                    yaml_config["context"] += f"{fp.read()}\n"
+            yaml_config["context"] += "</rules>\n"
+
         yaml_config["file"] = latest_yaml_file
         yaml_content = convert_yaml_config_to_str(yaml_config=yaml_config)
         execute_file = os.path.join(args.source_dir, "actions", latest_yaml_file)
@@ -1572,6 +981,20 @@ def commit_info(query: str, llm: AutoLLM):
                 os.remove(execute_file)
 
 
+def agentic_edit(query: str, llm: AutoLLM):
+    update_config_to_args(query=query, delete_execute_file=True)
+
+    sources = SourceCodeList([])
+    agentic_editor = AgenticEdit(
+        args=args, llm=llm, files=sources, history_conversation=[]
+    )
+
+    query = query.strip()
+    request = AgenticEditRequest(user_input=query)
+
+    agentic_editor.run_in_terminal(request)
+
+
 @prompt()
 def _generate_shell_script(user_input: str) -> str:
     """
@@ -2224,71 +1647,100 @@ def configure_project_model():
     )
 
 
-# def new_project(query, llm):
-#     console.print(f"正在基于你的需求 {query} 构建项目 ...", style="bold green")
-#     env_info = detect_env()
-#     project = BuildNewProject(args=args, llm=llm,
-#                               chat_model=memory["conf"]["chat_model"],
-#                               code_model=memory["conf"]["code_model"])
-#
-#     console.print(f"正在完善项目需求 ...", style="bold green")
-#
-#     information = project.build_project_information(query, env_info, args.project_type)
-#     if not information:
-#         raise Exception(f"项目需求未正常生成 .")
-#
-#     table = Table(title=f"{query}")
-#     table.add_column("需求说明", style="cyan")
-#     table.add_row(f"{information[:50]}...")
-#     console.print(table)
-#
-#     console.print(f"正在完善项目架构 ...", style="bold green")
-#     architecture = project.build_project_architecture(query, env_info, args.project_type, information)
-#
-#     console.print(f"正在构建项目索引 ...", style="bold green")
-#     index_file_list = project.build_project_index(query, env_info, args.project_type, information, architecture)
-#
-#     table = Table(title=f"索引列表")
-#     table.add_column("路径", style="cyan")
-#     table.add_column("用途", style="cyan")
-#     for index_file in index_file_list.file_list:
-#         table.add_row(index_file.file_path, index_file.purpose)
-#     console.print(table)
-#
-#     for index_file in index_file_list.file_list:
-#         full_path = os.path.join(args.source_dir, index_file.file_path)
-#
-#         # 获取目录路径
-#         full_dir_path = os.path.dirname(full_path)
-#         if not os.path.exists(full_dir_path):
-#             os.makedirs(full_dir_path)
-#
-#         console.print(f"正在编码: {full_path} ...", style="bold green")
-#         code = project.build_single_code(query, env_info, args.project_type, information, architecture, index_file)
-#
-#         with open(full_path, "w") as fp:
-#             fp.write(code)
-#
-#     # 生成 readme
-#     readme_context = information + architecture
-#     readme_path = os.path.join(args.source_dir, "README.md")
-#     with open(readme_path, "w") as fp:
-#         fp.write(readme_context)
-#
-#     console.print(f"项目构建完成", style="bold green")
+def rules(query_args: List[str], llm: AutoLLM):
+    """
+    /rules 命令帮助:
+    /rules /list            - 列出规则文件
+    /rules /show            - 查看规则文件内容
+    /rules /remove          - 删除规则文件
+    /rules /analyze         - 分析当前文件，可选提供查询内容
+    /rules /commit <提交ID>  - 分析特定提交，必须提供提交ID和查询内容
+    """
+    update_config_to_args(query="", delete_execute_file=True)
+    rules_dir_path = os.path.join(project_root, ".auto-coder", "autocoderrules")
+    if query_args[0] == "/list":
+        printer.print_table_compact(
+            data=[[rules_name] for rules_name in os.listdir(rules_dir_path)],
+            title="Rules 列表",
+            headers=["Rules 文件"],
+            center=True
+        )
+
+    if query_args[0] == "/remove":
+        remove_rules_name = query_args[1].strip()
+        remove_rules_path = os.path.join(rules_dir_path, remove_rules_name)
+        if os.path.exists(remove_rules_path):
+            os.remove(remove_rules_path)
+            printer.print_text(f"Rules 文件[{remove_rules_name}]移除成功", style="green")
+        else:
+            printer.print_text(f"Rules 文件[{remove_rules_name}]不存在", style="yellow")
+
+    if query_args[0] == "/show":  # /rules /show 参数检查
+        show_rules_name = query_args[1].strip()
+        show_rules_path = os.path.join(rules_dir_path, show_rules_name)
+        if os.path.exists(show_rules_path):
+            with open(show_rules_path, "r") as fp:
+                printer.print_markdown(text=fp.read(), panel=True)
+        else:
+            printer.print_text(f"Rules 文件[{show_rules_name}]不存在", style="yellow")
+
+    if query_args[0] == "/commit":
+        commit_id = query_args[1].strip()
+        auto_learn = AutoRulesLearn(llm=llm, args=args)
+
+        try:
+            result = auto_learn.analyze_commit_changes(commit_id=commit_id, conversations=[])
+            rules_file = os.path.join(rules_dir_path, f"rules-commit-{uuid.uuid4()}.md")
+            with open(rules_file, "w", encoding="utf-8") as f:
+                f.write(result)
+            printer.print_text(f"代码变更[{commit_id}]生成 Rules 成功", style="green")
+        except Exception as e:
+            printer.print_text(f"代码变更[{commit_id}]生成 Rules 失败: {e}", style="red")
+
+    if query_args[0] == "/analyze":
+        auto_learn = AutoRulesLearn(llm=llm, args=args)
+
+        files = memory.get("current_files", {}).get("files", [])
+        if not files:
+            printer.print_text("当前无活跃文件用于生成 Rules", style="yellow")
+            return
+
+        sources = SourceCodeList([])
+        for file in files:
+            try:
+                with open(file, "r", encoding="utf-8") as f:
+                    source_code = f.read()
+                    sources.sources.append(SourceCode(module_name=file, source_code=source_code))
+            except Exception as e:
+                printer.print_text(f"读取文件生成 Rules 失败: {e}", style="yellow")
+                continue
+
+        try:
+            result = auto_learn.analyze_modules(sources=sources, conversations=[])
+            rules_file = os.path.join(rules_dir_path, f"rules-modules-{uuid.uuid4()}.md")
+            with open(rules_file, "w", encoding="utf-8") as f:
+                f.write(result)
+            printer.print_text(f"活跃文件[Files:{len(files)}]生成 Rules 成功", style="green")
+        except Exception as e:
+            printer.print_text(f"活跃文件生成 Rules 失败: {e}", style="red")
+
+    completer.refresh_files()
 
 
 def is_old_version():
-    """
-    __version__ = "0.1.26" 开始使用兼容 AutoCoder 的 chat_model, code_model 参数
-    不再使用 current_chat_model 和 current_chat_model
-    """
+    # "0.1.26" 开始使用兼容 AutoCoder 的 chat_model, code_model 参数
+    # 不再使用 current_chat_model 和 current_chat_model
     if 'current_chat_model' in memory['conf'] and 'current_code_model' in memory['conf']:
-        printer.print_text(f"您当前使用的版本偏低 {__version__}, 正在进行配置兼容性处理", style="yellow")
+        printer.print_text(f"0.1.26 新增 chat_model, code_model 参数, 正在进行配置兼容性处理", style="yellow")
         memory['conf']['chat_model'] = memory['conf']['current_chat_model']
         memory['conf']['code_model'] = memory['conf']['current_code_model']
         del memory['conf']['current_chat_model']
         del memory['conf']['current_code_model']
+    # "0.1.31" 在 .auto-coder 目录中新增 autocoderrules 目录
+    rules_dir_path = os.path.join(project_root, ".auto-coder", "autocoderrules")
+    if not os.path.exists(rules_dir_path):
+        printer.print_text(f"0.1.31 .auto-coder 目录中新增 autocoderrules 目录, 正在进行配置兼容性处理", style="yellow")
+        os.makedirs(rules_dir_path, exist_ok=True)
 
 
 def main():
@@ -2301,6 +1753,7 @@ def main():
 
     load_memory()
     is_old_version()
+    completer.update_current_files(memory["current_files"]["files"])
 
     if len(memory["models"]) == 0:
         _model_pass = input(f"  是否跳过模型配置(y/n): ").strip().lower()
@@ -2453,6 +1906,12 @@ def main():
             elif user_input.startswith("/commit"):
                 query = user_input[len("/commit"):].strip()
                 commit_info(query, auto_llm)
+            elif user_input.startswith("/rules"):
+                query_args = user_input[len("/rules"):].strip().split()
+                if not query_args:
+                    printer.print_text("Please enter your request.", style="yellow")
+                    continue
+                rules(query_args=query_args, llm=auto_llm)
             elif user_input.startswith("/help"):
                 query = user_input[len("/help"):].strip()
                 show_help(query)
@@ -2461,15 +1920,15 @@ def main():
             elif user_input.startswith("/coding"):
                 query = user_input[len("/coding"):].strip()
                 if not query:
-                    print("\033[91mPlease enter your request.\033[0m")
+                    printer.print_text("Please enter your request.", style="yellow")
                     continue
                 coding(query=query, llm=auto_llm)
-            # elif user_input.startswith("/new"):
-            #     query = user_input[len("/new"):].strip()
-            #     if not query:
-            #         print("\033[91mPlease enter your request.\033[0m")
-            #         continue
-            #     new_project(query=query, llm=auto_llm)
+            elif user_input.startswith("/auto"):
+                query = user_input[len("/auto"):].strip()
+                if not query:
+                    print("\033[91mPlease enter your request.\033[0m")
+                    continue
+                agentic_edit(query=query, llm=auto_llm)
             elif user_input.startswith("/chat"):
                 query = user_input[len("/chat"):].strip()
                 if not query: