Aider
从源码学会它怎么工作

   88  class Coder:
   89      abs_fnames = None
   90      abs_read_only_fnames = None
   91      repo = None
   92      last_aider_commit_hash = None
   93      aider_edited_files = None
   94      last_asked_for_commit_time = 0
   95      repo_map = None
   96      functions = None
   97      num_exhausted_context_windows = 0
   98      num_malformed_responses = 0
   99      last_keyboard_interrupt = None
  100      num_reflections = 0
  101      max_reflections = 3
  102      edit_format = None
  103      yield_stream = False
  104      temperature = None
  105      auto_lint = True
  106      auto_test = False

 1530          self.io.tool_output()
 1531  
 1532          self.show_usage_report()
 1533  
 1534          self.add_assistant_reply_to_cur_messages()
 1535  
 1536          if exhausted:
 1537              if self.cur_messages and self.cur_messages[-1]["role"] == "user":
 1538                  self.cur_messages += [
 1539                      dict(
 1540                          role="assistant",
 1541                          content="FinishReasonLength exception: you sent too many tokens",
 1542                      ),
 1543                  ]
 1544  
 1545              self.show_exhausted_error()
 1546              self.num_exhausted_context_windows += 1
 1547              return
 1548  
 1549          if self.partial_response_function_call:
 1550              args = self.parse_partial_args()
 1551              if args:
 1552                  content = args.get("explanation") or ""
 1553              else:
 1554                  content = ""
      … 58 lines omitted; exact range 1530–1623 …
 1613                  dict(role="assistant", content="Ok"),
 1614              ]
 1615  
 1616          if edited and self.auto_test:
 1617              test_errors = self.commands.cmd_test(self.test_cmd)
 1618              self.test_outcome = not test_errors
 1619              if test_errors:
 1620                  ok = self.io.confirm_ask("Attempt to fix test errors?")
 1621                  if ok:
 1622                      self.reflected_message = test_errors
 1623                      return

  985      def send_completion(self, messages, functions, stream, temperature=None):
  986          if os.environ.get("AIDER_SANITY_CHECK_TURNS"):
  987              sanity_check_messages(messages)
  988  
  989          if self.is_deepseek_r1():
  990              messages = ensure_alternating_roles(messages)
  991  
  992          kwargs = dict(
  993              model=self.name,
  994              stream=stream,
  995          )
  996  
  997          if self.use_temperature is not False:
  998              if temperature is None:
  999                  if isinstance(self.use_temperature, bool):
 1000                      temperature = 0
 1001                  else:
 1002                      temperature = float(self.use_temperature)
 1003  
 1004              kwargs["temperature"] = temperature
 1005  
 1006          if functions is not None:
 1007              function = functions[0]
 1008              kwargs["tools"] = [dict(type="function", function=function)]
 1009              kwargs["tool_choice"] = {"type": "function", "function": {"name": function["name"]}}
      … 17 lines omitted; exact range 985–1037 …
 1027          if "GITHUB_COPILOT_TOKEN" in os.environ:
 1028              if "extra_headers" not in kwargs:
 1029                  kwargs["extra_headers"] = {
 1030                      "Editor-Version": f"aider/{__version__}",
 1031                      "Copilot-Integration-Id": "vscode-chat",
 1032                  }
 1033  
 1034              self.github_copilot_token_to_open_ai_key(kwargs["extra_headers"])
 1035  
 1036          res = litellm.completion(**kwargs)
 1037          return hash_object, res

  124      @classmethod
  125      def create(
  126          self,
  127          main_model=None,
  128          edit_format=None,
  129          io=None,
  130          from_coder=None,
  131          summarize_from_coder=True,
  132          **kwargs,
  133      ):
  134          import aider.coders as coders
  135  
  136          if not main_model:
  137              if from_coder:
  138                  main_model = from_coder.main_model
  139              else:
  140                  main_model = models.Model(models.DEFAULT_MODEL_NAME)
  141  
  142          if edit_format == "code":
  143              edit_format = None
  144          if edit_format is None:
  145              if from_coder:
  146                  edit_format = from_coder.edit_format
  147              else:
  148                  edit_format = main_model.edit_format
      … 42 lines omitted; exact range 124–201 …
  191              if hasattr(coder, "edit_format") and coder.edit_format == edit_format:
  192                  res = coder(main_model, io, **kwargs)
  193                  res.original_kwargs = dict(kwargs)
  194                  return res
  195  
  196          valid_formats = [
  197              str(c.edit_format)
  198              for c in coders.__all__
  199              if hasattr(c, "edit_format") and c.edit_format is not None
  200          ]
  201          raise UnknownEditFormat(edit_format, valid_formats)

 2269      def prepare_to_edit(self, edits):
 2270          res = []
 2271          seen = dict()
 2272  
 2273          self.need_commit_before_edits = set()
 2274  
 2275          for edit in edits:
 2276              path = edit[0]
 2277              if path is None:
 2278                  res.append(edit)
 2279                  continue
 2280              if path == "python":
 2281                  dump(edits)
 2282              if path in seen:
 2283                  allowed = seen[path]
 2284              else:
 2285                  allowed = self.allowed_to_edit(path)
 2286                  seen[path] = allowed
 2287  
 2288              if allowed:
 2289                  res.append(edit)
 2290  
 2291          self.dirty_commit()
 2292          self.need_commit_before_edits = set()
 2293  
      … 32 lines omitted; exact range 2269–2336 …
 2326  
 2327              self.reflected_message = str(err)
 2328              return edited
 2329  
 2330          for path in edited:
 2331              if self.dry_run:
 2332                  self.io.tool_output(f"Did not apply edit to {path} (--dry-run)")
 2333              else:
 2334                  self.io.tool_output(f"Applied edit to {path}")
 2335  
 2336          return edited

 1006          if functions is not None:
 1007              function = functions[0]
 1008              kwargs["tools"] = [dict(type="function", function=function)]
 1009              kwargs["tool_choice"] = {"type": "function", "function": {"name": function["name"]}}

 1226      def format_chat_chunks(self):
 1227          self.choose_fence()
 1228          main_sys = self.fmt_system_prompt(self.gpt_prompts.main_system)
 1229          if self.main_model.system_prompt_prefix:
 1230              main_sys = self.main_model.system_prompt_prefix + "\n" + main_sys
 1231  
 1232          example_messages = []
 1233          if self.main_model.examples_as_sys_msg:
 1234              if self.gpt_prompts.example_messages:
 1235                  main_sys += "\n# Example conversations:\n\n"
 1236              for msg in self.gpt_prompts.example_messages:
 1237                  role = msg["role"]
 1238                  content = self.fmt_system_prompt(msg["content"])
 1239                  main_sys += f"## {role.upper()}: {content}\n\n"
 1240              main_sys = main_sys.strip()
 1241          else:
 1242              for msg in self.gpt_prompts.example_messages:
 1243                  example_messages.append(
 1244                      dict(
 1245                          role=msg["role"],
 1246                          content=self.fmt_system_prompt(msg["content"]),
 1247                      )
 1248                  )
 1249              if self.gpt_prompts.example_messages:
 1250                  example_messages += [
      … 77 lines omitted; exact range 1226–1338 …
 1328                  )
 1329                  chunks.cur[-1] = dict(role=final["role"], content=new_content)
 1330  
 1331          return chunks
 1332  
 1333      def format_messages(self):
 1334          chunks = self.format_chat_chunks()
 1335          if self.add_cache_headers:
 1336              chunks.add_cache_control_headers()
 1337  
 1338          return chunks

  300  
  301          # Run the tags queries
  302          captures = self._run_captures(Query(language, query_scm), tree.root_node)
  303  
  304          captures_by_tag = defaultdict(list)
  305          matches = []
  306          for tag, nodes in captures.items():
  307              for node in nodes:
  308                  captures_by_tag[tag].append(node)
  309              captures_by_tag[tag].append(node)
  310              matches.append((node, tag))
  311  
  312          if USING_TSL_PACK:
  313              all_nodes = [(node, tag) for tag, nodes in captures_by_tag.items() for node in nodes]
  314          else:
  315              all_nodes = matches
  316  
  317          saw = set()
  318          for node, tag in all_nodes:
  319              if tag.startswith("name.definition."):
  320                  kind = "def"
  321              elif tag.startswith("name.reference."):
  322                  kind = "ref"
  323              else:
  324                  continue
      … 28 lines omitted; exact range 300–363 …
  353          tokens = list(lexer.get_tokens(code))
  354          tokens = [token[1] for token in tokens if token[0] in Token.Name]
  355  
  356          for token in tokens:
  357              yield Tag(
  358                  rel_fname=rel_fname,
  359                  fname=fname,
  360                  name=token,
  361                  kind="ref",
  362                  line=-1,
  363              )

  629      def get_ranked_tags_map_uncached(
  630          self,
  631          chat_fnames,
  632          other_fnames=None,
  633          max_map_tokens=None,
  634          mentioned_fnames=None,
  635          mentioned_idents=None,
  636      ):
  637          if not other_fnames:
  638              other_fnames = list()
  639          if not max_map_tokens:
  640              max_map_tokens = self.max_map_tokens
  641          if not mentioned_fnames:
  642              mentioned_fnames = set()
  643          if not mentioned_idents:
  644              mentioned_idents = set()
  645  
  646          spin = Spinner(UPDATING_REPO_MAP_MESSAGE)
  647  
  648          ranked_tags = self.get_ranked_tags(
  649              chat_fnames,
  650              other_fnames,
  651              mentioned_fnames,
  652              mentioned_idents,
  653              progress=spin.step,
      … 42 lines omitted; exact range 629–706 …
  696                      break
  697  
  698              if num_tokens < max_map_tokens:
  699                  lower_bound = middle + 1
  700              else:
  701                  upper_bound = middle - 1
  702  
  703              middle = int((lower_bound + upper_bound) // 2)
  704  
  705          spin.end()
  706          return best_tree

  339          self.max_chat_history_tokens = 1024
  340          self.weak_model = None
  341          self.editor_model = None
  342  
  343          # Find the extra settings
  344          self.extra_model_settings = next(
  345              (ms for ms in MODEL_SETTINGS if ms.name == "aider/extra_params"), None
  346          )
  347  
  348          self.info = self.get_model_info(model)
  349  
  350          # Are all needed keys/params available?
  351          res = self.validate_environment()
  352          self.missing_keys = res.get("missing_keys")
  353          self.keys_in_environment = res.get("keys_in_environment")
  354  
  355          max_input_tokens = self.info.get("max_input_tokens") or 0
  356          # Calculate max_chat_history_tokens as 1/16th of max_input_tokens,
  357          # with minimum 1k and maximum 8k
  358          self.max_chat_history_tokens = min(max(max_input_tokens / 16, 1024), 8192)

 1396      def check_tokens(self, messages):
 1397          """Check if the messages will fit within the model's token limits."""
 1398          input_tokens = self.main_model.token_count(messages)
 1399          max_input_tokens = self.main_model.info.get("max_input_tokens") or 0
 1400  
 1401          if max_input_tokens and input_tokens >= max_input_tokens:
 1402              self.io.tool_error(
 1403                  f"Your estimated chat context of {input_tokens:,} tokens exceeds the"
 1404                  f" {max_input_tokens:,} token limit for {self.main_model.name}!"
 1405              )
 1406              self.io.tool_output("To reduce the chat context:")
 1407              self.io.tool_output("- Use /drop to remove unneeded files from the chat")
 1408              self.io.tool_output("- Use /clear to clear the chat history")
 1409              self.io.tool_output("- Break your code into smaller files")
 1410              self.io.tool_output(
 1411                  "It's probably safe to try and send the request, most providers won't charge if"
 1412                  " the context limit is exceeded."
 1413              )
 1414  
 1415              if not self.io.confirm_ask("Try to proceed anyway?"):
 1416                  return False
 1417          return True

 2375      def auto_commit(self, edited, context=None):
 2376          if not self.repo or not self.auto_commits or self.dry_run:
 2377              return
 2378  
 2379          if not context:
 2380              context = self.get_context_from_history(self.cur_messages)
 2381  
 2382          try:
 2383              res = self.repo.commit(fnames=edited, context=context, aider_edits=True, coder=self)
 2384              if res:
 2385                  self.show_auto_commit_outcome(res)
 2386                  commit_hash, commit_message = res
 2387                  return self.gpt_prompts.files_content_gpt_edits.format(
 2388                      hash=commit_hash,
 2389                      message=commit_message,
 2390                  )
 2391  
 2392              return self.gpt_prompts.files_content_gpt_no_edits
 2393          except ANY_GIT_ERROR as err:
 2394              self.io.tool_error(f"Unable to commit: {str(err)}")
 2395              return
 2396  
 2397      def show_auto_commit_outcome(self, res):
 2398          commit_hash, commit_message = res
 2399          self.last_aider_commit_hash = commit_hash
      … 13 lines omitted; exact range 2375–2423 …
 2413              return
 2414          if not self.dirty_commits:
 2415              return
 2416          if not self.repo:
 2417              return
 2418  
 2419          self.repo.commit(fnames=self.need_commit_before_edits, coder=self)
 2420  
 2421          # files changed, move cur messages back behind the files messages
 2422          # self.move_back_cur_messages(self.gpt_prompts.files_content_local_edits)
 2423          return True

 2215  
 2216                  # Seems unlikely that we needed to create the file, but it was
 2217                  # actually already part of the repo.
 2218                  # But let's only add if we need to, just to be safe.
 2219                  if need_to_add and self.auto_commits:
 2220                      self.repo.repo.git.add(full_path)
 2221  
 2222              self.abs_fnames.add(full_path)
 2223              self.check_added_files()
 2224              return True
 2225  
 2226          if not self.io.confirm_ask(
 2227              "Allow edits to file that has not been added to the chat?",
 2228              subject=path,
 2229          ):
 2230              self.io.tool_output(f"Skipping edits to {path}")
 2231              return
 2232  
 2233          if need_to_add and self.auto_commits:
 2234              self.repo.repo.git.add(full_path)
 2235  
 2236          self.abs_fnames.add(full_path)
 2237          self.check_added_files()
 2238          self.check_for_dirty_commit(path)
 2239  
 2240          return True

 2434      def run_shell_commands(self):
 2435          if not self.suggest_shell_commands:
 2436              return ""
 2437  
 2438          done = set()
 2439          group = ConfirmGroup(set(self.shell_commands))
 2440          accumulated_output = ""
 2441          for command in self.shell_commands:
 2442              if command in done:
 2443                  continue
 2444              done.add(command)
 2445              output = self.handle_shell_commands(command, group)
 2446              if output:
 2447                  accumulated_output += output + "\n\n"
 2448          return accumulated_output
 2449  
 2450      def handle_shell_commands(self, commands_str, group):
 2451          commands = commands_str.strip().splitlines()
 2452          command_count = sum(
 2453              1 for cmd in commands if cmd.strip() and not cmd.strip().startswith("#")
 2454          )
 2455          prompt = "Run shell command?" if command_count == 1 else "Run shell commands?"
 2456          if not self.io.confirm_ask(
 2457              prompt,
 2458              subject="\n".join(commands),
      … 16 lines omitted; exact range 2434–2485 …
 2475              exit_status, output = run_cmd(command, error_print=self.io.tool_error, cwd=self.root)
 2476              if output:
 2477                  accumulated_output += f"Output from {command}\n{output}\n"
 2478  
 2479          if accumulated_output.strip() and self.io.confirm_ask(
 2480              "Add command output to the chat?", allow_never=True
 2481          ):
 2482              num_lines = len(accumulated_output.strip().splitlines())
 2483              line_plural = "line" if num_lines == 1 else "lines"
 2484              self.io.tool_output(f"Added {num_lines} {line_plural} of output to the chat.")
 2485              return accumulated_output

    6  class ArchitectCoder(AskCoder):
    7      edit_format = "architect"
    8      gpt_prompts = ArchitectPrompts()
    9      auto_accept_architect = False
   10  
   11      def reply_completed(self):
   12          content = self.partial_response_content
   13  
   14          if not content or not content.strip():
   15              return
   16  
   17          if not self.auto_accept_architect and not self.io.confirm_ask("Edit the files?"):
   18              return
   19  
   20          kwargs = dict()
   21  
   22          # Use the editor_model from the main_model if it exists, otherwise use the main_model itself
   23          editor_model = self.main_model.editor_model or self.main_model
   24  
   25          kwargs["main_model"] = editor_model
   26          kwargs["edit_format"] = self.main_model.editor_edit_format
   27          kwargs["suggest_shell_commands"] = False
   28          kwargs["map_tokens"] = 0
   29          kwargs["total_cost"] = self.total_cost
   30          kwargs["cache_prompts"] = False
      … 7 lines omitted; exact range 6–48 …
   38          editor_coder.cur_messages = []
   39          editor_coder.done_messages = []
   40  
   41          if self.verbose:
   42              editor_coder.show_announcements()
   43  
   44          editor_coder.run(with_message=content, preproc=False)
   45  
   46          self.move_back_cur_messages("I made those changes to the files.")
   47          self.total_cost = editor_coder.total_cost
   48          self.aider_commit_hashes = editor_coder.aider_commit_hashes

  754      def log_llm_history(self, role, content):
  755          if not self.llm_history_file:
  756              return
  757          timestamp = datetime.now().isoformat(timespec="seconds")
  758          try:
  759              Path(self.llm_history_file).parent.mkdir(parents=True, exist_ok=True)
  760              with open(self.llm_history_file, "a", encoding="utf-8") as log_file:
  761                  log_file.write(f"{role.upper()} {timestamp}\n")
  762                  log_file.write(content + "\n")
  763          except (PermissionError, OSError) as err:
  764              self.tool_warning(f"Unable to write to llm history file {self.llm_history_file}: {err}")
  765              self.llm_history_file = None