Repository: plandex-ai/plandex
Branch: main
Commit: e2d772072efa
Files: 656
Total size: 3.0 MB

Directory structure:
gitextract_skjdl2ff/

├── .dockerignore
├── .gitattributes
├── .github/
│   └── workflows/
│       └── docker-publish.yml
├── .gitignore
├── LICENSE
├── README.md
├── app/
│   ├── .dockerignore
│   ├── .gitignore
│   ├── clear_local.sh
│   ├── cli/
│   │   ├── api/
│   │   │   ├── clients.go
│   │   │   ├── errors.go
│   │   │   ├── methods.go
│   │   │   └── stream.go
│   │   ├── auth/
│   │   │   ├── account.go
│   │   │   ├── api.go
│   │   │   ├── auth.go
│   │   │   ├── org.go
│   │   │   ├── state.go
│   │   │   └── trial.go
│   │   ├── cmd/
│   │   │   ├── apply.go
│   │   │   ├── archive.go
│   │   │   ├── billing.go
│   │   │   ├── branches.go
│   │   │   ├── browser.go
│   │   │   ├── build.go
│   │   │   ├── cd.go
│   │   │   ├── chat.go
│   │   │   ├── checkout.go
│   │   │   ├── claude_max.go
│   │   │   ├── clear.go
│   │   │   ├── config.go
│   │   │   ├── connect.go
│   │   │   ├── context_show.go
│   │   │   ├── continue.go
│   │   │   ├── convo.go
│   │   │   ├── current.go
│   │   │   ├── debug.go
│   │   │   ├── delete_branch.go
│   │   │   ├── delete_plan.go
│   │   │   ├── diffs.go
│   │   │   ├── invite.go
│   │   │   ├── load.go
│   │   │   ├── log.go
│   │   │   ├── ls.go
│   │   │   ├── model_helpers.go
│   │   │   ├── model_packs.go
│   │   │   ├── model_providers.go
│   │   │   ├── models.go
│   │   │   ├── new.go
│   │   │   ├── plan_exec_helpers.go
│   │   │   ├── plan_start_helpers.go
│   │   │   ├── plans.go
│   │   │   ├── ps.go
│   │   │   ├── reject.go
│   │   │   ├── rename.go
│   │   │   ├── repl.go
│   │   │   ├── revoke.go
│   │   │   ├── rewind.go
│   │   │   ├── rm.go
│   │   │   ├── root.go
│   │   │   ├── set_config.go
│   │   │   ├── set_model.go
│   │   │   ├── sign_in.go
│   │   │   ├── stop.go
│   │   │   ├── summary.go
│   │   │   ├── tell.go
│   │   │   ├── unarchive.go
│   │   │   ├── update.go
│   │   │   ├── usage.go
│   │   │   ├── users.go
│   │   │   └── version.go
│   │   ├── dev.sh
│   │   ├── format/
│   │   │   ├── file.go
│   │   │   └── time.go
│   │   ├── fs/
│   │   │   ├── fs.go
│   │   │   ├── paths.go
│   │   │   ├── projects.go
│   │   │   └── utils.go
│   │   ├── go.mod
│   │   ├── go.sum
│   │   ├── install.sh
│   │   ├── lib/
│   │   │   ├── active_stream.go
│   │   │   ├── apply.go
│   │   │   ├── apply_cgroup_linux.go
│   │   │   ├── apply_cgroup_other.go
│   │   │   ├── apply_proc.go
│   │   │   ├── build.go
│   │   │   ├── claude_max.go
│   │   │   ├── context_auto_load.go
│   │   │   ├── context_conflict.go
│   │   │   ├── context_display.go
│   │   │   ├── context_load.go
│   │   │   ├── context_paths.go
│   │   │   ├── context_shared.go
│   │   │   ├── context_update.go
│   │   │   ├── current.go
│   │   │   ├── custom_models.go
│   │   │   ├── editor.go
│   │   │   ├── git.go
│   │   │   ├── legacy_files.go
│   │   │   ├── log_format.go
│   │   │   ├── model_credentials.go
│   │   │   ├── model_settings.go
│   │   │   ├── models_sync.go
│   │   │   ├── org_user_config.go
│   │   │   ├── plan_config.go
│   │   │   ├── plans.go
│   │   │   ├── repl.go
│   │   │   └── rewind.go
│   │   ├── main.go
│   │   ├── nodemon.json
│   │   ├── plan.json
│   │   ├── plan_exec/
│   │   │   ├── action_menu.go
│   │   │   ├── apply_exec.go
│   │   │   ├── build.go
│   │   │   ├── params.go
│   │   │   └── tell.go
│   │   ├── schema/
│   │   │   ├── json-schemas/
│   │   │   │   ├── definitions/
│   │   │   │   │   ├── auto-modes.schema.json
│   │   │   │   │   ├── local-providers.schema.json
│   │   │   │   │   └── model-providers.schema.json
│   │   │   │   ├── model-config.schema.json
│   │   │   │   ├── model-pack-base-config.schema.json
│   │   │   │   ├── model-pack-config.schema.json
│   │   │   │   ├── model-pack-inline.schema.json
│   │   │   │   ├── model-pack-roles.schema.json
│   │   │   │   ├── model-provider-config.schema.json
│   │   │   │   ├── model-role-config.schema.json
│   │   │   │   ├── models-input.schema.json
│   │   │   │   └── plan-config.schema.json
│   │   │   └── schemas.go
│   │   ├── stream/
│   │   │   └── stream.go
│   │   ├── stream_tui/
│   │   │   ├── debouncer.go
│   │   │   ├── model.go
│   │   │   ├── run.go
│   │   │   ├── update.go
│   │   │   └── view.go
│   │   ├── term/
│   │   │   ├── color.go
│   │   │   ├── errors.go
│   │   │   ├── format.go
│   │   │   ├── help.go
│   │   │   ├── os.go
│   │   │   ├── prompt.go
│   │   │   ├── repl.go
│   │   │   ├── select.go
│   │   │   ├── spinner.go
│   │   │   └── utils.go
│   │   ├── types/
│   │   │   ├── api.go
│   │   │   ├── apply.go
│   │   │   ├── exec.go
│   │   │   ├── fs.go
│   │   │   └── types.go
│   │   ├── ui/
│   │   │   └── ui.go
│   │   ├── upgrade.go
│   │   ├── url/
│   │   │   └── url.go
│   │   ├── utils/
│   │   │   └── utils.go
│   │   ├── version/
│   │   │   └── version.go
│   │   └── version.txt
│   ├── docker-compose.yml
│   ├── plans/
│   │   ├── credits-cmd.txt
│   │   ├── credits-log-cmd.txt
│   │   ├── json-prompts-to-xml.md
│   │   └── plan-config.md
│   ├── reset_local.sh
│   ├── scripts/
│   │   ├── cmd/
│   │   │   ├── gen/
│   │   │   │   └── gen.go
│   │   │   └── provider/
│   │   │       └── gen_provider.go
│   │   ├── dev.sh
│   │   ├── litellm_deps.sh
│   │   └── wait-for-it.sh
│   ├── server/
│   │   ├── .gitignore
│   │   ├── Dockerfile
│   │   ├── db/
│   │   │   ├── account_helpers.go
│   │   │   ├── ai_model_helpers.go
│   │   │   ├── auth_helpers.go
│   │   │   ├── branch_helpers.go
│   │   │   ├── build_helpers.go
│   │   │   ├── context_helpers_conflicts.go
│   │   │   ├── context_helpers_get.go
│   │   │   ├── context_helpers_load.go
│   │   │   ├── context_helpers_map.go
│   │   │   ├── context_helpers_remove.go
│   │   │   ├── context_helpers_store.go
│   │   │   ├── context_helpers_update.go
│   │   │   ├── convo_helpers.go
│   │   │   ├── data_models.go
│   │   │   ├── db.go
│   │   │   ├── diff_helpers.go
│   │   │   ├── fs.go
│   │   │   ├── git.go
│   │   │   ├── invite_helpers.go
│   │   │   ├── locks.go
│   │   │   ├── models.go
│   │   │   ├── org_helpers.go
│   │   │   ├── plan_config_helpers.go
│   │   │   ├── plan_helpers.go
│   │   │   ├── project_helpers.go
│   │   │   ├── queue.go
│   │   │   ├── rbac_helpers.go
│   │   │   ├── result_helpers.go
│   │   │   ├── settings_helpers.go
│   │   │   ├── stream_helpers.go
│   │   │   ├── subtask_helpers.go
│   │   │   ├── summary_helpers.go
│   │   │   ├── transactions.go
│   │   │   ├── user_helpers.go
│   │   │   └── utils.go
│   │   ├── diff/
│   │   │   └── diff.go
│   │   ├── email/
│   │   │   ├── email.go
│   │   │   ├── invite.go
│   │   │   └── verification.go
│   │   ├── go.mod
│   │   ├── go.sum
│   │   ├── handlers/
│   │   │   ├── accounts.go
│   │   │   ├── auth_helpers.go
│   │   │   ├── branches.go
│   │   │   ├── client_helper.go
│   │   │   ├── context_helper.go
│   │   │   ├── err_helper.go
│   │   │   ├── file_maps.go
│   │   │   ├── file_maps_queue.go
│   │   │   ├── invites.go
│   │   │   ├── models.go
│   │   │   ├── org_helpers.go
│   │   │   ├── orgs.go
│   │   │   ├── plan_config.go
│   │   │   ├── plans_changes.go
│   │   │   ├── plans_context.go
│   │   │   ├── plans_convo.go
│   │   │   ├── plans_crud.go
│   │   │   ├── plans_exec.go
│   │   │   ├── plans_versions.go
│   │   │   ├── projects.go
│   │   │   ├── proxy_helper.go
│   │   │   ├── sessions.go
│   │   │   ├── settings.go
│   │   │   ├── stream_helper.go
│   │   │   └── users.go
│   │   ├── hooks/
│   │   │   └── hooks.go
│   │   ├── host/
│   │   │   └── ip.go
│   │   ├── litellm_proxy.py
│   │   ├── main.go
│   │   ├── migrations/
│   │   │   ├── 2023120500_init.down.sql
│   │   │   ├── 2023120500_init.up.sql
│   │   │   ├── 2024011700_rbac.down.sql
│   │   │   ├── 2024011700_rbac.up.sql
│   │   │   ├── 2024012400_streams.down.sql
│   │   │   ├── 2024012400_streams.up.sql
│   │   │   ├── 2024012500_locks.down.sql
│   │   │   ├── 2024012500_locks.up.sql
│   │   │   ├── 2024013000_plan_build_convo_ids.down.sql
│   │   │   ├── 2024013000_plan_build_convo_ids.up.sql
│   │   │   ├── 2024020800_heartbeats.down.sql
│   │   │   ├── 2024020800_heartbeats.up.sql
│   │   │   ├── 2024022000_revert_plan_build_convo_ids.down.sql
│   │   │   ├── 2024022000_revert_plan_build_convo_ids.up.sql
│   │   │   ├── 2024032700_remove_billing_admin.down.sql
│   │   │   ├── 2024032700_remove_billing_admin.up.sql
│   │   │   ├── 2024032701_drop_users_projects.down.sql
│   │   │   ├── 2024032701_drop_users_projects.up.sql
│   │   │   ├── 2024040400_add_orgs_users_unique.down.sql
│   │   │   ├── 2024040400_add_orgs_users_unique.up.sql
│   │   │   ├── 2024041500_model_sets_models.down.sql
│   │   │   ├── 2024041500_model_sets_models.up.sql
│   │   │   ├── 2024042600_default_plan_settings.down.sql
│   │   │   ├── 2024042600_default_plan_settings.up.sql
│   │   │   ├── 2024091800_sign_in_codes.down.sql
│   │   │   ├── 2024091800_sign_in_codes.up.sql
│   │   │   ├── 2024092100_remove_trial_fields.down.sql
│   │   │   ├── 2024092100_remove_trial_fields.up.sql
│   │   │   ├── 2024100900_update_locks.down.sql
│   │   │   ├── 2024100900_update_locks.up.sql
│   │   │   ├── 2024121400_plan_config.down.sql
│   │   │   ├── 2024121400_plan_config.up.sql
│   │   │   ├── 2025012600_update_custom_models.down.sql
│   │   │   ├── 2025012600_update_custom_models.up.sql
│   │   │   ├── 2025021101_locks_unique.down.sql
│   │   │   ├── 2025021101_locks_unique.up.sql
│   │   │   ├── 2025022700_remove_models_col.down.sql
│   │   │   ├── 2025022700_remove_models_col.up.sql
│   │   │   ├── 2025031300_add_model_roles.down.sql
│   │   │   ├── 2025031300_add_model_roles.up.sql
│   │   │   ├── 2025031900_add_custom_model_cols.down.sql
│   │   │   ├── 2025031900_add_custom_model_cols.up.sql
│   │   │   ├── 2025032400_sign_in_codes_on_delete.down.sql
│   │   │   ├── 2025032400_sign_in_codes_on_delete.up.sql
│   │   │   ├── 2025051600_custom_models_refactor.down.sql
│   │   │   ├── 2025051600_custom_models_refactor.up.sql
│   │   │   ├── 2025052200_model_pack_cols.down.sql
│   │   │   ├── 2025052200_model_pack_cols.up.sql
│   │   │   ├── 2025070200_add_org_user_config.down.sql
│   │   │   └── 2025070200_add_org_user_config.up.sql
│   │   ├── model/
│   │   │   ├── client.go
│   │   │   ├── client_stream.go
│   │   │   ├── litellm.go
│   │   │   ├── model_error.go
│   │   │   ├── model_request.go
│   │   │   ├── name.go
│   │   │   ├── parse/
│   │   │   │   ├── subtasks.go
│   │   │   │   └── subtasks_test.go
│   │   │   ├── plan/
│   │   │   │   ├── activate.go
│   │   │   │   ├── build_exec.go
│   │   │   │   ├── build_finish.go
│   │   │   │   ├── build_load.go
│   │   │   │   ├── build_race.go
│   │   │   │   ├── build_state.go
│   │   │   │   ├── build_structured_edits.go
│   │   │   │   ├── build_validate_and_fix.go
│   │   │   │   ├── build_whole_file.go
│   │   │   │   ├── commit_msg.go
│   │   │   │   ├── exec_status.go
│   │   │   │   ├── shutdown.go
│   │   │   │   ├── state.go
│   │   │   │   ├── stop.go
│   │   │   │   ├── tell_build_pending.go
│   │   │   │   ├── tell_context.go
│   │   │   │   ├── tell_exec.go
│   │   │   │   ├── tell_load.go
│   │   │   │   ├── tell_missing_file.go
│   │   │   │   ├── tell_prompt_message.go
│   │   │   │   ├── tell_stage.go
│   │   │   │   ├── tell_state.go
│   │   │   │   ├── tell_stream_error.go
│   │   │   │   ├── tell_stream_finish.go
│   │   │   │   ├── tell_stream_main.go
│   │   │   │   ├── tell_stream_processor.go
│   │   │   │   ├── tell_stream_processor_test.go
│   │   │   │   ├── tell_stream_status.go
│   │   │   │   ├── tell_stream_store.go
│   │   │   │   ├── tell_stream_usage.go
│   │   │   │   ├── tell_subtasks.go
│   │   │   │   ├── tell_summary.go
│   │   │   │   ├── tell_sys_prompt.go
│   │   │   │   └── utils.go
│   │   │   ├── prompts/
│   │   │   │   ├── apply_exec.go
│   │   │   │   ├── architect_context.go
│   │   │   │   ├── build_helpers.go
│   │   │   │   ├── build_validation_replacements.go
│   │   │   │   ├── build_whole_file.go
│   │   │   │   ├── chat.go
│   │   │   │   ├── code_block_langs.go
│   │   │   │   ├── describe.go
│   │   │   │   ├── exec_status.go
│   │   │   │   ├── explanation_format.go
│   │   │   │   ├── file_ops.go
│   │   │   │   ├── implement.go
│   │   │   │   ├── missing_file.go
│   │   │   │   ├── name.go
│   │   │   │   ├── planning.go
│   │   │   │   ├── shared.go
│   │   │   │   ├── summary.go
│   │   │   │   ├── update_format.go
│   │   │   │   └── user_prompt.go
│   │   │   ├── summarize.go
│   │   │   └── tokens.go
│   │   ├── notify/
│   │   │   └── errors.go
│   │   ├── routes/
│   │   │   └── routes.go
│   │   ├── setup/
│   │   │   └── setup.go
│   │   ├── shutdown/
│   │   │   └── shutdown.go
│   │   ├── syntax/
│   │   │   ├── comments.go
│   │   │   ├── file_map/
│   │   │   │   ├── cli/
│   │   │   │   │   ├── .gitignore
│   │   │   │   │   ├── go.mod
│   │   │   │   │   ├── go.sum
│   │   │   │   │   └── main.go
│   │   │   │   ├── examples/
│   │   │   │   │   ├── bash_example.sh
│   │   │   │   │   ├── c_example.c
│   │   │   │   │   ├── cpp_example.cpp
│   │   │   │   │   ├── csharp_example.cs
│   │   │   │   │   ├── css_example.css
│   │   │   │   │   ├── cue_example.cue
│   │   │   │   │   ├── dockerfile_example
│   │   │   │   │   ├── elixir_example.ex
│   │   │   │   │   ├── elm_example.elm
│   │   │   │   │   ├── go_example.go
│   │   │   │   │   ├── groovy_example.groovy
│   │   │   │   │   ├── hcl_example.hcl
│   │   │   │   │   ├── html_example.html
│   │   │   │   │   ├── java_example.java
│   │   │   │   │   ├── javascript_example.js
│   │   │   │   │   ├── kotlin_example.kt
│   │   │   │   │   ├── lua_example.lua
│   │   │   │   │   ├── markdown_example.md
│   │   │   │   │   ├── ocaml_example.ml
│   │   │   │   │   ├── php_example.php
│   │   │   │   │   ├── protobuf_example.proto
│   │   │   │   │   ├── python_example.py
│   │   │   │   │   ├── ruby_example.rb
│   │   │   │   │   ├── rust_example.rs
│   │   │   │   │   ├── scala_example.scala
│   │   │   │   │   ├── svelte_example.svelte
│   │   │   │   │   ├── swift_example.swift
│   │   │   │   │   ├── toml_example.toml
│   │   │   │   │   ├── tsx_example.tsx
│   │   │   │   │   ├── typescript_example.ts
│   │   │   │   │   └── yaml_example.yaml
│   │   │   │   ├── map.go
│   │   │   │   ├── markup.go
│   │   │   │   ├── multi.go
│   │   │   │   ├── nodes_config.go
│   │   │   │   ├── nodes_find.go
│   │   │   │   └── svelte.go
│   │   │   ├── map.txt
│   │   │   ├── parsers.go
│   │   │   ├── structured_edits_apply.go
│   │   │   ├── structured_edits_generic.go
│   │   │   ├── structured_edits_sections.go
│   │   │   ├── structured_edits_test.go
│   │   │   ├── structured_edits_tree_sitter.go
│   │   │   ├── unique_replacement.go
│   │   │   ├── unique_replacement_test.go
│   │   │   └── validate.go
│   │   ├── types/
│   │   │   ├── active_plan.go
│   │   │   ├── active_plan_pending_builds.go
│   │   │   ├── auth.go
│   │   │   ├── convo_message_desc.go
│   │   │   ├── exec_status.go
│   │   │   ├── message.go
│   │   │   ├── model.go
│   │   │   ├── reply.go
│   │   │   ├── reply_test.go
│   │   │   ├── reply_test_examples/
│   │   │   │   ├── 1.md
│   │   │   │   ├── 10.md
│   │   │   │   ├── 2.md
│   │   │   │   ├── 3.md
│   │   │   │   ├── 4.md
│   │   │   │   ├── 5.md
│   │   │   │   ├── 6.md
│   │   │   │   ├── 7.md
│   │   │   │   ├── 8.md
│   │   │   │   └── 9.md
│   │   │   ├── safe_map.go
│   │   │   └── trial.go
│   │   ├── utils/
│   │   │   ├── whitespace.go
│   │   │   ├── whitespace_test.go
│   │   │   └── xml.go
│   │   └── version.txt
│   ├── shared/
│   │   ├── ai_models_available.go
│   │   ├── ai_models_compatibility.go
│   │   ├── ai_models_config.go
│   │   ├── ai_models_credentials.go
│   │   ├── ai_models_custom.go
│   │   ├── ai_models_data_models.go
│   │   ├── ai_models_errors.go
│   │   ├── ai_models_large_context.go
│   │   ├── ai_models_openrouter.go
│   │   ├── ai_models_packs.go
│   │   ├── ai_models_providers.go
│   │   ├── ai_models_roles.go
│   │   ├── auth.go
│   │   ├── context.go
│   │   ├── convo_message.go
│   │   ├── data_models.go
│   │   ├── email.go
│   │   ├── file_maps.go
│   │   ├── go.mod
│   │   ├── go.sum
│   │   ├── images.go
│   │   ├── org_user_config.go
│   │   ├── plan_config.go
│   │   ├── plan_model_settings.go
│   │   ├── plan_result.go
│   │   ├── plan_result_exec_history.go
│   │   ├── plan_result_pending_summary.go
│   │   ├── plan_result_replacements.go
│   │   ├── plan_status.go
│   │   ├── rbac.go
│   │   ├── req_res.go
│   │   ├── stream.go
│   │   ├── streamed_change.go
│   │   ├── syntax.go
│   │   ├── tokens.go
│   │   ├── tygo.yaml
│   │   ├── utils.go
│   │   └── utils_struct.go
│   └── start_local.sh
├── docs/
│   ├── .gitignore
│   ├── README.md
│   ├── babel.config.js
│   ├── blog/
│   │   ├── 2019-05-28-first-blog-post.md
│   │   ├── 2019-05-29-long-blog-post.md
│   │   ├── 2021-08-01-mdx-blog-post.mdx
│   │   ├── 2021-08-26-welcome/
│   │   │   └── index.md
│   │   ├── authors.yml
│   │   └── tags.yml
│   ├── docs/
│   │   ├── cli-reference.md
│   │   ├── core-concepts/
│   │   │   ├── _category_.json
│   │   │   ├── autonomy.md
│   │   │   ├── background-tasks.md
│   │   │   ├── branches.md
│   │   │   ├── configuration.md
│   │   │   ├── context-management.md
│   │   │   ├── conversations.md
│   │   │   ├── execution-and-debugging.md
│   │   │   ├── orgs.md
│   │   │   ├── plans.md
│   │   │   ├── prompts.md
│   │   │   ├── reviewing-changes.md
│   │   │   └── version-control.md
│   │   ├── development.md
│   │   ├── environment-variables.md
│   │   ├── hosting/
│   │   │   ├── _category_.json
│   │   │   ├── cloud.md
│   │   │   └── self-hosting/
│   │   │       ├── _category_.json
│   │   │       ├── advanced-self-hosting.md
│   │   │       └── local-mode-quickstart.md
│   │   ├── install.md
│   │   ├── models/
│   │   │   ├── _category_.json
│   │   │   ├── built-in/
│   │   │   │   ├── _category_.json
│   │   │   │   ├── built-in-models.md
│   │   │   │   └── built-in-packs.md
│   │   │   ├── claude-subscription.md
│   │   │   ├── custom-models.md
│   │   │   ├── model-providers.md
│   │   │   ├── model-settings.md
│   │   │   ├── models-overview.md
│   │   │   ├── ollama.md
│   │   │   └── roles.md
│   │   ├── quick-start.md
│   │   ├── repl.md
│   │   └── security.md
│   ├── docusaurus.config.ts
│   ├── package.json
│   ├── sidebars.ts
│   ├── src/
│   │   └── css/
│   │       └── custom.css
│   ├── static/
│   │   ├── .nojekyll
│   │   └── _redirects
│   └── tsconfig.json
├── plans/
│   ├── invite-commands.txt
│   ├── model-sets-custom-models-crud.txt
│   ├── pdx-file.md
│   └── race_cond_chatgpt.txt
├── releases/
│   ├── cli/
│   │   ├── CHANGELOG.md
│   │   └── versions/
│   │       ├── 0.7.1.md
│   │       ├── 0.7.2.md
│   │       ├── 0.7.3.md
│   │       ├── 0.8.0.md
│   │       ├── 0.8.1.md
│   │       ├── 0.8.2.md
│   │       ├── 0.8.3.md
│   │       ├── 0.9.0.md
│   │       ├── 0.9.1.md
│   │       ├── 1.0.0.md
│   │       ├── 1.1.0.md
│   │       ├── 1.1.1.md
│   │       ├── 1.1.2.md
│   │       ├── 2.0.0.md
│   │       ├── 2.0.1.md
│   │       ├── 2.0.2.md
│   │       ├── 2.0.3.md
│   │       ├── 2.0.4.md
│   │       ├── 2.0.5.md
│   │       ├── 2.0.6.md
│   │       ├── 2.0.7+1.md
│   │       ├── 2.0.7.md
│   │       ├── 2.0.8.md
│   │       ├── 2.1.0+1.md
│   │       ├── 2.1.0.md
│   │       ├── 2.1.1.md
│   │       ├── 2.1.2.md
│   │       ├── 2.1.3.md
│   │       ├── 2.1.5.md
│   │       ├── 2.1.6+1.md
│   │       ├── 2.1.6.md
│   │       ├── 2.2.0.md
│   │       └── 2.2.1.md
│   └── server/
│       ├── CHANGELOG.md
│       └── versions/
│           ├── 0.7.0.md
│           ├── 0.7.1.md
│           ├── 0.8.0.md
│           ├── 0.8.1.md
│           ├── 0.8.2.md
│           ├── 0.8.3.md
│           ├── 0.8.4.md
│           ├── 0.9.0.md
│           ├── 0.9.1.md
│           ├── 1.0.0.md
│           ├── 1.0.1.md
│           ├── 1.1.0.md
│           ├── 1.1.1.md
│           ├── 2.0.0+1.md
│           ├── 2.0.0+2.md
│           ├── 2.0.0.md
│           ├── 2.0.2.md
│           ├── 2.0.3.md
│           ├── 2.0.4.md
│           ├── 2.0.5.md
│           ├── 2.0.6.md
│           ├── 2.1.0+1.md
│           ├── 2.1.0.md
│           ├── 2.1.1+1.md
│           ├── 2.1.1.md
│           ├── 2.1.2.md
│           ├── 2.1.3.md
│           ├── 2.1.4.md
│           ├── 2.1.5.md
│           ├── 2.1.6+1.md
│           ├── 2.1.6.md
│           ├── 2.1.7.md
│           ├── 2.1.8.md
│           ├── 2.2.0.md
│           └── 2.2.1.md
├── scripts/
│   └── merge_from_reflog.sh
└── test/
    ├── _test_apply.sh
    ├── error-test.html
    ├── evals/
    │   └── promptfoo-poc/
    │       ├── README.md
    │       ├── build/
    │       │   ├── assets/
    │       │   │   ├── build/
    │       │   │   │   ├── changes.md
    │       │   │   │   └── post_build.go
    │       │   │   └── shared/
    │       │   │       └── pre_build.go
    │       │   ├── build.config.properties
    │       │   ├── build.parameters.json
    │       │   ├── build.prompt.txt
    │       │   ├── build.provider.yml
    │       │   ├── promptfooconfig.yaml
    │       │   └── tests/
    │       │       └── build.test.yml
    │       ├── evals.md
    │       ├── fix/
    │       │   ├── assets/
    │       │   │   ├── removal/
    │       │   │   │   ├── changes.md
    │       │   │   │   ├── post_build.go
    │       │   │   │   └── problems.txt
    │       │   │   └── shared/
    │       │   │       └── pre_build.go
    │       │   ├── fix.config.properties
    │       │   ├── fix.parameters.json
    │       │   ├── fix.prompt.txt
    │       │   ├── fix.provider.yml
    │       │   ├── promptfooconfig.yaml
    │       │   └── tests/
    │       │       └── fix.test.yml
    │       ├── templates/
    │       │   └── provider.template.yml
    │       └── verify/
    │           ├── assets/
    │           │   ├── removal/
    │           │   │   ├── changes.md
    │           │   │   ├── diff.txt
    │           │   │   └── post_build.go
    │           │   ├── shared/
    │           │   │   └── pre_build.go
    │           │   └── valid/
    │           │       ├── changes.md
    │           │       ├── diff.txt
    │           │       └── post_build.go
    │           ├── promptfooconfig.yaml
    │           ├── tests/
    │           │   ├── removal.test.yml
    │           │   └── validate.test.yml
    │           ├── verify.config.properties
    │           ├── verify.parameters.json
    │           ├── verify.prompt.txt
    │           └── verify.provider.yml
    ├── plan_deletion_test.sh
    ├── project/
    │   └── react-redux-foobar/
    │       ├── action.ts
    │       ├── component.ts
    │       ├── lib/
    │       │   ├── constants.ts
    │       │   └── utils.ts
    │       ├── package.json
    │       ├── reducer.ts
    │       ├── tests/
    │       │   ├── action.test.ts
    │       │   └── component.test.ts
    │       └── tsconfig.json
    ├── smoke_test.sh
    ├── test_custom_models.sh
    ├── test_prompts/
    │   ├── aws-infra.txt
    │   ├── pong.txt
    │   ├── robust-logging.txt
    │   ├── stripe-plan.txt
    │   └── tic-tac-toe.txt
    └── test_utils.sh

================================================
FILE CONTENTS
================================================

================================================
FILE: .dockerignore
================================================
dist-server/
cli/
node_modules/
plandex-server
plandex-cloud


================================================
FILE: .gitattributes
================================================
*.sh		text eol=lf

================================================
FILE: .github/workflows/docker-publish.yml
================================================
name: Build and publish Docker Image

on:
  release:
    types: [created]
  workflow_dispatch: # enable manual triggering

jobs:
  check_release:
    runs-on: ubuntu-latest
    outputs:
      should_build: ${{ steps.check_release.outputs.should_build }}
      tag: ${{ steps.check_release.outputs.tag }}
    
    steps:
      - name: Check release tag and find latest server tag
        id: check_release
        run: |
          if [ "${{ github.event_name }}" == "release" ]; then
            # This is a release event - check if the tag starts with 'server'
            if [[ "${{ github.ref_name }}" == server* ]]; then
              echo "This is a server release: ${{ github.ref_name }}"
              echo "should_build=true" >> $GITHUB_OUTPUT
              echo "tag=${{ github.ref_name }}" >> $GITHUB_OUTPUT
            else
              echo "This is not a server release. Skipping build."
              echo "should_build=false" >> $GITHUB_OUTPUT
            fi
          else
            # This is a manual workflow_dispatch event
            echo "This is a manual workflow trigger. Proceeding to find latest server tag."
            echo "should_build=true" >> $GITHUB_OUTPUT
            echo "tag=latest_server" >> $GITHUB_OUTPUT
          fi

  build_and_push:
    needs: check_release
    if: needs.check_release.outputs.should_build == 'true'
    runs-on: ubuntu-latest

    steps:
      - name: Check out the repo
        uses: actions/checkout@v2
        with:
          fetch-depth: 0  # Fetch all history and tags

      - name: Find latest server tag
        id: find_tag
        if: needs.check_release.outputs.tag == 'latest_server'
        run: |
          # Find the latest tag that starts with 'server'
          LATEST_SERVER_TAG=$(git tag -l "server*" --sort=-creatordate | head -n 1)
          
          if [ -z "$LATEST_SERVER_TAG" ]; then
            echo "No tags starting with 'server' found."
            echo "skip=true" >> $GITHUB_OUTPUT
          else
            echo "Found latest server tag: $LATEST_SERVER_TAG"
            echo "skip=false" >> $GITHUB_OUTPUT
            echo "tag=$LATEST_SERVER_TAG" >> $GITHUB_OUTPUT
          fi
        shell: bash

      - name: Set release tag
        id: set_tag
        if: needs.check_release.outputs.tag != 'latest_server'
        run: |
          echo "skip=false" >> $GITHUB_OUTPUT
          echo "tag=${{ needs.check_release.outputs.tag }}" >> $GITHUB_OUTPUT

      - name: Skip build if no server tag found
        if: (steps.find_tag.outputs.skip == 'true' && needs.check_release.outputs.tag == 'latest_server')
        run: |
          echo "Skipping build because no tag starting with 'server' was found."
          exit 1

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      - name: Log in to Docker Hub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Determine tag to use
        id: determine_tag
        run: |
          if [ "${{ needs.check_release.outputs.tag }}" == "latest_server" ]; then
            TAG="${{ steps.find_tag.outputs.tag }}"
          else
            TAG="${{ needs.check_release.outputs.tag }}"
          fi
          echo "Using tag: $TAG"
          echo "tag=$TAG" >> $GITHUB_OUTPUT

      - name: Sanitize tag name
        id: sanitize
        run: echo "SANITIZED_TAG_NAME=$(echo ${{ steps.determine_tag.outputs.tag }} | tr '/' '-' | tr '+' '-')" >> $GITHUB_OUTPUT

      - name: Build and push
        uses: docker/build-push-action@v2
        with:
          context: ./app/
          file: ./app/server/Dockerfile
          push: true
          platforms: linux/amd64,linux/arm64
          tags: |
            plandexai/plandex-server:${{ steps.sanitize.outputs.SANITIZED_TAG_NAME }}
            plandexai/plandex-server:latest

================================================
FILE: .gitignore
================================================
.plandex/
.plandex-dev/
.plandex-v2/
.plandex-dev-v2/
.envkey
.env
.env.*
plandex
plandex-dev
plandex-server
*.exe
node_modules/
/tools/
/static/
/infra/
/payments-dashboard/
.DS_Store
.goreleaser.yml
dist/
__pycache__/

.aider.*
*.code-workspace

__pycache__/

.repo_ignore

================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2025 PlandexAI Inc.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

================================================
FILE: README.md
================================================
<h1 align="center">
 <a href="https://plandex.ai">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="images/plandex-logo-dark-v2.png"/>
    <source media="(prefers-color-scheme: light)" srcset="images/plandex-logo-light-v2.png"/>
    <img width="400" src="images/plandex-logo-dark-bg-v2.png"/>
 </a>
 <br />
</h1>
<br />

<div align="center">

<p align="center">
  <!-- Call to Action Links -->
  <a href="#install">
    <b>30-Second Install</b>
  </a>
   ·
  <a href="https://plandex.ai">
    <b>Website</b>
  </a>
   ·
  <a href="https://docs.plandex.ai/">
    <b>Docs</b>
  </a>
   ·
  <a href="#examples-">
    <b>Examples</b>
  </a>
   ·
  <a href="https://docs.plandex.ai/hosting/self-hosting/local-mode-quickstart">
    <b>Local Self-Hosted Mode</b>
  </a>
</p>

<br>

[![Discord](https://img.shields.io/discord/1214825831973785600.svg?style=flat&logo=discord&label=Discord&refresh=1)](https://discord.gg/plandex-ai)
[![GitHub Repo stars](https://img.shields.io/github/stars/plandex-ai/plandex?style=social)](https://github.com/plandex-ai/plandex)
[![Twitter Follow](https://img.shields.io/twitter/follow/PlandexAI?style=social)](https://twitter.com/PlandexAI)

</div>

<p align="center">
  <!-- Badges -->
<a href="https://github.com/plandex-ai/plandex/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome" /></a> <a href="https://github.com/plandex-ai/plandex/releases?q=cli"><img src="https://img.shields.io/github/v/release/plandex-ai/plandex?filter=cli*" alt="Release" /></a>
<a href="https://github.com/plandex-ai/plandex/releases?q=server"><img src="https://img.shields.io/github/v/release/plandex-ai/plandex?filter=server*" alt="Release" /></a>

  <!-- <a href="https://github.com/your_username/your_project/issues">
    <img src="https://img.shields.io/github/issues-closed/your_username/your_project.svg" alt="Issues Closed" />
  </a> -->

</p>

<br />

<div align="center">
<a href="https://trendshift.io/repositories/8994" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8994" alt="plandex-ai%2Fplandex | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
</div>

<br>

<h1 align="center" >
  An AI coding agent designed for large tasks and real world projects.<br/><br/>
</h1>

<!-- <h2 align="center">
  Designed for large tasks and real world projects.<br/><br/>
  </h2> -->
  <br/>

<div align="center">
  <a href="https://www.youtube.com/watch?v=SFSu2vNmlLk">
    <img src="images/plandex-v2-yt.png" alt="Plandex v2 Demo Video" width="800">
  </a>
</div>

<br/>

💻  Plandex is a terminal-based AI development tool that can **plan and execute** large coding tasks that span many steps and touch dozens of files. It can handle up to 2M tokens of context directly (~100k per file), and can index directories with 20M tokens or more using tree-sitter project maps.

🔬  **A cumulative diff review sandbox** keeps AI-generated changes separate from your project files until they are ready to go. Command execution is controlled so you can easily roll back and debug. Plandex helps you get the most out of AI without leaving behind a mess in your project.

🧠  **Combine the best models** from Anthropic, OpenAI, Google, and open source providers to build entire features and apps with a robust terminal-based workflow.

🚀  Plandex is capable of <strong>full autonomy</strong>—it can load relevant files, plan and implement changes, execute commands, and automatically debug—but it's also highly flexible and configurable, giving developers fine-grained control and a step-by-step review process when needed.

💪  Plandex is designed to be resilient to <strong>large projects and files</strong>. If you've found that others tools struggle once your project gets past a certain size or the changes are too complex, give Plandex a shot.

## Smart context management that works in big projects

- 🐘 **2M token effective context window** with default model pack. Plandex loads only what's needed for each step.

- 🗄️ **Reliable in large projects and files.** Easily generate, review, revise, and apply changes spanning dozens of files.

- 🗺️ **Fast project map generation** and syntax validation with tree-sitter. Supports 30+ languages.

- 💰 **Context caching** is used across the board for OpenAI, Anthropic, and Google models, reducing costs and latency.

## Tight control or full autonomy—it's up to you

- 🚦 **Configurable autonomy:** go from full auto mode to fine-grained control depending on the task.

- 🐞 **Automated debugging** of terminal commands (like builds, linters, tests, deployments, and scripts). If you have Chrome installed, you can also automatically debug browser applications.

## Tools that help you get production-ready results

- 💬 **A project-aware chat mode** that helps you flesh out ideas before moving to implementation. Also great for asking questions and learning about a codebase.

- 🧠 **Easily try + combine models** from multiple providers. Curated model packs offer different tradeoffs of capability, cost, and speed, as well as open source and provider-specific packs.

- 🛡️ **Reliable file edits** that prioritize correctness. While most edits are quick and cheap, Plandex validates both syntax and logic as needed, with multiple fallback layers when there are problems.

- 🔀 **Full-fledged version control** for every update to the plan, including branches for exploring multiple paths or comparing different models.

- 📂 **Git integration** with commit message generation and optional automatic commits.

## Dev-friendly, easy to install

- 🧑‍💻 **REPL mode** with fuzzy auto-complete for commands and file loading. Just run `plandex` in any project to get started.

- 🛠️ **CLI interface** for scripting or piping data into context.

- 📦 **One-line, zero dependency CLI install**. Dockerized local mode for easily self-hosting the server. Cloud-hosting options for extra reliability and convenience.

## Workflow  🔄

<img src="images/plandex-workflow.png" alt="Plandex workflow" width="100%"/>

## Examples  🎥

  <br/>

<div align="center">
  <a href="https://www.youtube.com/watch?v=g-_76U_nK0Y">
    <img src="images/plandex-browser-debug-yt.png" alt="Plandex Browser Debugging Example" width="800">
  </a>
</div>

<br/>

## Install  📥

```bash
curl -sL https://plandex.ai/install.sh | bash
```

**Note:** Windows is supported via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install). Plandex only works correctly on Windows in the WSL shell. It doesn't work in the Windows CMD prompt or PowerShell.

[More installation options.](https://docs.plandex.ai/install)

## Hosting  ⚖️

| Option                     | Description                                                                                                                                                                                                                                                                                                                                                 |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plandex Cloud**          | Winding down as of 10/3/2025 and no longer accepting new users. <a href="https://plandex.ai/blog/winding-down">Learn more.</a>                                                                                                                                                                                                                              |
| **Self-hosted/Local Mode** | • Run Plandex locally with Docker or host on your own server.<br/>• Use your own [OpenRouter.ai](https://openrouter.ai) key (or [other model provider](https://docs.plandex.ai/models/model-providers) accounts and API keys).<br/>• Follow the [local-mode quickstart](https://docs.plandex.ai/hosting/self-hosting/local-mode-quickstart) to get started. |

## Provider keys  🔑

<!-- If you're going with a 'BYO API Key' option above (whether cloud or self-hosted), you'll need to set API keys for the [model providers](https://docs.plandex.ai/models/model-providers) you're using: -->

```bash
export OPENROUTER_API_KEY=... # if using OpenRouter.ai
```

<br/>

## Claude Pro/Max subscription  🖇️

If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. You'll be asked if you want to connect a subscription the first time you run Plandex.

<br/>

## Get started  🚀

First, `cd` into a **project directory** where you want to get something done or chat about the project. Make a new directory first with `mkdir your-project-dir` if you're starting on a new project.

```bash
cd your-project-dir
```

For a new project, you might also want to initialize a git repo. Plandex doesn't require that your project is in a git repo, but it does integrate well with git if you use it.

```bash
git init
```

Now start the Plandex REPL in your project:

```bash
plandex
```

or for short:

```bash
pdx
```

<!-- ☁️ _If you're using Plandex Cloud, you'll be prompted at this point to start a trial._

Then just give the REPL help text a quick read, and you're ready go. The REPL starts in _chat mode_ by default, which is good for fleshing out ideas before moving to implementation. Once the task is clear, Plandex will prompt you to switch to _tell mode_ to make a detailed plan and start writing code. -->

<br/>

## Docs  🛠️

### [👉  Full documentation.](https://docs.plandex.ai/)

<br/>

## Discussion and discord  💬

Please feel free to give your feedback, ask questions, report a bug, or just hang out:

- [Discord](https://discord.gg/plandex-ai)
- [Discussions](https://github.com/plandex-ai/plandex/discussions)
- [Issues](https://github.com/plandex-ai/plandex/issues)

## Follow and subscribe

- [Follow @PlandexAI](https://x.com/PlandexAI)
- [Follow @Danenania](https://x.com/Danenania) (Plandex's creator)
- [Subscribe on YouTube](https://x.com/PlandexAI)

<br/>

## Contributors  👥

⭐️  Please star, fork, explore, and contribute to Plandex. There's a lot of work to do and so much that can be improved.

[Here's an overview on setting up a development environment.](https://docs.plandex.ai/development)


================================================
FILE: app/.dockerignore
================================================
cli/
plandex-server

================================================
FILE: app/.gitignore
================================================
.env


================================================
FILE: app/clear_local.sh
================================================
#!/usr/bin/env bash

# Get the absolute path to the script's directory, regardless of where it's run from
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

# Change to the app directory if we're not already there
cd "$SCRIPT_DIR"

echo "WARNING: This will delete all Plandex server data and reset the database."
echo "This action cannot be undone."
read -p "Are you sure you want to continue? (y/N) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]
then
    echo "Reset cancelled."
    exit 1
fi

echo "Resetting local mode..."
echo "Stopping containers and removing volumes..."

# Stop containers and remove volumes
docker compose down -v

echo "Database and data directories cleared. Server stopped."

================================================
FILE: app/cli/api/clients.go
================================================
package api

import (
	"math"
	"math/rand"
	"net"
	"net/http"
	"os"
	"plandex-cli/auth"
	"plandex-cli/types"
	"time"
)

const dialTimeout = 10 * time.Second
const fastReqTimeout = 30 * time.Second
const slowReqTimeout = 5 * time.Minute

type Api struct{}

var CloudApiHost string
var Client types.ApiClient = (*Api)(nil)

func init() {
	if os.Getenv("PLANDEX_ENV") == "development" {
		CloudApiHost = os.Getenv("PLANDEX_API_HOST")
		if CloudApiHost == "" {
			CloudApiHost = "http://localhost:8099"
		}
	} else {
		CloudApiHost = "https://api-v2.plandex.ai"
	}
}

func GetApiHost() string {
	if auth.Current == nil {
		return CloudApiHost
	} else if auth.Current.IsCloud {
		return CloudApiHost
	} else {
		return auth.Current.Host
	}
}

type authenticatedTransport struct {
	underlyingTransport http.RoundTripper
}

func (t *authenticatedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	err := auth.SetAuthHeader(req)
	if err != nil {
		return nil, err
	}
	auth.SetVersionHeader(req)
	return t.underlyingTransport.RoundTrip(req)
}

type unauthenticatedTransport struct {
	underlyingTransport http.RoundTripper
}

func (t *unauthenticatedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	auth.SetVersionHeader(req)
	return t.underlyingTransport.RoundTrip(req)
}

type retryTransport struct {
	Base          http.RoundTripper
	MaxRetries    int
	BaseDelay     time.Duration
	MaxDelay      time.Duration
	Jitter        time.Duration
	RetryStatuses map[int]bool
}

func (t *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	if t.Base == nil {
		t.Base = http.DefaultTransport
	}
	var resp *http.Response
	var err error

	for attempt := 0; attempt <= t.MaxRetries; attempt++ {
		resp, err = t.Base.RoundTrip(req)

		// If there's a low-level error (e.g. network), retry unless it's a timeout, as these are often transient.
		if err != nil {
			if netErr, ok := err.(net.Error); ok {
				if netErr.Timeout() {
					return resp, err
				}
			}
			// continue to next attempt
		} else {
			// If status code not in our RetryStatuses, return immediately.
			if !t.RetryStatuses[resp.StatusCode] {
				return resp, nil
			}

			// Close the body before retrying.
			_ = resp.Body.Close()
		}

		// If we reached the max, break out of loop (will return last resp).
		if attempt == t.MaxRetries {
			break
		}

		// Exponential backoff + jitter
		backoff := float64(t.BaseDelay) * math.Pow(2, float64(attempt))
		if backoff > float64(t.MaxDelay) {
			backoff = float64(t.MaxDelay)
		}
		sleepDuration := time.Duration(backoff) + time.Duration(rand.Int63n(int64(t.Jitter)))
		time.Sleep(sleepDuration)
	}
	return resp, err
}

var netDialer = &net.Dialer{
	Timeout: dialTimeout,
}

var baseTransport = &http.Transport{
	Dial: netDialer.Dial,
}

var sharedRetryTransport = &retryTransport{
	Base:          baseTransport,
	MaxRetries:    3,
	BaseDelay:     500 * time.Millisecond,
	MaxDelay:      5 * time.Second,
	Jitter:        300 * time.Millisecond,
	RetryStatuses: map[int]bool{502: true, 503: true, 504: true},
}

var unauthenticatedClient = &http.Client{
	Transport: &unauthenticatedTransport{
		underlyingTransport: sharedRetryTransport,
	},
	Timeout: fastReqTimeout,
}

var authenticatedFastClient = &http.Client{
	Transport: &authenticatedTransport{
		underlyingTransport: sharedRetryTransport,
	},
	Timeout: fastReqTimeout,
}

var authenticatedSlowClient = &http.Client{
	Transport: &authenticatedTransport{
		underlyingTransport: sharedRetryTransport,
	},
	Timeout: slowReqTimeout,
}

var authenticatedStreamingClient = &http.Client{
	Transport: &authenticatedTransport{
		underlyingTransport: sharedRetryTransport,
	},
}


================================================
FILE: app/cli/api/errors.go
================================================
package api

import (
	"encoding/json"
	"log"
	"net/http"
	"plandex-cli/auth"
	"plandex-cli/term"
	"strings"

	shared "plandex-shared"
)

func HandleApiError(r *http.Response, errBody []byte) *shared.ApiError {
	// Check if the response is JSON
	if r.Header.Get("Content-Type") != "application/json" {
		return &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: r.StatusCode,
			Msg:    strings.TrimSpace(string(errBody)),
		}
	}

	var apiError shared.ApiError
	if err := json.Unmarshal(errBody, &apiError); err != nil {
		log.Printf("Error unmarshalling JSON: %v\n", err)
		return &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: r.StatusCode,
			Msg:    strings.TrimSpace(string(errBody)),
		}
	}

	// return error if token/auth refresh is needed
	if apiError.Type == shared.ApiErrorTypeInvalidToken || apiError.Type == shared.ApiErrorTypeAuthOutdated {
		return &apiError
	}

	term.HandleApiError(&apiError)

	return &apiError
}

func refreshAuthIfNeeded(apiErr *shared.ApiError) (bool, *shared.ApiError) {
	if apiErr.Type == shared.ApiErrorTypeInvalidToken {
		err := auth.RefreshInvalidToken()
		if err != nil {
			return false, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: "error refreshing invalid token"}
		}
		return true, nil
	} else if apiErr.Type == shared.ApiErrorTypeAuthOutdated {
		err := auth.RefreshAuth()
		if err != nil {
			return false, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: "error refreshing auth"}
		}

		return true, nil
	}

	return false, apiErr
}


================================================
FILE: app/cli/api/methods.go
================================================
package api

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-cli/types"
	"strings"

	shared "plandex-shared"

	"github.com/shopspring/decimal"
)

func (a *Api) CreateCliTrialSession() (string, *shared.ApiError) {
	serverUrl := CloudApiHost + "/accounts/cli_trial_session"

	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", nil)

	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		return "", apiErr
	}

	bytes, err := io.ReadAll(resp.Body)

	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response: %v", err)}
	}

	return string(bytes), nil
}

func (a *Api) GetCliTrialSession(token string) (*shared.SessionResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/accounts/cli_trial_session/%s", CloudApiHost, token)

	resp, err := unauthenticatedClient.Get(serverUrl)

	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	if resp.StatusCode == 404 {
		return nil, nil
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		return nil, apiErr
	}

	var session shared.SessionResponse
	err = json.NewDecoder(resp.Body).Decode(&session)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &session, nil
}

func (a *Api) CreateProject(req shared.CreateProjectRequest) (*shared.CreateProjectResponse, *shared.ApiError) {
	serverUrl := GetApiHost() + "/projects"

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreateProject(req)
		}
		return nil, apiErr
	}

	var respBody shared.CreateProjectResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &respBody, nil
}

func (a *Api) ListProjects() ([]*shared.Project, *shared.ApiError) {
	serverUrl := GetApiHost() + "/projects"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListProjects()
		}
		return nil, apiErr
	}

	var projects []*shared.Project
	err = json.NewDecoder(resp.Body).Decode(&projects)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return projects, nil
}

func (a *Api) SetProjectPlan(projectId string, req shared.SetProjectPlanRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/projects/%s/set_plan", GetApiHost(), projectId)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.SetProjectPlan(projectId, req)
		}
		return apiErr
	}

	return nil
}

func (a *Api) RenameProject(projectId string, req shared.RenameProjectRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/projects/%s/rename", GetApiHost(), projectId)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.RenameProject(projectId, req)
		}
		return apiErr
	}

	return nil
}
func (a *Api) ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans?", GetApiHost())
	parts := []string{}
	for _, projectId := range projectIds {
		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
	}
	serverUrl += strings.Join(parts, "&")

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.ListPlans(projectIds)
		}
		return nil, apiErr
	}

	var plans []*shared.Plan
	err = json.NewDecoder(resp.Body).Decode(&plans)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return plans, nil
}

func (a *Api) ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/archive?", GetApiHost())
	parts := []string{}
	for _, projectId := range projectIds {
		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
	}
	serverUrl += strings.Join(parts, "&")

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListArchivedPlans(projectIds)
		}
		return nil, apiErr
	}

	var plans []*shared.Plan
	err = json.NewDecoder(resp.Body).Decode(&plans)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return plans, nil
}

func (a *Api) ListPlansRunning(projectIds []string, includeRecent bool) (*shared.ListPlansRunningResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/ps?", GetApiHost())
	parts := []string{}
	for _, projectId := range projectIds {
		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
	}
	serverUrl += strings.Join(parts, "&")
	if includeRecent {
		serverUrl += "&recent=true"
	}

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListPlansRunning(projectIds, includeRecent)
		}
		return nil, apiErr
	}

	var respBody *shared.ListPlansRunningResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return respBody, nil
}

func (a *Api) GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/projects/%s/plans/current_branches", GetApiHost(), projectId)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))

	if err != nil {
		return nil, &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)

	if err != nil {
		return nil, &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.GetCurrentBranchByPlanId(projectId, req)
		}
		return nil, apiErr
	}

	var respBody map[string]*shared.Branch
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return respBody, nil
}

func (a *Api) CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/projects/%s/plans", GetApiHost(), projectId)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreatePlan(projectId, req)
		}
		return nil, apiErr
	}

	var respBody shared.CreatePlanResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &respBody, nil
}

func (a *Api) GetPlan(planId string) (*shared.Plan, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s", GetApiHost(), planId)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetPlan(planId)
		}
		return nil, apiErr
	}

	var plan shared.Plan
	err = json.NewDecoder(resp.Body).Decode(&plan)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &plan, nil
}

func (a *Api) DeletePlan(planId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s", GetApiHost(), planId)

	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.DeletePlan(planId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) DeleteAllPlans(projectId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/projects/%s/plans", GetApiHost(), projectId)

	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)

		if didRefresh {
			return a.DeleteAllPlans(projectId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) TellPlan(planId, branch string, req shared.TellPlanRequest, onStream types.OnStreamPlan) *shared.ApiError {

	serverUrl := fmt.Sprintf("%s/plans/%s/%s/tell", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	var client *http.Client
	if req.ConnectStream {
		client = authenticatedStreamingClient
	} else {
		client = authenticatedFastClient
	}

	resp, err := client.Do(request)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)

		if didRefresh {
			return a.TellPlan(planId, branch, req, onStream)
		}
		return apiErr
	}

	if req.ConnectStream {
		log.Println("Connecting stream")
		connectPlanRespStream(resp.Body, onStream)
	} else {
		// log.Println("Background exec - not connecting stream")
		resp.Body.Close()
	}

	return nil
}

func (a *Api) BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStream types.OnStreamPlan) *shared.ApiError {

	log.Println("Calling BuildPlan")

	serverUrl := fmt.Sprintf("%s/plans/%s/%s/build", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	var client *http.Client
	if req.ConnectStream {
		client = authenticatedStreamingClient
	} else {
		client = authenticatedFastClient
	}

	resp, err := client.Do(request)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	if resp.StatusCode >= 400 {
		log.Println("Error response from build plan", resp.StatusCode)

		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)

		if didRefresh {
			return a.BuildPlan(planId, branch, req, onStream)
		}
		return apiErr
	}

	if req.ConnectStream {
		log.Println("Connecting stream")
		connectPlanRespStream(resp.Body, onStream)
	} else {
		// log.Println("Background exec - not connecting stream")
		resp.Body.Close()
	}

	return nil
}

func (a *Api) RespondMissingFile(planId, branch string, req shared.RespondMissingFileRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/respond_missing_file", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)

		if didRefresh {
			return a.RespondMissingFile(planId, branch, req)
		}
		return apiErr
	}

	return nil

}

func (a *Api) ConnectPlan(planId, branch string, onStream types.OnStreamPlan) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/connect", GetApiHost(), planId, branch)

	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedStreamingClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)

		if didRefresh {
			return a.ConnectPlan(planId, branch, onStream)
		}

		return apiErr
	}

	connectPlanRespStream(resp.Body, onStream)

	return nil
}

func (a *Api) StopPlan(ctx context.Context, planId, branch string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/stop", GetApiHost(), planId, branch)

	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.StopPlan(ctx, planId, branch)
		}
		return apiErr
	}

	return nil
}

func (a *Api) GetCurrentPlanState(planId, branch string) (*shared.CurrentPlanState, *shared.ApiError) {
	return a.getCurrentPlanState(planId, branch, "")
}

func (a *Api) GetCurrentPlanStateAtSha(planId, sha string) (*shared.CurrentPlanState, *shared.ApiError) {
	return a.getCurrentPlanState(planId, "", sha)
}

func (a *Api) getCurrentPlanState(planId, branch, sha string) (*shared.CurrentPlanState, *shared.ApiError) {
	var serverUrl string
	if sha != "" {
		serverUrl = fmt.Sprintf("%s/plans/%s/current_plan/%s", GetApiHost(), planId, sha)
	} else {
		serverUrl = fmt.Sprintf("%s/plans/%s/%s/current_plan", GetApiHost(), planId, branch)
	}

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.getCurrentPlanState(planId, branch, sha)
		}
		return nil, apiErr
	}

	var state shared.CurrentPlanState
	err = json.NewDecoder(resp.Body).Decode(&state)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &state, nil
}

func (a *Api) ApplyPlan(planId, branch string, req shared.ApplyPlanRequest) (string, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/apply", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return "", &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return "", &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return "", &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.ApplyPlan(planId, branch, req)
		}
		return "", apiErr
	}

	// Reading the body on success
	responseData, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", &shared.ApiError{Msg: fmt.Sprintf("error reading response body: %v", err)}
	}

	return string(responseData), nil
}

func (a *Api) ArchivePlan(planId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/archive", GetApiHost(), planId)

	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.ArchivePlan(planId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) UnarchivePlan(planId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/unarchive", GetApiHost(), planId)

	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.ArchivePlan(planId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) RenamePlan(planId string, name string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/rename", GetApiHost(), planId)

	reqBytes, err := json.Marshal(shared.RenamePlanRequest{Name: name})
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))

	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)

	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.RenamePlan(planId, name)
		}
		return apiErr
	}

	return nil
}

func (a *Api) RejectAllChanges(planId, branch string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_all", GetApiHost(), planId, branch)

	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			return a.RejectAllChanges(planId, branch)
		}
		return apiErr
	}

	return nil
}

func (a *Api) RejectFile(planId, branch, filePath string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_file", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(shared.RejectFileRequest{FilePath: filePath})

	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	req, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			a.RejectFile(planId, branch, filePath)
		}
		return apiErr
	}

	return nil
}

func (a *Api) RejectFiles(planId, branch string, paths []string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_files", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(shared.RejectFilesRequest{Paths: paths})

	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	req, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
		if didRefresh {
			a.RejectFiles(planId, branch, paths)
		}
		return apiErr
	}

	return nil
}

func (a *Api) LoadContext(planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	// use the slow client since we may be uploading relatively large files
	resp, err := authenticatedSlowClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.LoadContext(planId, branch, req)
		}
		return nil, apiErr
	}

	var loadContextResponse shared.LoadContextResponse
	err = json.NewDecoder(resp.Body).Decode(&loadContextResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &loadContextResponse, nil
}

func (a *Api) UpdateContext(planId, branch string, req shared.UpdateContextRequest) (*shared.UpdateContextResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))

	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	request.Header.Set("Content-Type", "application/json")

	// use the slow client since we may be uploading relatively large files
	resp, err := authenticatedSlowClient.Do(request)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdateContext(planId, branch, req)
		}
		return nil, apiErr
	}

	var updateContextResponse shared.UpdateContextResponse
	err = json.NewDecoder(resp.Body).Decode(&updateContextResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &updateContextResponse, nil
}

func (a *Api) DeleteContext(planId, branch string, req shared.DeleteContextRequest) (*shared.DeleteContextResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodDelete, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.DeleteContext(planId, branch, req)
		}
		return nil, apiErr
	}

	var deleteContextResponse shared.DeleteContextResponse
	err = json.NewDecoder(resp.Body).Decode(&deleteContextResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &deleteContextResponse, nil
}

func (a *Api) ListContext(planId, branch string) ([]*shared.Context, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListContext(planId, branch)
		}
		return nil, apiErr
	}

	var contexts []*shared.Context
	err = json.NewDecoder(resp.Body).Decode(&contexts)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return contexts, nil
}

func (a *Api) LoadCachedFileMap(planId, branch string, req shared.LoadCachedFileMapRequest) (*shared.LoadCachedFileMapResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/load_cached_file_map", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		return nil, apiErr
	}

	var loadResp shared.LoadCachedFileMapResponse
	err = json.NewDecoder(resp.Body).Decode(&loadResp)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &loadResp, nil
}

func (a *Api) ListConvo(planId, branch string) ([]*shared.ConvoMessage, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/convo", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListConvo(planId, branch)
		}
		return nil, apiErr
	}

	var convos []*shared.ConvoMessage
	err = json.NewDecoder(resp.Body).Decode(&convos)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return convos, nil
}

func (a *Api) GetPlanStatus(planId, branch string) (string, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/status", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetPlanStatus(planId, branch)
		}
		return "", apiErr
	}

	body, err := io.ReadAll(resp.Body)

	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
	}

	return string(body), nil
}

func (a *Api) GetPlanDiffs(planId, branch string, plain bool) (string, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/diffs", GetApiHost(), planId, branch)

	if plain {
		serverUrl += "?plain=true"
	}

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetPlanDiffs(planId, branch, plain)
		}
		return "", apiErr
	}

	body, err := io.ReadAll(resp.Body)

	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
	}

	return string(body), nil
}

func (a *Api) ListLogs(planId, branch string) (*shared.LogResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/logs", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListLogs(planId, branch)
		}
		return nil, apiErr
	}

	var logs shared.LogResponse
	err = json.NewDecoder(resp.Body).Decode(&logs)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &logs, nil
}

func (a *Api) RewindPlan(planId, branch string, req shared.RewindPlanRequest) (*shared.RewindPlanResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/rewind", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}

	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.RewindPlan(planId, branch, req)
		}
		return nil, apiErr
	}

	var rewindPlanResponse shared.RewindPlanResponse
	err = json.NewDecoder(resp.Body).Decode(&rewindPlanResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &rewindPlanResponse, nil
}

func (a *Api) SignIn(req shared.SignInRequest, customHost string) (*shared.SessionResponse, *shared.ApiError) {
	host := customHost
	if host == "" {
		host = CloudApiHost
	}
	serverUrl := host + "/accounts/sign_in"
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		return nil, apiErr
	}

	var sessionResponse shared.SessionResponse
	err = json.NewDecoder(resp.Body).Decode(&sessionResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &sessionResponse, nil
}

func (a *Api) CreateAccount(req shared.CreateAccountRequest, customHost string) (*shared.SessionResponse, *shared.ApiError) {
	host := customHost
	if host == "" {
		host = CloudApiHost
	}
	serverUrl := host + "/accounts"
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		return nil, apiErr
	}

	var sessionResponse shared.SessionResponse
	err = json.NewDecoder(resp.Body).Decode(&sessionResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &sessionResponse, nil
}

func (a *Api) CreateOrg(req shared.CreateOrgRequest) (*shared.CreateOrgResponse, *shared.ApiError) {
	serverUrl := GetApiHost() + "/orgs"
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreateOrg(req)
		}
		return nil, apiErr
	}

	var createOrgResponse shared.CreateOrgResponse
	err = json.NewDecoder(resp.Body).Decode(&createOrgResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &createOrgResponse, nil
}

func (a *Api) GetOrgSession() (*shared.Org, *shared.ApiError) {
	serverUrl := GetApiHost() + "/orgs/session"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetOrgSession()
		}
		return nil, apiErr
	}

	var org *shared.Org

	err = json.NewDecoder(resp.Body).Decode(&org)

	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return org, nil
}

func (a *Api) ListOrgs() ([]*shared.Org, *shared.ApiError) {
	serverUrl := GetApiHost() + "/orgs"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListOrgs()
		}
		return nil, apiErr
	}

	var orgs []*shared.Org
	err = json.NewDecoder(resp.Body).Decode(&orgs)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return orgs, nil
}

func (a *Api) GetOrgUserConfig() (*shared.OrgUserConfig, *shared.ApiError) {
	serverUrl := GetApiHost() + "/org_user_config"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetOrgUserConfig()
		}
		return nil, apiErr
	}

	var orgUserConfig shared.OrgUserConfig
	err = json.NewDecoder(resp.Body).Decode(&orgUserConfig)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &orgUserConfig, nil
}

func (a *Api) UpdateOrgUserConfig(c shared.OrgUserConfig) *shared.ApiError {
	serverUrl := GetApiHost() + "/org_user_config"

	reqBytes, err := json.Marshal(c)

	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdateOrgUserConfig(c)
		}
		return apiErr
	}

	return nil
}

func (a *Api) DeleteUser(userId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/orgs/users/%s", GetApiHost(), userId)
	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.DeleteUser(userId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) ListOrgRoles() ([]*shared.OrgRole, *shared.ApiError) {
	serverUrl := GetApiHost() + "/orgs/roles"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListOrgRoles()
		}
		return nil, apiErr
	}

	var roles []*shared.OrgRole
	err = json.NewDecoder(resp.Body).Decode(&roles)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return roles, nil
}

func (a *Api) InviteUser(req shared.InviteRequest) *shared.ApiError {
	serverUrl := GetApiHost() + "/invites"
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.InviteUser(req)
		}
		return apiErr
	}

	return nil
}

func (a *Api) ListPendingInvites() ([]*shared.Invite, *shared.ApiError) {
	serverUrl := GetApiHost() + "/invites/pending"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListPendingInvites()
		}
		return nil, apiErr
	}

	var invites []*shared.Invite
	err = json.NewDecoder(resp.Body).Decode(&invites)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return invites, nil
}

func (a *Api) ListAcceptedInvites() ([]*shared.Invite, *shared.ApiError) {
	serverUrl := GetApiHost() + "/invites/accepted"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListAcceptedInvites()
		}
		return nil, apiErr
	}

	var invites []*shared.Invite
	err = json.NewDecoder(resp.Body).Decode(&invites)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return invites, nil
}

func (a *Api) ListAllInvites() ([]*shared.Invite, *shared.ApiError) {
	serverUrl := GetApiHost() + "/invites/all"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListAllInvites()
		}
		return nil, apiErr
	}

	var invites []*shared.Invite
	err = json.NewDecoder(resp.Body).Decode(&invites)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return invites, nil
}

func (a *Api) DeleteInvite(inviteId string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/invites/%s", GetApiHost(), inviteId)
	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)

		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.DeleteInvite(inviteId)
		}
		return apiErr
	}

	return nil
}

func (a *Api) CreateEmailVerification(email, customHost, userId string) (*shared.CreateEmailVerificationResponse, *shared.ApiError) {
	host := customHost
	if host == "" {
		host = CloudApiHost
	}
	serverUrl := host + "/accounts/email_verifications"
	req := shared.CreateEmailVerificationRequest{Email: email, UserId: userId}
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		return nil, HandleApiError(resp, errorBody)
	}

	var verificationResponse shared.CreateEmailVerificationResponse
	err = json.NewDecoder(resp.Body).Decode(&verificationResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &verificationResponse, nil
}

func (a *Api) CreateSignInCode() (string, *shared.ApiError) {
	serverUrl := GetApiHost() + "/accounts/sign_in_codes"
	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", nil)
	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreateSignInCode()
		}
		return "", apiErr
	}

	var signInCode string
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
	}
	signInCode = string(body)

	return signInCode, nil
}

func (a *Api) SignOut() *shared.ApiError {
	serverUrl := GetApiHost() + "/accounts/sign_out"

	req, err := http.NewRequest(http.MethodPost, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		return HandleApiError(resp, errorBody)
	}

	return nil
}

func (a *Api) ListUsers() (*shared.ListUsersResponse, *shared.ApiError) {
	serverUrl := GetApiHost() + "/users"
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListUsers()
		}
		return nil, apiErr
	}

	var r *shared.ListUsersResponse
	err = json.NewDecoder(resp.Body).Decode(&r)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return r, nil
}

func (a *Api) ListBranches(planId string) ([]*shared.Branch, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/branches", GetApiHost(), planId)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListBranches(planId)
		}
		return nil, apiErr
	}

	var branches []*shared.Branch
	err = json.NewDecoder(resp.Body).Decode(&branches)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return branches, nil
}

func (a *Api) CreateBranch(planId, branch string, req shared.CreateBranchRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/branches", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreateBranch(planId, branch, req)
		}
		return apiErr
	}

	return nil
}

func (a *Api) DeleteBranch(planId, branch string) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/branches/%s", GetApiHost(), planId, branch)

	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
	}

	resp, err := authenticatedFastClient.Do(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.DeleteBranch(planId, branch)
		}
		return apiErr
	}

	return nil
}

func (a *Api) GetSettings(planId, branch string) (*shared.PlanSettings, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/settings", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)

	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetSettings(planId, branch)
		}
		return nil, apiErr
	}

	var settings shared.PlanSettings
	err = json.NewDecoder(resp.Body).Decode(&settings)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return &settings, nil
}

func (a *Api) UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/settings", GetApiHost(), planId, branch)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
	}

	// log.Println("UpdateSettings", string(reqBytes))

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdateSettings(planId, branch, req)
		}
		return nil, apiErr
	}

	var updateRes shared.UpdateSettingsResponse
	err = json.NewDecoder(resp.Body).Decode(&updateRes)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return &updateRes, nil

}

func (a *Api) GetOrgDefaultSettings() (*shared.PlanSettings, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/default_settings", GetApiHost())

	resp, err := authenticatedFastClient.Get(serverUrl)

	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetOrgDefaultSettings()
		}
		return nil, apiErr
	}

	var settings shared.PlanSettings
	err = json.NewDecoder(resp.Body).Decode(&settings)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return &settings, nil
}

func (a *Api) UpdateOrgDefaultSettings(req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/default_settings", GetApiHost())

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
	}

	// log.Println("UpdateSettings", string(reqBytes))

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdateOrgDefaultSettings(req)
		}
		return nil, apiErr
	}

	var updateRes shared.UpdateSettingsResponse
	err = json.NewDecoder(resp.Body).Decode(&updateRes)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
	}

	return &updateRes, nil
}

func (a *Api) GetPlanConfig(planId string) (*shared.PlanConfig, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/config", GetApiHost(), planId)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetPlanConfig(planId)
		}
		return nil, apiErr
	}

	var res shared.GetPlanConfigResponse
	err = json.NewDecoder(resp.Body).Decode(&res)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return res.Config, nil
}

func (a *Api) UpdatePlanConfig(planId string, req shared.UpdatePlanConfigRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/plans/%s/config", GetApiHost(), planId)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdatePlanConfig(planId, req)
		}
		return apiErr
	}

	return nil
}

func (a *Api) GetDefaultPlanConfig() (*shared.PlanConfig, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/default_plan_config", GetApiHost())

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetDefaultPlanConfig()
		}
		return nil, apiErr
	}

	var res shared.GetDefaultPlanConfigResponse
	err = json.NewDecoder(resp.Body).Decode(&res)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return res.Config, nil
}

func (a *Api) UpdateDefaultPlanConfig(req shared.UpdateDefaultPlanConfigRequest) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/default_plan_config", GetApiHost())

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := authenticatedFastClient.Do(request)
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.UpdateDefaultPlanConfig(req)
		}
		return apiErr
	}

	return nil
}

func (a *Api) CreateCustomModels(input *shared.ModelsInput) *shared.ApiError {
	serverUrl := fmt.Sprintf("%s/custom_models", GetApiHost())
	body, err := json.Marshal(input)
	if err != nil {
		return &shared.ApiError{Msg: "Failed to marshal model"}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(body))
	if err != nil {
		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.CreateCustomModels(input)
		}
		return apiErr
	}

	return nil
}

func (a *Api) ListCustomModels() ([]*shared.CustomModel, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/custom_models", GetApiHost())
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListCustomModels()
		}
		return nil, apiErr
	}

	var models []*shared.CustomModel
	err = json.NewDecoder(resp.Body).Decode(&models)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return models, nil
}

func (a *Api) ListCustomProviders() ([]*shared.CustomProvider, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/custom_providers", GetApiHost())
	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListCustomProviders()
		}
		return nil, apiErr
	}

	var providers []*shared.CustomProvider
	err = json.NewDecoder(resp.Body).Decode(&providers)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return providers, nil
}

func (a *Api) ListModelPacks() ([]*shared.ModelPack, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/model_sets", GetApiHost())

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.ListModelPacks()
		}
		return nil, apiErr
	}

	var sets []*shared.ModelPack
	err = json.NewDecoder(resp.Body).Decode(&sets)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return sets, nil

}

func (a *Api) GetCreditsTransactions(pageSize, pageNum int, req shared.CreditsLogRequest) (*shared.CreditsLogResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/billing/credits_transactions?size=%d&page=%d", GetApiHost(), pageSize, pageNum)

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)

		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetCreditsTransactions(pageSize, pageNum, req)
		}
		return nil, apiErr
	}

	var res *shared.CreditsLogResponse
	err = json.NewDecoder(resp.Body).Decode(&res)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return res, nil
}

func (a *Api) GetCreditsSummary(req shared.CreditsLogRequest) (*shared.CreditsSummaryResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/billing/credits_summary", GetApiHost())

	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetCreditsSummary(req)
		}
		return nil, apiErr
	}

	var res *shared.CreditsSummaryResponse
	err = json.NewDecoder(resp.Body).Decode(&res)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return res, nil
}

func (a *Api) GetBalance() (decimal.Decimal, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/billing/balance", GetApiHost())

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return decimal.Zero, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetBalance()
		}
		return decimal.Zero, apiErr
	}

	var res *shared.GetBalanceResponse
	err = json.NewDecoder(resp.Body).Decode(&res)
	if err != nil {
		return decimal.Zero, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return res.Balance, nil
}

func (a *Api) GetFileMap(req shared.GetFileMapRequest) (*shared.GetFileMapResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/file_map", GetApiHost())
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	resp, err := authenticatedSlowClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetFileMap(req)
		}
		return nil, apiErr
	}

	var respBody shared.GetFileMapResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &respBody, nil
}

func (a *Api) GetContextBody(planId, branch, contextId string) (*shared.GetContextBodyResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context/%s/body", GetApiHost(), planId, branch, contextId)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetContextBody(planId, branch, contextId)
		}
		return nil, apiErr
	}

	var respBody shared.GetContextBodyResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &respBody, nil
}

func (a *Api) AutoLoadContext(ctx context.Context, planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/auto_load_context", GetApiHost(), planId, branch)
	reqBytes, err := json.Marshal(req)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
	}

	// Create a new request with context
	httpReq, err := http.NewRequestWithContext(ctx, "POST", serverUrl, bytes.NewBuffer(reqBytes))
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
	}

	// Set the content type header
	httpReq.Header.Set("Content-Type", "application/json")

	// Use the slow client since we may be uploading relatively large files
	resp, err := authenticatedSlowClient.Do(httpReq)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.LoadContext(planId, branch, req)
		}
		return nil, apiErr
	}

	var loadContextResponse shared.LoadContextResponse
	err = json.NewDecoder(resp.Body).Decode(&loadContextResponse)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &loadContextResponse, nil
}

func (a *Api) GetBuildStatus(planId, branch string) (*shared.GetBuildStatusResponse, *shared.ApiError) {
	serverUrl := fmt.Sprintf("%s/plans/%s/%s/build_status", GetApiHost(), planId, branch)

	resp, err := authenticatedFastClient.Get(serverUrl)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		errorBody, _ := io.ReadAll(resp.Body)
		apiErr := HandleApiError(resp, errorBody)
		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
		if authRefreshed {
			return a.GetBuildStatus(planId, branch)
		}
		return nil, apiErr
	}

	var respBody shared.GetBuildStatusResponse
	err = json.NewDecoder(resp.Body).Decode(&respBody)
	if err != nil {
		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
	}

	return &respBody, nil
}


================================================
FILE: app/cli/api/stream.go
================================================
package api

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"plandex-cli/types"
	"time"

	shared "plandex-shared"
)

// 3 heartbeat misses = timeout
const HeartbeatTimeout = 16 * time.Second

func connectPlanRespStream(body io.ReadCloser, onStream types.OnStreamPlan) {
	reader := bufio.NewReader(body)
	timer := time.NewTimer(HeartbeatTimeout)
	defer timer.Stop()

	go func() {
		for {
			select {
			case <-timer.C:
				log.Println("Connection to plan stream timed out due to missing heartbeats")
				onStream(types.OnStreamPlanParams{Msg: nil, Err: fmt.Errorf("connection to plan stream timed out due to missing heartbeats")})
				body.Close()
				return
			default:
			}

			s, err := readUntilSeparator(reader, shared.STREAM_MESSAGE_SEPARATOR)
			if err != nil {
				log.Println("Error reading line:", err)
				onStream(types.OnStreamPlanParams{Msg: nil, Err: err})
				body.Close()
				return
			}

			timer.Reset(HeartbeatTimeout)

			// ignore heartbeats
			if s == string(shared.StreamMessageHeartbeat) {
				continue
			}

			var msg shared.StreamMessage
			err = json.Unmarshal([]byte(s), &msg)
			if err != nil {
				log.Println("Error unmarshalling message:", err)
				onStream(types.OnStreamPlanParams{Msg: nil, Err: err})
				body.Close()
				return
			}

			// log.Println("connectPlanRespStream: received message:", msg)

			onStream(types.OnStreamPlanParams{Msg: &msg, Err: nil})

			if msg.Type == shared.StreamMessageFinished || msg.Type == shared.StreamMessageError || msg.Type == shared.StreamMessageAborted {
				body.Close()
				return
			}

		}
	}()
}

func readUntilSeparator(reader *bufio.Reader, separator string) (string, error) {
	var result []byte
	sepBytes := []byte(separator)
	for {
		b, err := reader.ReadByte()
		if err != nil {
			return string(result), err
		}
		result = append(result, b)
		if len(result) >= len(sepBytes) && bytes.HasSuffix(result, sepBytes) {
			return string(result[:len(result)-len(separator)]), nil
		}
	}
}


================================================
FILE: app/cli/auth/account.go
================================================
package auth

import (
	"fmt"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/fatih/color"
)

const AddAccountOption = "Add another account"

func SelectOrSignInOrCreate() error {
	accounts, err := loadAccounts()

	if err != nil {
		return fmt.Errorf("error loading accounts: %v", err)
	}

	if len(accounts) == 0 {
		err := promptSignInNewAccount()
		if err != nil {
			return fmt.Errorf("error signing in to new account: %v", err)
		}

		return nil
	}

	var options []string
	for _, account := range accounts {
		options = append(options, fmt.Sprintf("<%s> %s", account.UserName, account.Email))
	}

	options = append(options, AddAccountOption)

	// either select from existing accounts or sign in/create account

	selectedOpt, err := term.SelectFromList("Select an account:", options)

	if err != nil {
		return fmt.Errorf("error selecting account: %v", err)
	}

	if selectedOpt == AddAccountOption {
		err := promptSignInNewAccount()
		if err != nil {
			return fmt.Errorf("error prompting for sign in to new account: %v", err)
		}
		return nil
	}

	var selected *shared.ClientAccount
	for i, opt := range options {
		if selectedOpt == opt {
			selected = accounts[i]
			break
		}
	}

	if selected == nil {
		return fmt.Errorf("error selecting account: account not found")
	}

	selectedAuth := *selected

	setAuth(&shared.ClientAuth{
		ClientAccount: selectedAuth,
	})

	term.StartSpinner("")
	orgs, apiErr := apiClient.ListOrgs()
	term.StopSpinner()

	if apiErr != nil {
		return fmt.Errorf("error listing orgs: %v", apiErr.Msg)
	}

	org, err := resolveOrgAuth(orgs, selectedAuth.IsLocalMode)

	if err != nil {
		return fmt.Errorf("error resolving org: %v", err)
	}

	err = setAuth(&shared.ClientAuth{
		ClientAccount:        *selected,
		OrgId:                org.Id,
		OrgName:              org.Name,
		OrgIsTrial:           org.IsTrial,
		IntegratedModelsMode: org.IntegratedModelsMode,
	})

	if err != nil {
		return fmt.Errorf("error setting auth: %v", err)
	}

	_, apiErr = apiClient.GetOrgSession()

	if apiErr != nil {
		return fmt.Errorf("error getting org session: %v", apiErr.Msg)
	}

	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
	fmt.Println()

	if !term.IsRepl {
		term.PrintCmds("", "")
	}

	return nil
}

func SignInWithCode(code, host string) error {
	term.StartSpinner("")
	res, apiErr := apiClient.SignIn(shared.SignInRequest{
		Pin:          code,
		IsSignInCode: true,
	}, host)
	term.StopSpinner()

	if apiErr != nil {
		return fmt.Errorf("error signing in: %v", apiErr.Msg)
	}

	return handleSignInResponse(res, host)
}

func promptInitialAuth() error {
	fmt.Println("👋 Hey there!\nIt looks like this is your first time using Plandex on this computer.")

	err := SelectOrSignInOrCreate()

	if err != nil {
		return fmt.Errorf("error selecting or signing in to account: %v", err)
	}

	return nil
}

const (
	// SignInCloudOption = "Plandex Cloud"
	SignInLocalOption = "Local mode host"
	SignInOtherOption = "Another host"
)

func promptSignInNewAccount() error {
	selected, err := term.SelectFromList("Use local mode or another host?", []string{SignInLocalOption, SignInOtherOption})

	if err != nil {
		return fmt.Errorf("error selecting sign in option: %v", err)
	}

	var host string
	var email string

	if selected == SignInLocalOption {
		host, err = term.GetRequiredUserStringInputWithDefault("Host:", "http://localhost:8099")
	} else {
		host, err = term.GetRequiredUserStringInput("Host:")
	}

	if err != nil {
		return fmt.Errorf("error prompting host: %v", err)
	}

	if selected == SignInLocalOption {
		email = "local-admin@plandex.ai"
	} else {
		email, err = term.GetRequiredUserStringInput("Your email:")
	}

	if err != nil {
		return fmt.Errorf("error prompting email: %v", err)
	}

	res, err := verifyEmail(email, host)

	if err != nil {
		return fmt.Errorf("error verifying email: %v", err)
	}

	if res.hasAccount {
		err := signIn(email, res.pin, host)
		if err != nil {
			return fmt.Errorf("error signing in: %v", err)
		}
	} else {
		err := createAccount(email, res.pin, host, res.isLocalMode)
		if err != nil {
			return fmt.Errorf("error creating account: %v", err)
		}
	}

	if !term.IsRepl {
		term.PrintCmds("", "")
	}

	return nil
}

type verifyEmailRes struct {
	hasAccount  bool
	isLocalMode bool
	pin         string
}

func verifyEmail(email, host string) (*verifyEmailRes, error) {
	term.StartSpinner("")
	res, apiErr := apiClient.CreateEmailVerification(email, host, "")
	term.StopSpinner()

	if apiErr != nil {
		return nil, fmt.Errorf("error creating email verification: %v", apiErr.Msg)
	}

	if res.IsLocalMode {
		return &verifyEmailRes{
			hasAccount:  res.HasAccount,
			isLocalMode: true,
			pin:         "",
		}, nil
	}

	fmt.Println("✉️  You'll now receive a 6 character pin by email. It will be valid for 5 minutes.")

	pin, err := term.GetUserPasswordInput("Please enter your pin:")

	if err != nil {
		return nil, fmt.Errorf("error prompting pin: %v", err)
	}

	return &verifyEmailRes{
		hasAccount:  res.HasAccount,
		isLocalMode: false,
		pin:         pin,
	}, nil
}

func signIn(email, pin, host string) error {
	term.StartSpinner("")
	res, apiErr := apiClient.SignIn(shared.SignInRequest{
		Email: email,
		Pin:   pin,
	}, host)
	term.StopSpinner()

	if apiErr != nil {
		return fmt.Errorf("error signing in: %v", apiErr.Msg)
	}

	return handleSignInResponse(res, host)
}

func handleSignInResponse(res *shared.SessionResponse, host string) error {
	isLocalMode := host != "" && res.IsLocalMode

	err := setAuth(&shared.ClientAuth{
		ClientAccount: shared.ClientAccount{
			Email:       res.Email,
			UserId:      res.UserId,
			UserName:    res.UserName,
			Token:       res.Token,
			IsTrial:     false,
			IsCloud:     host == "",
			Host:        host,
			IsLocalMode: isLocalMode,
		},
	})

	if err != nil {
		return fmt.Errorf("error setting auth: %v", err)
	}

	org, err := resolveOrgAuth(res.Orgs, isLocalMode)

	if err != nil {
		return fmt.Errorf("error resolving org: %v", err)
	}

	Current.OrgId = org.Id
	Current.OrgName = org.Name
	Current.IntegratedModelsMode = org.IntegratedModelsMode

	err = writeCurrentAuth()

	if err != nil {
		return fmt.Errorf("error writing auth: %v", err)
	}

	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
	fmt.Println()

	return nil
}

func createAccount(email, pin, host string, isLocalMode bool) error {
	var name string

	if isLocalMode {
		name = "Local Admin"
	} else {
		var err error
		name, err = term.GetUserStringInput("Your name:")

		if err != nil {
			return fmt.Errorf("error prompting name: %v", err)
		}
	}

	term.StartSpinner("🌟 Creating account...")
	res, apiErr := apiClient.CreateAccount(shared.CreateAccountRequest{
		Email:    email,
		UserName: name,
		Pin:      pin,
	}, host)
	term.StopSpinner()

	if apiErr != nil {
		return fmt.Errorf("error creating account: %v", apiErr.Msg)
	}

	if res.IsLocalMode {
		isLocalMode = true
	}

	err := setAuth(&shared.ClientAuth{
		ClientAccount: shared.ClientAccount{
			Email:       res.Email,
			UserId:      res.UserId,
			UserName:    res.UserName,
			Token:       res.Token,
			IsTrial:     false,
			IsCloud:     host == "",
			Host:        host,
			IsLocalMode: isLocalMode,
		},
	})

	if err != nil {
		return fmt.Errorf("error setting auth: %v", err)
	}

	org, err := resolveOrgAuth(res.Orgs, isLocalMode)

	if err != nil {
		return fmt.Errorf("error resolving org: %v", err)
	}

	if org == nil {
		return fmt.Errorf("no org selected")
	}

	Current.OrgId = org.Id
	Current.OrgName = org.Name
	Current.IntegratedModelsMode = org.IntegratedModelsMode

	err = writeCurrentAuth()

	if err != nil {
		return fmt.Errorf("error writing auth: %v", err)
	}

	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
	fmt.Println()

	return nil
}


================================================
FILE: app/cli/auth/api.go
================================================
package auth

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"plandex-cli/types"
	"plandex-cli/version"

	shared "plandex-shared"
)

var apiClient types.ApiClient

func SetApiClient(client types.ApiClient) {
	apiClient = client
}

func SetAuthHeader(req *http.Request) error {
	if Current == nil {
		return fmt.Errorf("error setting auth header: auth not loaded")
	}
	hash := Current.ToHash()

	authHeader := shared.AuthHeader{
		Token: Current.Token,
		OrgId: Current.OrgId,
		Hash:  hash,
	}

	bytes, err := json.Marshal(authHeader)

	if err != nil {
		return fmt.Errorf("error marshalling auth header: %v", err)
	}

	// base64 encode
	token := base64.URLEncoding.EncodeToString(bytes)

	req.Header.Set("Authorization", "Bearer "+token)

	return nil
}

func SetVersionHeader(req *http.Request) {
	req.Header.Set("X-Client-Version", version.Version)
}


================================================
FILE: app/cli/auth/auth.go
================================================
package auth

import (
	"encoding/json"
	"fmt"
	"os"
	"plandex-cli/fs"
	"plandex-cli/term"

	shared "plandex-shared"
)

var openUnauthenticatedCloudURL func(msg, path string)
var openAuthenticatedURL func(msg, path string)

func SetOpenUnauthenticatedCloudURLFn(fn func(msg, path string)) {
	openUnauthenticatedCloudURL = fn
}

func SetOpenAuthenticatedURLFn(fn func(msg, path string)) {
	openAuthenticatedURL = fn
}

func MustResolveAuthWithOrg() {
	MustResolveAuth(true)
}

func MustResolveAuth(requireOrg bool) {
	if apiClient == nil {
		term.OutputErrorAndExit("error resolving auth: api client not set")
	}

	// load HomeAuthPath file into ClientAuth struct
	bytes, err := os.ReadFile(fs.HomeAuthPath)

	if err != nil {
		if os.IsNotExist(err) {
			err = promptInitialAuth()

			if err != nil {
				term.OutputErrorAndExit("error resolving auth: %v", err)
			}

			return
		} else {
			term.OutputErrorAndExit("error reading auth.json: %v", err)
		}
	}

	var auth shared.ClientAuth
	err = json.Unmarshal(bytes, &auth)
	if err != nil {
		term.OutputErrorAndExit("error unmarshalling auth.json: %v", err)
	}

	Current = &auth

	if requireOrg && Current.OrgId == "" {
		term.StartSpinner("")
		orgs, apiErr := apiClient.ListOrgs()
		term.StopSpinner()

		if apiErr != nil {
			term.OutputErrorAndExit("Error listing orgs: %v", apiErr.Msg)
		}

		org, err := resolveOrgAuth(orgs, Current.IsLocalMode)

		if err != nil {
			term.OutputErrorAndExit("Error resolving org: %v", err)
		}

		if org.Id == "" {
			// still no org--exit now
			term.OutputErrorAndExit("No org")
		}

		Current.OrgId = org.Id
		Current.OrgName = org.Name
		Current.IntegratedModelsMode = org.IntegratedModelsMode

		err = writeCurrentAuth()

		if err != nil {
			term.OutputErrorAndExit("Error writing auth: %v", err)
		}
	}
}

func RefreshInvalidToken() error {
	if Current == nil {
		return fmt.Errorf("error refreshing token: auth not loaded")
	}
	res, err := verifyEmail(Current.Email, Current.Host)

	if err != nil {
		return fmt.Errorf("error verifying email: %v", err)
	}

	if res.hasAccount {
		return signIn(Current.Email, res.pin, Current.Host)
	} else {
		host := Current.Host
		if host == "" {
			host = "Plandex Cloud"
		}

		term.OutputErrorAndExit("Account %s not found on %s", Current.Email, host)
	}

	return nil
}

func RefreshAuth() error {
	if Current == nil {
		return fmt.Errorf("error refreshing auth: auth not loaded")
	}

	org, apiErr := apiClient.GetOrgSession()

	if apiErr != nil {
		return fmt.Errorf("error getting org session: %v", apiErr.Msg)
	}

	Current.OrgName = org.Name
	Current.OrgIsTrial = org.IsTrial
	Current.IntegratedModelsMode = org.IntegratedModelsMode

	err := writeCurrentAuth()

	if err != nil {
		return fmt.Errorf("error writing auth: %v", err)
	}

	return nil
}


================================================
FILE: app/cli/auth/org.go
================================================
package auth

import (
	"fmt"
	"plandex-cli/term"
	"strings"

	shared "plandex-shared"
)

func resolveOrgAuth(orgs []*shared.Org, isLocalMode bool) (*shared.Org, error) {
	var org *shared.Org
	var err error

	if len(orgs) == 0 {
		if isLocalMode {
			org, err = createOrg(isLocalMode)
		} else {
			org, err = promptNoOrgs()
		}

		if err != nil {
			return nil, fmt.Errorf("error prompting no orgs: %v", err)
		}

	} else if len(orgs) == 1 {
		org = orgs[0]
	} else {
		org, err = selectOrg(orgs, isLocalMode)

		if err != nil {
			return nil, fmt.Errorf("error selecting org: %v", err)
		}
	}

	return org, nil
}

func promptNoOrgs() (*shared.Org, error) {
	fmt.Println("🧐 You don't have access to any orgs yet.\n\nTo join an existing org, ask an admin to either invite you directly or give your whole email domain access.\n\nOtherwise, you can go ahead and create a new org.")

	shouldCreate, err := term.ConfirmYesNo("Create a new org now?")

	if err != nil {
		return nil, fmt.Errorf("error prompting create org: %v", err)
	}

	if shouldCreate {
		return createOrg(false)
	}

	return nil, nil
}

func createOrg(isLocalMode bool) (*shared.Org, error) {
	var err error
	var name string
	var autoAddDomainUsers bool

	if isLocalMode {
		name = "Local Org"
	} else {
		name, err = term.GetRequiredUserStringInput("Org name:")
	}
	if err != nil {
		return nil, fmt.Errorf("error prompting org name: %v", err)
	}

	if !isLocalMode {
		autoAddDomainUsers, err = promptAutoAddUsersIfValid(Current.Email)
		if err != nil {
			return nil, fmt.Errorf("error prompting auto add domain users: %v", err)
		}
	}

	term.StartSpinner("")
	res, apiErr := apiClient.CreateOrg(shared.CreateOrgRequest{
		Name:               name,
		AutoAddDomainUsers: autoAddDomainUsers,
	})
	term.StopSpinner()

	if apiErr != nil {
		return nil, fmt.Errorf("error creating org: %v", apiErr.Msg)
	}

	return &shared.Org{Id: res.Id, Name: name}, nil
}

func promptAutoAddUsersIfValid(email string) (bool, error) {
	userDomain := strings.Split(email, "@")[1]
	var autoAddDomainUsers bool
	var err error
	if !shared.IsEmailServiceDomain(userDomain) {
		fmt.Println("With domain auto-join, you can allow any user with an email ending in @"+userDomain, "to auto-join this org.")
		autoAddDomainUsers, err = term.ConfirmYesNo(fmt.Sprintf("Enable auto-join for %s?", userDomain))

		if err != nil {
			return false, err
		}
	}
	return autoAddDomainUsers, nil
}

const CreateOrgOption = "Create a new org"

func selectOrg(orgs []*shared.Org, isLocalMode bool) (*shared.Org, error) {
	var options []string
	for _, org := range orgs {
		options = append(options, org.Name)
	}
	options = append(options, CreateOrgOption)

	selected, err := term.SelectFromList("Select an org:", options)

	if err != nil {
		return nil, fmt.Errorf("error selecting org: %v", err)
	}

	if selected == CreateOrgOption {
		return createOrg(isLocalMode)
	}

	var selectedOrg *shared.Org
	for _, org := range orgs {
		if org.Name == selected {
			selectedOrg = org
			break
		}
	}

	if selectedOrg == nil {
		return nil, fmt.Errorf("error selecting org: org not found")
	}

	return selectedOrg, nil
}


================================================
FILE: app/cli/auth/state.go
================================================
package auth

import (
	"encoding/json"
	"fmt"
	"os"
	"plandex-cli/fs"

	shared "plandex-shared"
)

var Current *shared.ClientAuth

func loadAccounts() ([]*shared.ClientAccount, error) {
	bytes, err := os.ReadFile(fs.HomeAccountsPath)

	if err != nil {
		if os.IsNotExist(err) {
			// no accounts
			return []*shared.ClientAccount{}, nil
		} else {
			return nil, fmt.Errorf("error reading accounts.json: %v", err)
		}
	}

	var accounts []*shared.ClientAccount
	err = json.Unmarshal(bytes, &accounts)

	if err != nil {
		return nil, fmt.Errorf("error unmarshalling accounts.json: %v", err)
	}

	return accounts, nil
}

func setAuth(auth *shared.ClientAuth) error {
	err := storeAccount(&auth.ClientAccount)

	if err != nil {
		return fmt.Errorf("error storing account: %v", err)
	}

	Current = auth

	err = writeCurrentAuth()

	if err != nil {
		return fmt.Errorf("error writing auth: %v", err)
	}

	return nil
}

func storeAccount(toStore *shared.ClientAccount) error {
	accounts, err := loadAccounts()

	if err != nil {
		return fmt.Errorf("error loading accounts: %v", err)
	}

	found := false
	for i, account := range accounts {
		if account.UserId == toStore.UserId {
			accounts[i] = toStore
			found = true
			break
		}
	}

	if !found {
		accounts = append(accounts, toStore)
	}

	bytes, err := json.Marshal(accounts)

	if err != nil {
		return fmt.Errorf("error marshalling accounts: %v", err)
	}

	err = os.WriteFile(fs.HomeAccountsPath, bytes, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error writing accounts: %v", err)
	}

	return nil
}

func writeCurrentAuth() error {
	if Current == nil {
		return fmt.Errorf("error writing auth: auth not loaded")
	}

	bytes, err := json.Marshal(Current)

	if err != nil {
		return fmt.Errorf("error marshalling auth: %v", err)
	}

	err = os.WriteFile(fs.HomeAuthPath, bytes, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error writing auth: %v", err)
	}

	return nil
}


================================================
FILE: app/cli/auth/trial.go
================================================
package auth

import (
	"fmt"
	"plandex-cli/term"
	"time"
)

func ConvertTrial() {
	openAuthenticatedURL("Opening Plandex Cloud upgrade flow in your browser.", "/settings/billing?upgrade=1&cliUpgrade=1")

	fmt.Println("\nCommand will continue automatically once you've upgraded...")
	fmt.Println()
	term.StartSpinner("")

	startTime := time.Now()
	expirationTime := startTime.Add(1 * time.Hour)

	for time.Now().Before(expirationTime) {
		org, apiErr := apiClient.GetOrgSession()

		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("error getting org session: %s", apiErr.Msg)
		}

		if org != nil && !org.IsTrial {
			term.StopSpinner()
			fmt.Println("🚀 Trial upgraded")
			fmt.Println()
			return
		}

		time.Sleep(1500 * time.Millisecond)
	}

	term.StopSpinner()
	term.OutputErrorAndExit("Timed out waiting for upgrade. Please try again. Email support@plandex.ai if the problem persists.")
}

func startTrial() {
	term.StartSpinner("")
	cliTrialToken, apiErr := apiClient.CreateCliTrialSession()
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("error starting trial: %s", apiErr.Msg)
	}

	openUnauthenticatedCloudURL(
		"Opening Plandex Cloud trial flow in your browser.",
		fmt.Sprintf("/start?cliTrialToken=%s", cliTrialToken),
	)

	fmt.Println("\nCommand will continue automatically once you've started your trial...")
	fmt.Println()
	term.StartSpinner("")

	startTime := time.Now()
	expirationTime := startTime.Add(1 * time.Hour)

	for time.Now().Before(expirationTime) {
		cliTrialSession, apiErr := apiClient.GetCliTrialSession(cliTrialToken)

		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("error getting cli trial session: %s", apiErr.Msg)
		}

		if cliTrialSession != nil {
			// Trial session is valid, break the loop and sign in
			term.StopSpinner()
			fmt.Println("🚀 Trial started")
			fmt.Println()
			err := handleSignInResponse(cliTrialSession, "")
			if err != nil {
				term.OutputErrorAndExit("error signing in after trial started: %s", err)
			}
			return
		}

		time.Sleep(1500 * time.Millisecond)
	}

	term.StopSpinner()
	term.OutputErrorAndExit("Timed out waiting for trial to start. Please try again. Email support@plandex.ai if the problem persists.")
}


================================================
FILE: app/cli/cmd/apply.go
================================================
package cmd

import (
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/term"
	"plandex-cli/types"

	"github.com/spf13/cobra"
)

var autoCommit, skipCommit, autoExec bool

func init() {
	initApplyFlags(applyCmd, false)
	initExecScriptFlags(applyCmd)
	RootCmd.AddCommand(applyCmd)

	applyCmd.Flags().BoolVar(&fullAuto, "full", false, "Apply the plan and debug in full auto mode")
}

var applyCmd = &cobra.Command{
	Use:     "apply",
	Aliases: []string{"ap"},
	Short:   "Apply a plan to the project",
	Run:     apply,
}

func apply(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if fullAuto {
		term.StartSpinner("")
		config := lib.MustGetCurrentPlanConfig()
		_, updatedConfig, printFn := resolveAutoModeSilent(config)
		lib.SetCachedPlanConfig(updatedConfig)
		term.StopSpinner()
		printFn()
	}

	mustSetPlanExecFlags(cmd, true)

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	applyFlags := types.ApplyFlags{
		AutoConfirm: true,
		AutoCommit:  autoCommit,
		NoCommit:    skipCommit,
		AutoExec:    autoExec,
		NoExec:      noExec,
		AutoDebug:   autoDebug,
	}

	tellFlags := types.TellFlags{
		TellBg:      tellBg,
		TellStop:    tellStop,
		TellNoBuild: tellNoBuild,
		AutoContext: tellAutoContext,
		ExecEnabled: !noExec,
		AutoApply:   tellAutoApply,
	}

	lib.MustApplyPlan(lib.ApplyPlanParams{
		PlanId:     lib.CurrentPlanId,
		Branch:     lib.CurrentBranch,
		ApplyFlags: applyFlags,
		TellFlags:  tellFlags,
		OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
	})
}


================================================
FILE: app/cli/cmd/archive.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var archiveCmd = &cobra.Command{
	Use:     "archive [name-or-index]",
	Aliases: []string{"arc"},
	Short:   "Archive a plan",
	Args:    cobra.MaximumNArgs(1),
	Run:     archive,
}

func init() {
	RootCmd.AddCommand(archiveCmd)
}

func archive(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	var nameOrIdx string
	if len(args) > 0 {
		nameOrIdx = strings.TrimSpace(args[0])
	}

	var plan *shared.Plan

	term.StartSpinner("")
	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No plans available to archive")
		return
	}

	if nameOrIdx == "" {
		opts := make([]string, len(plans))
		for i, p := range plans {
			opts[i] = p.Name
		}

		selected, err := term.SelectFromList("Select a plan to archive", opts)
		if err != nil {
			term.OutputErrorAndExit("Error selecting plan: %v", err)
		}

		for _, p := range plans {
			if p.Name == selected {
				plan = p
				break
			}
		}
	} else {
		idx, err := strconv.Atoi(nameOrIdx)
		if err == nil && idx > 0 && idx <= len(plans) {
			plan = plans[idx-1]
		} else {
			for _, p := range plans {
				if p.Name == nameOrIdx {
					plan = p
					break
				}
			}
		}
	}

	if plan == nil {
		term.OutputErrorAndExit("Plan not found")
	}

	err := api.Client.ArchivePlan(plan.Id)
	if err != nil {
		term.OutputErrorAndExit("Error archiving plan: %v", err)
	}

	fmt.Printf("✅ Plan %s archived\n", color.New(color.Bold, term.ColorHiYellow).Sprint(plan.Name))

	fmt.Println()

	term.PrintCmds("", "plans --archived", "unarchive")
}


================================================
FILE: app/cli/cmd/billing.go
================================================
package cmd

import (
	"plandex-cli/auth"
	"plandex-cli/term"
	"plandex-cli/ui"

	"github.com/spf13/cobra"
)

var billingCmd = &cobra.Command{
	Use:   "billing",
	Short: "Open the billing page in the browser",
	Run:   billing,
}

func init() {
	RootCmd.AddCommand(billingCmd)
}

func billing(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	if !auth.Current.IsCloud {
		term.OutputErrorAndExit("This command is only available for Plandex Cloud accounts.")
	}

	ui.OpenAuthenticatedURL("Opening billing page in your default browser...", "/settings/billing")
}


================================================
FILE: app/cli/cmd/branches.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/format"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var branchesCmd = &cobra.Command{
	Use:     "branches",
	Aliases: []string{"br"},
	Short:   "List plan branches",
	Run:     branches,
}

func init() {
	RootCmd.AddCommand(branchesCmd)
}

func branches(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")

	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)

	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
		return
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{"#", "Name", "Updated" /* "Created",*/, "Context", "Convo"})

	for i, b := range branches {
		num := strconv.Itoa(i + 1)
		if b.Name == lib.CurrentBranch {
			num = color.New(color.Bold, term.ColorHiGreen).Sprint(num)
		}

		var name string
		if b.Name == lib.CurrentBranch {
			name = color.New(color.Bold, term.ColorHiGreen).Sprint(b.Name) + " 👈"
		} else {
			name = b.Name
		}

		row := []string{
			num,
			name,
			format.Time(b.UpdatedAt),
			// format.Time(b.CreatedAt),
			strconv.Itoa(b.ContextTokens) + " 🪙",
			strconv.Itoa(b.ConvoTokens) + " 🪙",
		}

		var style []tablewriter.Colors
		if b.Name == lib.CurrentPlanId {
			style = []tablewriter.Colors{
				{tablewriter.FgGreenColor, tablewriter.Bold},
			}
		} else {
			style = []tablewriter.Colors{
				{tablewriter.Bold},
			}
		}

		table.Rich(row, style)

	}
	table.Render()
	fmt.Println()
	term.PrintCmds("", "checkout", "delete-branch")

}


================================================
FILE: app/cli/cmd/browser.go
================================================
package cmd

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"
	"os/exec"
	"os/signal"
	"runtime"
	"syscall"
	"time"

	chrome_log "github.com/chromedp/cdproto/log"
	chrome_runtime "github.com/chromedp/cdproto/runtime"
	"github.com/chromedp/cdproto/target"
	"github.com/chromedp/chromedp"
	"github.com/spf13/cobra"
)

var timeoutSeconds int

// browserCmd is our cobra command
var browserCmd = &cobra.Command{
	Use:   "browser [urls...]",
	Short: "Open browser windows with given URLs, capturing console logs and exiting on JS errors",
	RunE:  browser,
}

func init() {
	RootCmd.AddCommand(browserCmd)
	browserCmd.Flags().IntVar(&timeoutSeconds, "timeout", 10, "Timeout in seconds for browser to load")
}

// browser is the main function for our command.
func browser(cmd *cobra.Command, args []string) error {
	if len(args) == 0 {
		return errors.New("no URLs provided")
	}

	// See if we can find Chrome or Firefox in PATH:
	chromePath, _ := findChrome()

	if chromePath != "" {
		fmt.Println("Using Chrome (not default browser, but found in PATH).")
		return openChromeWithLogs(args)
	}

	// Fallback: open with OS default tool (open/xdg-open)
	fmt.Println("No Chrome or Firefox found; falling back to OS default opener.")
	return openWithOSDefault(args)
}

// findChrome returns the path to Chrome/Chromium if found, or "" if not found.
func findChrome() (string, error) {
	switch runtime.GOOS {
	case "darwin":
		// macOS standard installation paths
		macPaths := []string{
			"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
			"/Applications/Chromium.app/Contents/MacOS/Chromium",
		}
		for _, p := range macPaths {
			if _, err := os.Stat(p); err == nil {
				return p, nil
			}
		}
	case "linux", "freebsd":
		// Linux/FreeBSD (usually in PATH)
		candidates := []string{
			"google-chrome",
			"google-chrome-stable",
			"chromium",
			"chromium-browser",
		}
		for _, c := range candidates {
			if path, err := exec.LookPath(c); err == nil {
				return path, nil
			}
		}
	}
	return "", errors.New("Chrome/Chromium not found")
}

var pages = map[target.ID]string{}

// openChromeWithLogs uses chromedp to open each URL in a visible Chrome browser,
// logs JS console messages, and exits on the first JS error (or if user presses Ctrl+C).
func openChromeWithLogs(urls []string) error {
	if len(urls) == 0 {
		return errors.New("no URLs provided")
	}

	fmt.Println("Launching Chrome with console log capture...")
	// 1) Create a cancellable context that sets up a Chrome ExecAllocator
	rootCtx, cancelAllocator := chromedp.NewExecAllocator(context.Background(),
		chromedp.Flag("headless", false), // Visible, not headless
		chromedp.Flag("disable-gpu", false),
		chromedp.Flag("no-first-run", true),             // Avoid "Welcome" dialog
		chromedp.Flag("no-default-browser-check", true), // Avoid default browser dialog
		chromedp.Flag("disable-default-apps", true),     // Prevent default apps/extensions from loading
		chromedp.Flag("remote-debugging-port", "0"),     // Ensures separate debug session
	)
	defer cancelAllocator()

	// 2) Create a new browser context from the allocator
	browserCtx, cancelBrowser := chromedp.NewContext(rootCtx)
	defer cancelBrowser()

	// Add this to get the initial target
	var initialTargetID target.ID
	chromedp.ListenTarget(browserCtx, func(ev interface{}) {
		if e, ok := ev.(*target.EventTargetCreated); ok {
			// fmt.Printf("[DEBUG] Got event: %#v\n", e)
			if e.TargetInfo.Type == "page" {
				initialTargetID = e.TargetInfo.TargetID
			}
		}
	})

	if err := chromedp.Run(
		browserCtx,
		chrome_runtime.Enable(),
		chrome_log.Enable(),
	); err != nil {
		log.Fatal(err)
	}

	// Listen for console API calls & JS exceptions
	chromedp.ListenBrowser(browserCtx, func(ev interface{}) {
		// fmt.Printf("[DEBUG] Got event: %#v\n", ev)
		switch e := ev.(type) {

		case *target.EventTargetCreated:
		case *target.EventAttachedToTarget:
			// This sometimes also includes target info
			info := e.TargetInfo
			if info.Type == "page" {
				url := info.URL
				if url == "about:blank" {
					url = urls[0]
				}
				pages[info.TargetID] = url
			}

		case *target.EventTargetDestroyed:
			// Something was destroyed
			destroyedID := e.TargetID
			// Check if it was a top-level page
			if url, ok := pages[destroyedID]; ok {
				fmt.Printf("[CHROME] Closed page: %s\n", url)
				// remove from map
				delete(pages, destroyedID)
				// If that was your last page, do something:
				if len(pages) == 0 {
					cancelBrowser()
					cancelAllocator()
					os.Exit(0)
				} else {
					fmt.Printf("num pages left: %d\n", len(pages))
				}
			}
		}
	})

	// Channels to handle signals & error detection
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	errChan := make(chan bool, 1)

	// 3) Open all URLs in new tabs
	for i, url := range urls {
		// Reuse the initial browser tab for the first URL
		var ctx context.Context
		if i == 0 {
			ctx, _ = chromedp.NewContext(browserCtx, chromedp.WithTargetID(initialTargetID))
		} else {
			// Create a new tab for each additional URL
			ctx, _ = chromedp.NewContext(browserCtx)
		}
		tabCtx, _ := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)

		chromedp.ListenTarget(tabCtx, func(ev interface{}) {
			switch e := ev.(type) {
			case *chrome_runtime.EventConsoleAPICalled:
				logType := e.Type.String()
				for _, arg := range e.Args {
					val := arg.Value
					fmt.Printf("[CHROME:%s] %v\n", logType, val)
					if logType == "error" {
						fmt.Println("❌ Chrome console error")
						errChan <- true
					}
				}
			case *chrome_log.EventEntryAdded:
				fmt.Printf("[CHROME:Log:%s] %s\n", e.Entry.Level, e.Entry.Text)
			case *chrome_runtime.EventExceptionThrown:
				fmt.Printf("[CHROME:Exception] %s\n", e.ExceptionDetails.Error())
				fmt.Println("❌ JavaScript exception")
				errChan <- true
			}
		})

		if err := chromedp.Run(
			tabCtx,
			chrome_runtime.Enable(),
			chrome_log.Enable(),
			chromedp.Navigate(url),
			chromedp.WaitReady("body", chromedp.ByQuery),
		); err != nil {
			fmt.Printf("Failed to load url %s: %v", url, err)
			cancelBrowser()
			cancelAllocator()
			os.Exit(1)
		} else {
			fmt.Printf("Opened (%d/%d): %s\n", i+1, len(urls), url)
		}
	}

	fmt.Println("Chrome is running, waiting for error or interrupt...")

	// 4) Wait forever, or until an error or signal
	select {
	case <-sigChan:
		fmt.Println("\n⚠️  Plandex browser process interrupted")
		return nil
	case <-rootCtx.Done():
		fmt.Println("\n⚠️  Plandex browser process closed")
		return nil
	case <-errChan:
		fmt.Println("\n❌ Plandex browser process exited due to JavaScript error")
		cancelBrowser()
		cancelAllocator()
		os.Exit(1)
	}
	return nil
}

func openWithOSDefault(urls []string) error {
	var openCmd string
	switch runtime.GOOS {
	case "darwin":
		openCmd = "open"
	case "linux", "freebsd":
		openCmd = "xdg-open"
	default:
		return errors.New("unsupported OS for fallback")
	}

	for _, url := range urls {
		cmd := exec.Command(openCmd, url)
		if err := cmd.Start(); err != nil {
			log.Printf("Failed to open %s with %s: %v", url, openCmd, err)
		}
	}
	return nil
}


================================================
FILE: app/cli/cmd/build.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/term"
	"plandex-cli/types"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var buildCmd = &cobra.Command{
	Use:     "build",
	Aliases: []string{"b"},
	Short:   "Build pending changes",
	// Long:  ``,
	Args: cobra.NoArgs,
	Run:  build,
}

func init() {
	RootCmd.AddCommand(buildCmd)

	initExecFlags(buildCmd, initExecFlagsParams{
		omitFile:         true,
		omitNoBuild:      true,
		omitEditor:       true,
		omitStop:         true,
		omitAutoContext:  true,
		omitSmartContext: true,
	})
}

func build(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	mustSetPlanExecFlags(cmd, false)

	didBuild, err := plan_exec.Build(plan_exec.ExecParams{
		CurrentPlanId: lib.CurrentPlanId,
		CurrentBranch: lib.CurrentBranch,
		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
			auto := autoConfirm || tellAutoApply || tellAutoContext
			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
		},
	}, types.BuildFlags{
		BuildBg:   tellBg,
		AutoApply: tellAutoApply,
	})

	if err != nil {
		term.OutputErrorAndExit("Error building plan: %v", err)
	}

	if !didBuild {
		fmt.Println()
		term.PrintCmds("", "log", "tell", "continue")
		return
	}

	if tellBg {
		fmt.Println("🏗️ Building plan in the background")
		fmt.Println()
		term.PrintCmds("", "ps", "connect", "stop")
	} else if tellAutoApply {
		applyFlags := types.ApplyFlags{
			AutoConfirm: true,
			AutoCommit:  autoCommit,
			NoCommit:    !autoCommit,
			NoExec:      noExec,
			AutoExec:    autoExec,
			AutoDebug:   autoDebug,
		}

		tellFlags := types.TellFlags{
			AutoContext: tellAutoContext,
			ExecEnabled: !noExec,
			AutoApply:   tellAutoApply,
		}

		lib.MustApplyPlan(lib.ApplyPlanParams{
			PlanId:     lib.CurrentPlanId,
			Branch:     lib.CurrentBranch,
			ApplyFlags: applyFlags,
			TellFlags:  tellFlags,
			OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
		})
	} else {
		fmt.Println()
		term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
	}
}


================================================
FILE: app/cli/cmd/cd.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

func init() {
	RootCmd.AddCommand(cdCmd)
}

var cdCmd = &cobra.Command{
	Use:     "cd [name-or-index]",
	Aliases: []string{"set-plan"},
	Short:   "Set current plan by name or index",
	Args:    cobra.MaximumNArgs(1),
	Run:     cd,
}

func cd(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	var nameOrIdx string
	if len(args) > 0 {
		nameOrIdx = strings.TrimSpace(args[0])
	}

	var plan *shared.Plan

	term.StartSpinner("")
	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No plans")
		fmt.Println()
		term.PrintCmds("", "new")
		return
	}

	if nameOrIdx == "" {

		opts := make([]string, len(plans))
		for i, plan := range plans {
			opts[i] = plan.Name
		}

		selected, err := term.SelectFromList("Select a plan", opts)

		if err != nil {
			term.OutputErrorAndExit("Error selecting plan: %v", err)
		}

		for _, p := range plans {
			if p.Name == selected {
				plan = p
				break
			}
		}
	} else {
		// see if it's an index
		idx, err := strconv.Atoi(nameOrIdx)

		if err == nil {
			if idx > 0 && idx <= len(plans) {
				plan = plans[idx-1]
			} else {
				term.OutputErrorAndExit("Plan index out of range")
			}
		} else {
			for _, p := range plans {
				if p.Name == nameOrIdx {
					plan = p
					break
				}
			}
		}
	}

	if plan == nil {
		term.OutputErrorAndExit("Plan not found")
	}

	err := lib.WriteCurrentPlan(plan.Id)
	if err != nil {
		term.OutputErrorAndExit("Error setting current plan: %v", err)
	}

	// reload current plan, which will also handle setting the right branch
	lib.MustLoadCurrentPlan()

	// fire and forget SetProjectPlan request (we don't care about the response or errors)
	// this only matters for setting the current plan on a new device (i.e. when the current plan is not set)
	go api.Client.SetProjectPlan(lib.CurrentProjectId, shared.SetProjectPlanRequest{PlanId: plan.Id})

	// give the SetProjectPlan request some time to be sent before exiting
	time.Sleep(50 * time.Millisecond)

	fmt.Println("✅ Changed current plan to " + color.New(term.ColorHiGreen, color.Bold).Sprint(plan.Name))

	fmt.Println()
	term.PrintCmds("", "current")
}


================================================
FILE: app/cli/cmd/chat.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/types"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var chatCmd = &cobra.Command{
	Use:     "chat [prompt]",
	Aliases: []string{"c"},
	Short:   "Chat without making changes",
	// Long:  ``,
	Args: cobra.RangeArgs(0, 1),
	Run:  doChat,
}

func init() {
	RootCmd.AddCommand(chatCmd)

	initExecFlags(chatCmd, initExecFlagsParams{
		omitNoBuild:      true,
		omitStop:         true,
		omitBg:           true,
		omitApply:        true,
		omitExec:         true,
		omitSmartContext: true,
		omitSkipMenu:     true,
	})

}

func doChat(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()
	mustSetPlanExecFlags(cmd, false)

	prompt := getTellPrompt(args)

	if prompt == "" {
		fmt.Println("🤷‍♂️ No prompt to send")
		return
	}

	plan_exec.TellPlan(plan_exec.ExecParams{
		CurrentPlanId: lib.CurrentPlanId,
		CurrentBranch: lib.CurrentBranch,
		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
			auto := autoConfirm || tellAutoApply || tellAutoContext
			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
		},
	}, prompt, types.TellFlags{
		IsChatOnly:      true,
		AutoContext:     tellAutoContext,
		SkipChangesMenu: tellSkipMenu,
	})
}


================================================
FILE: app/cli/cmd/checkout.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

const (
	OptCreateNewBranch = "Create a new branch"
)

var confirmCreateBranch bool

var checkoutCmd = &cobra.Command{
	Use:     "checkout [name-or-index]",
	Aliases: []string{"co"},
	Short:   "Checkout an existing plan branch or create a new one",
	Run:     checkout,
	Args:    cobra.MaximumNArgs(1),
}

func init() {
	RootCmd.AddCommand(checkoutCmd)
	checkoutCmd.Flags().BoolVarP(&confirmCreateBranch, "yes", "y", false, "Confirm creating a new branch")
}

func checkout(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	branchName := ""
	willCreate := false

	var nameOrIdx string
	if len(args) > 0 {
		nameOrIdx = strings.TrimSpace(args[0])
	}

	term.StartSpinner("")
	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
		return
	}

	if nameOrIdx != "" {
		idx, err := strconv.Atoi(nameOrIdx)

		if err == nil {
			if idx > 0 && idx <= len(branches) {
				branchName = branches[idx-1].Name
			} else {
				term.OutputErrorAndExit("Branch %d not found", idx)
			}
		} else {
			for _, b := range branches {
				if b.Name == nameOrIdx {
					branchName = b.Name
					break
				}
			}
		}

		if branchName == "" {
			fmt.Printf("🌱 Branch %s not found\n", color.New(color.Bold, term.ColorHiCyan).Sprint(nameOrIdx))

			if confirmCreateBranch {
				fmt.Println("✅ --yes flag set, will create branch")
				branchName = nameOrIdx
				willCreate = true
			} else {
				res, err := term.ConfirmYesNo("Create it now?")

				if err != nil {
					term.OutputErrorAndExit("Error getting user input: %v", err)
				}

				if res {
					branchName = nameOrIdx
					willCreate = true
				} else {
					return
				}
			}
		}

	}

	if nameOrIdx == "" {
		opts := make([]string, len(branches))
		for i, branch := range branches {
			opts[i] = branch.Name
		}
		opts = append(opts, OptCreateNewBranch)

		selected, err := term.SelectFromList("Select a branch", opts)

		if err != nil {
			term.OutputErrorAndExit("Error selecting branch: %v", err)
			return
		}

		if selected == OptCreateNewBranch {
			branchName, err = term.GetRequiredUserStringInput("Branch name")
			if err != nil {
				term.OutputErrorAndExit("Error getting branch name: %v", err)
				return
			}
			willCreate = true
		} else {
			branchName = selected
		}
	}

	if branchName == "" {
		term.OutputErrorAndExit("Branch not found")
	}

	term.StartSpinner("")
	if willCreate {
		err := api.Client.CreateBranch(lib.CurrentPlanId, lib.CurrentBranch, shared.CreateBranchRequest{Name: branchName})

		if err != nil {
			term.OutputErrorAndExit("Error creating branch: %v", err)
			return
		}

		// fmt.Printf("✅ Created branch %s\n", color.New(color.Bold, term.ColorHiGreen).Sprint(branchName))
	}

	err := lib.WriteCurrentBranch(branchName)

	if err != nil {
		term.OutputErrorAndExit("Error setting current branch: %v", err)
		return
	}

	updatedModelSettings, err := lib.SaveLatestPlanModelSettingsIfNeeded()
	term.StopSpinner()
	if err != nil {
		term.OutputErrorAndExit("Error saving model settings: %v", err)
	}

	term.StopSpinner()

	fmt.Printf("✅ Checked out branch %s\n", color.New(color.Bold, term.ColorHiGreen).Sprint(branchName))

	if updatedModelSettings {
		fmt.Println()
		fmt.Println("🧠 Model settings file updated → ", lib.GetPlanModelSettingsPath(lib.CurrentPlanId))
	}

	fmt.Println()
	term.PrintCmds("", "load", "tell", "branches", "delete-branch")

}


================================================
FILE: app/cli/cmd/claude_max.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var connectClaudeCmd = &cobra.Command{
	Use:   "connect-claude",
	Short: "Connect your Claude Pro or Max subscription",
	Run:   connectClaude,
}

var disconnectClaudeCmd = &cobra.Command{
	Use:   "disconnect-claude",
	Short: "Disconnect your Claude Pro or Max subscription",
	Run:   disconnectClaude,
}

var claudeStatusCmd = &cobra.Command{
	Use:   "claude-status",
	Short: "Check the status of your Claude Pro or Max subscription",
	Run:   claudeStatus,
}

func connectClaude(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.ConnectClaudeMax()
}

func disconnectClaude(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.DisconnectClaudeMax()
}

func claudeStatus(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	creds, err := lib.GetAccountCredentials()
	if err != nil {
		term.OutputErrorAndExit("Error getting account credentials: %v", err)
	}

	orgUserConfig := lib.MustGetOrgUserConfig()

	connected := creds.ClaudeMax != nil && orgUserConfig.UseClaudeSubscription

	if connected {
		fmt.Println("✅ Claude Pro or Max subscription is connected")

		// if orgUserConfig.IsClaudeSubscriptionCooldownActive() {
		if true {
			fmt.Println()
			color.New(term.ColorHiYellow, color.Bold).Println("⏳ You've reached your Claude Pro or Max subscription quota")
			fmt.Println("The next provider with valid credentials will be used for Anthropic models until the quota resets")
			fmt.Println()
		}

		term.PrintCmds("", "disconnect-claude")
	} else {
		fmt.Println("❌ No Claude Pro or Max subscription is connected")
		term.PrintCmds("", "connect-claude")
	}
}

func init() {
	RootCmd.AddCommand(connectClaudeCmd)
	RootCmd.AddCommand(disconnectClaudeCmd)
	RootCmd.AddCommand(claudeStatusCmd)
}


================================================
FILE: app/cli/cmd/clear.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var clearCmd = &cobra.Command{
	Use:   "clear",
	Short: "Clear all context",
	Long:  `Clear all context.`,
	Run:   clearAllContext,
}

func clearAllContext(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for _, context := range contexts {
		deleteIds[context.Id] = true
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		fmt.Println("🤷‍♂️ No context removed")
	}

}

func init() {
	RootCmd.AddCommand(clearCmd)
}


================================================
FILE: app/cli/cmd/config.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

func init() {
	RootCmd.AddCommand(configCmd)
	configCmd.AddCommand(defaultConfigCmd)
}

var configCmd = &cobra.Command{
	Use:   "config",
	Short: "Show plan config",
	Run:   config,
}

var defaultConfigCmd = &cobra.Command{
	Use:   "default",
	Short: "Show default config for new plans",
	Run:   defaultConfig,
}

func config(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")

	config, apiErr := api.Client.GetPlanConfig(lib.CurrentPlanId)
	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting config: %v", apiErr.Msg)
		return
	}

	term.StopSpinner()

	color.New(color.Bold, term.ColorHiCyan).Println("⚙️  Plan Config")
	lib.ShowPlanConfig(config, "")
	fmt.Println()

	term.PrintCmds("", "set-config", "config default", "set-config default")
}

func defaultConfig(cmd *cobra.Command, args []string) {
	auth.MustResolveAuth(false)

	term.StartSpinner("")
	config, err := api.Client.GetDefaultPlanConfig()
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error getting default config: %v", err)
		return
	}

	color.New(color.Bold, term.ColorHiCyan).Println("⚙️  Default Config")
	lib.ShowPlanConfig(config, "")
	fmt.Println()

	term.PrintCmds("", "set-config default", "config", "set-config")
}


================================================
FILE: app/cli/cmd/connect.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/stream"
	streamtui "plandex-cli/stream_tui"
	"plandex-cli/term"

	"github.com/spf13/cobra"
)

var connectCmd = &cobra.Command{
	Use:     "connect [stream-id-or-plan] [branch]",
	Aliases: []string{"conn"},
	Short:   "Connect to an active stream",
	// Long:  ``,
	Args: cobra.MaximumNArgs(2),
	Run:  connect,
}

func init() {
	RootCmd.AddCommand(connectCmd)

}

func connect(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	planId, branch, shouldContinue := lib.SelectActiveStream(args)

	if !shouldContinue {
		return
	}

	term.StartSpinner("")
	apiErr := api.Client.ConnectPlan(planId, branch, stream.OnStreamPlan)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error connecting to stream: %v", apiErr)
	}

	go func() {
		err := streamtui.StartStreamUI("", false, true)

		if err != nil {
			term.OutputErrorAndExit("Error starting stream UI", err)
		}

		fmt.Println()
		term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")

		os.Exit(0)
	}()

	// Wait for the stream to finish
	select {}
}


================================================
FILE: app/cli/cmd/context_show.go
================================================
package cmd

import (
	"fmt"
	"log"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"strconv"

	"github.com/spf13/cobra"
)

func init() {
	RootCmd.AddCommand(contextShowCmd)
}

var contextShowCmd = &cobra.Command{
	Use:   "show [name-or-index]",
	Short: "Show the body of a context by name or list index",
	Args:  cobra.ExactArgs(1),
	RunE: func(cmd *cobra.Command, args []string) error {
		auth.MustResolveAuthWithOrg()
		lib.MustResolveProject()

		nameOrIndex := args[0]

		// Get list of contexts first
		contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
		if err != nil {
			log.Printf("Error listing contexts: %v\n", err)
			return fmt.Errorf("error listing contexts: %v", err)
		}

		var contextId string

		// Try parsing as index first
		if idx, err := strconv.Atoi(nameOrIndex); err == nil {
			// Convert to 0-based index
			idx--
			if idx < 0 || idx >= len(contexts) {
				return fmt.Errorf("invalid context index: %s", nameOrIndex)
			}
			contextId = contexts[idx].Id
		} else {
			// Try finding by name
			found := false
			for _, ctx := range contexts {
				if ctx.Name == nameOrIndex || ctx.FilePath == nameOrIndex {
					contextId = ctx.Id
					found = true
					break
				}
			}
			if !found {
				return fmt.Errorf("no context found with name: %s", nameOrIndex)
			}
		}

		res, apiErr := api.Client.GetContextBody(lib.CurrentPlanId, lib.CurrentBranch, contextId)
		if apiErr != nil {
			log.Printf("Error getting context body: %v\n", apiErr)
			return fmt.Errorf("error getting context body: %v", apiErr)
		}

		fmt.Println(res.Body)
		return nil
	},
}


================================================
FILE: app/cli/cmd/continue.go
================================================
package cmd

import (
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/types"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var (
	chatOnly bool
)

var continueCmd = &cobra.Command{
	Use:     "continue",
	Aliases: []string{"c"},
	Short:   "Continue the plan",
	Run:     doContinue,
}

func init() {
	RootCmd.AddCommand(continueCmd)

	continueCmd.Flags().BoolVar(&chatOnly, "chat", false, "Continue in chat mode (no file changes)")

	initExecFlags(continueCmd, initExecFlagsParams{
		omitFile:   true,
		omitEditor: true,
	})
}

func doContinue(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()
	mustSetPlanExecFlags(cmd, false)

	tellFlags := types.TellFlags{
		TellBg:          tellBg,
		TellStop:        tellStop,
		TellNoBuild:     tellNoBuild,
		IsUserContinue:  true,
		ExecEnabled:     !noExec,
		AutoContext:     tellAutoContext,
		SmartContext:    tellSmartContext,
		AutoApply:       tellAutoApply,
		IsChatOnly:      chatOnly,
		SkipChangesMenu: tellSkipMenu,
	}

	plan_exec.TellPlan(plan_exec.ExecParams{
		CurrentPlanId: lib.CurrentPlanId,
		CurrentBranch: lib.CurrentBranch,
		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
			auto := autoConfirm || tellAutoApply || tellAutoContext

			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
		},
	}, "", tellFlags)

	if tellAutoApply {
		applyFlags := types.ApplyFlags{
			AutoConfirm: true,
			AutoCommit:  autoCommit,
			NoCommit:    !autoCommit,
			AutoExec:    autoExec,
			NoExec:      noExec,
			AutoDebug:   autoDebug,
		}

		lib.MustApplyPlan(lib.ApplyPlanParams{
			PlanId:     lib.CurrentPlanId,
			Branch:     lib.CurrentBranch,
			ApplyFlags: applyFlags,
			TellFlags:  tellFlags,
			OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
		})
	}
}


================================================
FILE: app/cli/cmd/convo.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"regexp"
	"strings"
	"time"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var plainTextOutput bool
var convoRaw bool

// convoCmd represents the convo command
var convoCmd = &cobra.Command{
	Use:   "convo [msg-range]",
	Short: "Display complete conversation history",
	Long:  `Display complete conversation history. Optionally specify a message number or range of messages (e.g. '1' or '5' or '1-5' or '5-')`,
	Run:   convo,
}

func init() {
	RootCmd.AddCommand(convoCmd)

	convoCmd.Flags().BoolVarP(&plainTextOutput, "plain", "p", false, "Output conversation in plain text with no ANSI codes")

	// for debugging output
	convoCmd.Flags().BoolVar(&convoRaw, "raw", false, "Output conversation in raw format")
	convoCmd.Flags().MarkHidden("raw")
}

const stoppedEarlyMsg = "You stopped the reply early"

func convo(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	term.StartSpinner("")
	conversation, apiErr := api.Client.ListConvo(lib.CurrentPlanId, lib.CurrentBranch)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error loading conversation: %v", apiErr.Msg)
	}

	if len(conversation) == 0 {
		fmt.Println("🤷‍♂️ No conversation history")
		return
	}

	var msgRange string
	var msgRangeStart, msgRangeEnd int
	if len(args) > 0 {
		msgRange = args[0]
	}
	if msgRange != "" {
		// validate either a number or a range of numbers
		if strings.Contains(msgRange, "-") {
			_, err := fmt.Sscanf(msgRange, "%d-%d", &msgRangeStart, &msgRangeEnd)
			if err != nil {
				_, err := fmt.Sscanf(msgRange, "%d-", &msgRangeStart)

				if err != nil {
					term.OutputErrorAndExit("Invalid message range: %s", msgRange)
				}

				msgRangeEnd = len(conversation)
			}
		} else {
			_, err := fmt.Sscanf(msgRange, "%d", &msgRangeStart)
			if err != nil {
				term.OutputErrorAndExit("Invalid message number: %s", msgRange)
			}
			msgRangeEnd = msgRangeStart
		}
	}

	var convo string
	var totalTokens int
	var didCut bool
	for i, msg := range conversation {
		if msgRangeStart > 0 && msg.Num < msgRangeStart {
			didCut = true
			continue
		}
		if msgRangeEnd > 0 && msg.Num > msgRangeEnd {
			didCut = true
			break
		}

		var author string
		if msg.Role == "assistant" {
			author = "🤖 Plandex"
		} else if msg.Role == "user" {
			author = "💬 You"
		} else {
			author = msg.Role
		}

		replyTags := msg.Flags.GetReplyTags()

		// format as above but start with day of week
		formattedTs := msg.CreatedAt.Local().Format("Mon Jan 2, 2006 | 3:04pm MST")

		// if it's today then use 'Today' instead of the date
		if msg.CreatedAt.Day() == time.Now().Day() {
			formattedTs = msg.CreatedAt.Local().Format("Today | 3:04pm MST")
		}

		// if it's yesterday then use 'Yesterday' instead of the date
		if msg.CreatedAt.Day() == time.Now().AddDate(0, 0, -1).Day() {
			formattedTs = msg.CreatedAt.Local().Format("Yesterday | 3:04pm MST")
		}

		var header string
		if len(replyTags) > 0 {
			header = fmt.Sprintf("#### %d | %s | %s | %s | %d 🪙 ", i+1,
				author, strings.Join(replyTags, " | "), formattedTs, msg.Tokens)
		} else {
			header = fmt.Sprintf("#### %d | %s | %s | %d 🪙 ", i+1,
				author, formattedTs, msg.Tokens)
		}

		txt := msg.Message
		if !convoRaw {
			txt = convertCodeBlocks(msg.Message)
		}

		if plainTextOutput {
			convo += header + "\n" + txt + "\n\n"
		} else {
			md, err := term.GetMarkdown(header + "\n" + txt + "\n\n")
			if err != nil {
				term.OutputErrorAndExit("Error creating markdown representation: %v", err)
			}
			convo += md
		}

		if !didCut && msg.Stopped {
			if plainTextOutput {
				convo += fmt.Sprintf(" 🛑 %s\n\n", stoppedEarlyMsg)
			} else {
				convo += fmt.Sprintf(" 🛑 %s\n\n", color.New(color.Bold).Sprint(stoppedEarlyMsg))
			}
		}

		totalTokens += msg.Tokens
	}

	if !plainTextOutput {
		convo = strings.ReplaceAll(convo, stoppedEarlyMsg, color.New(term.ColorHiRed).Sprint(stoppedEarlyMsg))
	}

	output :=
		fmt.Sprintf("\n%s", convo)

	if !plainTextOutput && !didCut {
		output += term.GetDivisionLine() +
			color.New(color.Bold, term.ColorHiCyan).Sprint("  Conversation size →") + fmt.Sprintf(" %d 🪙", totalTokens) + "\n\n"
	}

	if plainTextOutput {
		fmt.Println(output)
	} else {
		term.PageOutput(output)

		fmt.Println()
		term.PrintCmds("", "convo 1", "convo 2-5", "convo --plain", "log")
	}
}

var codeBlockPattern = regexp.MustCompile(`<PlandexBlock\s+lang="(.+?)".*?>([\s\S]+?)</PlandexBlock>`)

func convertCodeBlocks(msg string) string {
	return codeBlockPattern.ReplaceAllStringFunc(msg, func(match string) string {
		// Extract language and content from the match
		submatches := codeBlockPattern.FindStringSubmatch(match)
		lang := submatches[1]
		content := submatches[2]

		// Escape any backticks in the content
		content = strings.ReplaceAll(content, "```", "\\`\\`\\`")

		// Return markdown code block format
		return fmt.Sprintf("```%s%s```", lang, content)
	})
}


================================================
FILE: app/cli/cmd/current.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var currentCmd = &cobra.Command{
	Use:     "current",
	Aliases: []string{"cu"},
	Short:   "Get the current plan",
	Run:     current,
}

func init() {
	RootCmd.AddCommand(currentCmd)
}

func current(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MaybeResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	plan, err := api.Client.GetPlan(lib.CurrentPlanId)
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error getting plan: %v", err)
		return
	}

	currentBranchesByPlanId, err := api.Client.GetCurrentBranchByPlanId(lib.CurrentProjectId, shared.GetCurrentBranchByPlanIdRequest{
		CurrentBranchByPlanId: map[string]string{
			lib.CurrentPlanId: lib.CurrentBranch,
		},
	})

	if err != nil {
		term.OutputErrorAndExit("Error getting current branches: %v", err)
	}

	table := lib.GetCurrentPlanTable(plan, currentBranchesByPlanId, nil)
	fmt.Println(table)

	term.PrintCmds("", "tell", "ls", "plans")

}


================================================
FILE: app/cli/cmd/debug.go
================================================
package cmd

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"os"
	"os/exec"
	"os/signal"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/term"
	"plandex-cli/types"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"time"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

const DebugDefaultTries = 5

var debugCmd = &cobra.Command{
	Use:     "debug [tries] <cmd>",
	Aliases: []string{"db"},
	Short:   "Debug a failing command with Plandex",
	Args:    cobra.MinimumNArgs(1),
	Run:     doDebug,
}

func init() {
	RootCmd.AddCommand(debugCmd)
	debugCmd.Flags().BoolVarP(&autoCommit, "commit", "c", false, "Commit changes after successful execution")
}

func doDebug(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()
	mustSetPlanExecFlags(cmd, false)

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	// Parse tries and command
	tries := DebugDefaultTries
	cmdArgs := args

	// Check if first arg is tries count
	if val, err := strconv.Atoi(args[0]); err == nil {
		if val <= 0 {
			term.OutputErrorAndExit("Tries must be greater than 0")
		}
		tries = val
		cmdArgs = args[1:]
		if len(cmdArgs) == 0 {
			term.OutputErrorAndExit("No command specified")
		}
	}

	// Get current working directory
	cwd, err := os.Getwd()
	if err != nil {
		term.OutputErrorAndExit("Failed to get working directory: %v", err)
	}

	cmdStr := strings.Join(cmdArgs, " ")

	// Execute command and handle retries
	for attempt := 0; attempt < tries; attempt++ {
		// Use shell to handle operators like && and |
		shellCmdStr := "set -euo pipefail; " + cmdStr
		execCmd := exec.Command("sh", "-c", shellCmdStr)
		execCmd.Dir = cwd
		execCmd.Env = os.Environ()
		lib.SetPlatformSpecificAttrs(execCmd)

		pipe, err := execCmd.StdoutPipe()
		if err != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Failed to create pipe: %v", err)
		}
		execCmd.Stderr = execCmd.Stdout

		if err := execCmd.Start(); err != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Failed to start command: %v", err)
		}

		maybeDeleteCgroup := lib.MaybeIsolateCgroup(execCmd)

		ctx, cancel := context.WithCancel(context.Background())
		var interrupted atomic.Bool
		var interruptHandled atomic.Bool
		var interruptWG sync.WaitGroup

		sigChan := make(chan os.Signal, 1)
		signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT)

		interruptWG.Add(1)
		go func() {
			defer interruptWG.Done()
			for {
				select {
				case sig := <-sigChan:
					if interruptHandled.CompareAndSwap(false, true) {
						fmt.Println()
						color.New(term.ColorHiYellow, color.Bold).Println("\n👉 Caught interrupt. Exiting gracefully...")
						interrupted.Store(true)

						var sysSig syscall.Signal

						switch sig {
						case os.Interrupt:
							// user pressed Ctrl+C
							sysSig = syscall.SIGINT
						case syscall.SIGTERM:
							// a polite "kill" request
							sysSig = syscall.SIGTERM
						case syscall.SIGHUP:
							sysSig = syscall.SIGHUP
						case syscall.SIGQUIT:
							sysSig = syscall.SIGQUIT
						default:
							sysSig = syscall.SIGINT
						}

						if err := lib.KillProcessGroup(execCmd, sysSig); err != nil {
							log.Printf("Failed to send signal %s to process group: %v", sysSig, err)
						}

						select {
						case <-time.After(2 * time.Second):
							color.New(term.ColorHiYellow, color.Bold).Println("👉 Commands didn't exit after 2 seconds. Sending SIGKILL.")
							if err := lib.KillProcessGroup(execCmd, syscall.SIGKILL); err != nil {
								log.Printf("Failed to send SIGKILL to process group: %v", err)
							}
							maybeDeleteCgroup()
						case <-ctx.Done():
							maybeDeleteCgroup()
							return
						}
					}
				case <-ctx.Done():
					maybeDeleteCgroup()
					return
				}
			}
		}()

		var outputBuilder strings.Builder
		scanner := bufio.NewScanner(pipe)
		go func() {
			for scanner.Scan() {
				line := scanner.Text()
				fmt.Println(line)
				outputBuilder.WriteString(line + "\n")
			}
		}()

		waitErr := execCmd.Wait()

		cancel()
		interruptWG.Wait()
		signal.Stop(sigChan)
		close(sigChan)

		if scanErr := scanner.Err(); scanErr != nil {
			log.Printf("⚠️ Scanner error reading subprocess output: %v", scanErr)
		}

		term.StopSpinner()

		outputStr := outputBuilder.String()
		if outputStr == "" && waitErr != nil {
			outputStr = waitErr.Error()
		}

		if outputStr != "" {
			fmt.Println(outputStr)
		}

		didSucceed := waitErr == nil

		if interrupted.Load() {
			color.New(term.ColorHiYellow, color.Bold).Println("👉  Execution interrupted")

			res, canceled, err := term.ConfirmYesNoCancel("Did the command succeed?")

			if err != nil {
				term.OutputErrorAndExit("Failed to get confirmation user input: %s", err)
			}

			didSucceed = res

			if canceled {
				os.Exit(0)
			}
		}

		if didSucceed {
			if attempt == 0 {
				fmt.Printf("✅ Command %s succeeded on first try\n", color.New(color.Bold, term.ColorHiCyan).Sprintf(cmdStr))
			} else {
				lbl := "attempts"
				if attempt == 1 {
					lbl = "attempt"
				}
				fmt.Printf("✅ Command %s succeeded after %d fix %s\n", color.New(color.Bold, term.ColorHiCyan).Sprintf(cmdStr), attempt, lbl)
			}
			return
		}

		if attempt == tries-1 {
			fmt.Printf("Command failed after %d tries\n", tries)
			os.Exit(1)
		}

		// Prepare prompt for TellPlan
		exitErr, ok := waitErr.(*exec.ExitError)
		status := -1
		if ok {
			status = exitErr.ExitCode()
		}

		prompt := fmt.Sprintf("'%s' failed with exit status %d. Output:\n\n%s\n\n--\n\n",
			strings.Join(cmdArgs, " "), status, outputStr)

		tellFlags := types.TellFlags{
			AutoContext: tellAutoContext,
			ExecEnabled: false,
			IsUserDebug: true,
		}

		plan_exec.TellPlan(plan_exec.ExecParams{
			CurrentPlanId: lib.CurrentPlanId,
			CurrentBranch: lib.CurrentBranch,
			AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
			CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
				return lib.CheckOutdatedContextWithOutput(true, true, maybeContexts, projectPaths)
			},
		}, prompt, tellFlags)

		applyFlags := types.ApplyFlags{
			AutoConfirm: true,
			AutoCommit:  autoCommit,
			NoCommit:    !autoCommit,
			NoExec:      false,
			AutoExec:    true,
		}

		lib.MustApplyPlan(lib.ApplyPlanParams{
			PlanId:      lib.CurrentPlanId,
			Branch:      lib.CurrentBranch,
			ApplyFlags:  applyFlags,
			TellFlags:   tellFlags,
			OnExecFail:  plan_exec.GetOnApplyExecFailWithCommand(applyFlags, tellFlags, cmdStr),
			ExecCommand: cmdStr,
		})
	}
}


================================================
FILE: app/cli/cmd/delete_branch.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var deleteBranchCmd = &cobra.Command{
	Use:     "delete-branch",
	Aliases: []string{"dlb"},
	Short:   "Delete a plan branch by name or index",
	Run:     deleteBranch,
	Args:    cobra.MaximumNArgs(1),
}

func init() {
	RootCmd.AddCommand(deleteBranchCmd)
}

func deleteBranch(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	var branch string
	var nameOrIdx string

	if len(args) > 0 {
		nameOrIdx = strings.TrimSpace(args[0])
	}

	if nameOrIdx == "main" {
		fmt.Println("🚨 Cannot delete main branch")
		return
	}

	term.StartSpinner("")
	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
		return
	}

	if nameOrIdx == "" {
		opts := make([]string, len(branches))
		for i, branch := range branches {
			if branch.Name == "main" {
				continue
			}
			opts[i] = branch.Name
		}

		if len(opts) == 0 {
			fmt.Println("🤷‍♂️ No branches to delete")
			return
		}

		sel, err := term.SelectFromList("Select a branch to delete", opts)

		if err != nil {
			term.OutputErrorAndExit("Error selecting branch: %v", err)
			return
		}

		branch = sel
	}

	// see if it's an index
	idx, err := strconv.Atoi(nameOrIdx)

	if err == nil {
		if idx > 0 && idx <= len(branches) {
			branch = branches[idx-1].Name
		} else {
			term.OutputErrorAndExit("Branch index out of range")
		}
	} else {
		for _, b := range branches {
			if b.Name == nameOrIdx {
				branch = b.Name
				break
			}
		}

		if branch == "" {
			term.OutputErrorAndExit("Branch not found")
		}
	}

	found := false
	for _, b := range branches {
		if b.Name == branch {
			found = true
			break
		}
	}

	if !found {
		fmt.Printf("🤷‍♂️ Branch %s does not exist\n", color.New(color.Bold, term.ColorHiCyan).Sprint(branch))
		return
	}

	term.StartSpinner("")
	apiErr = api.Client.DeleteBranch(lib.CurrentPlanId, branch)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error deleting branch: %v", apiErr)
		return
	}

	fmt.Printf("✅ Deleted branch %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint(branch))

	fmt.Println()
	term.PrintCmds("", "branches")
}


================================================
FILE: app/cli/cmd/delete_plan.go
================================================
package cmd

import (
	"fmt"
	"path"
	"strconv"
	"strings"

	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var all bool

func init() {
	rmCmd.Flags().BoolVar(&all, "all", false, "Delete all plans")
	RootCmd.AddCommand(rmCmd)
}

// rmCmd represents the rm command
var rmCmd = &cobra.Command{
	Use:     "delete-plan [name-or-index]",
	Aliases: []string{"dp"},
	Short:   "Delete a plan by name, index, range, or pattern, or select from a list. Delete all plans with --all flag.",
	Args:    cobra.RangeArgs(0, 1),
	Run:     del,
}

func matchPlansByPattern(pattern string, plans []*shared.Plan) []*shared.Plan {
	var matched []*shared.Plan
	for _, plan := range plans {
		if isMatched, err := path.Match(pattern, plan.Name); err == nil && isMatched {
			matched = append(matched, plan)
		}
	}
	return matched
}

func del(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if all {
		delAll()
		return
	}

	term.StartSpinner("")
	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No plans")
		fmt.Println()
		term.PrintCmds("", "new")
		return
	}

	var plansToDelete []*shared.Plan

	if len(args) == 0 {
		// Interactive selection
		opts := make([]string, len(plans))
		for i, plan := range plans {
			opts[i] = plan.Name
		}

		selected, err := term.SelectFromList("Select a plan:", opts)
		if err != nil {
			term.OutputErrorAndExit("Error selecting plan: %v", err)
		}

		for _, p := range plans {
			if p.Name == selected {
				plansToDelete = append(plansToDelete, p)
				break
			}
		}
	} else {
		nameOrPattern := strings.TrimSpace(args[0])

		// Check if it's a range of indices
		if strings.Contains(nameOrPattern, "-") {
			// Create single-element slice with the range pattern
			rangeArgs := []string{nameOrPattern}
			indices := parseIndices(rangeArgs)
			for idx := range indices {
				if idx >= 0 && idx < len(plans) {
					plansToDelete = append(plansToDelete, plans[idx])
				}
			}
		} else if strings.Contains(nameOrPattern, "*") {
			// Wildcard pattern matching
			plansToDelete = matchPlansByPattern(nameOrPattern, plans)
		} else {
			// Try as index first
			idx, err := strconv.Atoi(nameOrPattern)
			if err == nil {
				if idx > 0 && idx <= len(plans) {
					plansToDelete = append(plansToDelete, plans[idx-1])
				} else {
					term.OutputErrorAndExit("Plan index out of range")
				}
			} else {
				// Try exact name match
				for _, p := range plans {
					if p.Name == nameOrPattern {
						plansToDelete = append(plansToDelete, p)
						break
					}
				}
			}
		}
	}

	if len(plansToDelete) == 0 {
		term.OutputErrorAndExit("No matching plans found")
	}

	// Show confirmation with list of plans to be deleted
	fmt.Printf("\nThe following %d plan(s) will be deleted:\n", len(plansToDelete))
	for _, p := range plansToDelete {
		fmt.Printf("  - %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint(p.Name))
	}
	fmt.Println()

	confirmed, err := term.ConfirmYesNo("Are you sure you want to delete these plans?")
	if err != nil {
		term.OutputErrorAndExit("Error getting confirmation: %v", err)
	}
	if !confirmed {
		fmt.Println("Operation cancelled")
		return
	}

	// Delete the plans
	term.StartSpinner("")
	for _, p := range plansToDelete {
		apiErr = api.Client.DeletePlan(p.Id)
		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Error deleting plan %s: %s", p.Name, apiErr.Msg)
		}

		if lib.CurrentPlanId == p.Id {
			err := lib.ClearCurrentPlan()
			if err != nil {
				term.OutputErrorAndExit("Error clearing current plan: %v", err)
			}
		}
	}
	term.StopSpinner()

	if len(plansToDelete) == 1 {
		fmt.Printf("✅ Deleted plan '%s'\n", plansToDelete[0].Name)
	} else {
		fmt.Printf("✅ Deleted %d plans\n", len(plansToDelete))
	}
}

func delAll() {
	term.StartSpinner("")
	err := api.Client.DeleteAllPlans(lib.CurrentProjectId)
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error deleting all  plans: %v", err)
	}

	fmt.Println("✅ Deleted all plans")
}


================================================
FILE: app/cli/cmd/diffs.go
================================================
package cmd

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net"
	"net/http"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"plandex-cli/ui"

	"github.com/eiannone/keyboard"
	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var showDiffUi bool = true
var diffUiSideBySide = true
var diffUiLineByLine bool
var diffGit bool

var fromTellMenu bool

var diffsCmd = &cobra.Command{
	Use:     "diff",
	Aliases: []string{"diffs"},
	Short:   "Review pending changes",
	Run:     diffs,
}

func init() {
	RootCmd.AddCommand(diffsCmd)

	diffsCmd.Flags().BoolVarP(&plainTextOutput, "plain", "p", false, "Output diffs in plain text with no ANSI codes")
	diffsCmd.Flags().BoolVar(&showDiffUi, "ui", false, "Show diffs in a browser UI")
	diffsCmd.Flags().BoolVar(&diffGit, "git", true, "Show diffs in git diff format")
	diffsCmd.Flags().BoolVarP(&diffUiSideBySide, "side", "s", true, "Show diffs UI in side-by-side view")
	diffsCmd.Flags().BoolVarP(&diffUiLineByLine, "line", "l", false, "Show diffs UI in line-by-line view")

	diffsCmd.Flags().BoolVar(&fromTellMenu, "from-tell-menu", false, "Show diffs from the tell menu")
	diffsCmd.Flags().MarkHidden("from-tell-menu")

}

func diffs(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MaybeResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")

	if showDiffUi {
		diffGit = false
	} else if diffGit || plainTextOutput {
		showDiffUi = false
	} else {
		diffGit = true
	}

	diffs, err := api.Client.GetPlanDiffs(lib.CurrentPlanId, lib.CurrentBranch, plainTextOutput || showDiffUi)
	term.StopSpinner()
	if err != nil {
		term.OutputErrorAndExit("Error getting plan diffs: %v", err)
		return
	}

	if len(diffs) == 0 {
		fmt.Println("🤷‍♂️ No pending changes")
		return
	}

	if showDiffUi {
		getNewListener := func() net.Listener {
			outputFormat := "line-by-line"
			if diffUiSideBySide {
				outputFormat = "side-by-side"
			} else if diffUiLineByLine {
				outputFormat = "line-by-line"
			}

			// Properly escape the diff content for JavaScript
			diffJSON, err := json.Marshal(diffs)
			if err != nil {
				term.OutputErrorAndExit("Error encoding diff content: %v", err)
			}

			// Create template data
			data := struct {
				DiffContent  template.JS
				OutputFormat string
			}{
				DiffContent:  template.JS(diffJSON),
				OutputFormat: outputFormat,
			}

			// Parse and execute the template
			tmpl, err := template.New("diff").Parse(htmlTemplate)
			if err != nil {
				term.OutputErrorAndExit("Error parsing template: %v", err)
			}

			// Use :0 to let the OS pick an available port
			listener, err := net.Listen("tcp", ":0")
			if err != nil {
				term.OutputErrorAndExit("Error starting server: %v", err)
			}

			// Get the actual port chosen
			port := listener.Addr().(*net.TCPAddr).Port

			// Start web server
			go func() {
				http.HandleFunc("/"+outputFormat, func(w http.ResponseWriter, r *http.Request) {
					w.Header().Set("Content-Type", "text/html; charset=utf-8")
					err := tmpl.Execute(w, data)
					if err != nil {
						http.Error(w, err.Error(), http.StatusInternalServerError)
					}
				})
				http.Serve(listener, nil)
			}()

			ui.OpenURL("Showing "+outputFormat+" diffs in your default browser...", fmt.Sprintf("http://localhost:%d/%s", port, outputFormat))

			fmt.Println()

			return listener
		}

		listener := getNewListener()
		defer listener.Close()

		var relaunch bool

		for {
			if relaunch {
				listener.Close()
				listener = getNewListener()
				defer listener.Close()
				relaunch = false
			}

			if diffUiLineByLine {
				fmt.Printf("%s for side-by-side view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(s)"))
			} else {
				fmt.Printf("%s for line-by-line view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(l)"))
			}

			fmt.Printf("%s for git diff format\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(g)"))
			// fmt.Printf("%s to quit\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(q)"))

			s := "to exit menu/continue"
			if fromTellMenu {
				s = "to go back"
			}

			fmt.Printf("%s %s %s %s %s",
				color.New(term.ColorHiMagenta, color.Bold).Sprint("Press a hotkey,"),
				color.New(color.FgHiWhite, color.Bold).Sprintf("↓"),
				color.New(term.ColorHiMagenta, color.Bold).Sprintf("to select, or"),
				color.New(color.FgHiWhite, color.Bold).Sprintf("enter"),
				color.New(term.ColorHiMagenta, color.Bold).Sprintf("%s>", s),
			)

			char, key, err := term.GetUserKeyInput()
			if err != nil {
				term.OutputErrorAndExit("Error getting key: %v", err)
				return
			}
			fmt.Println()

			if key == keyboard.KeyArrowDown {
				options := []string{}
				if diffUiLineByLine {
					options = append(options, "side-by-side")
				} else {
					options = append(options, "line-by-line")
				}

				options = append(options, "git diff")
				options = append(options, "exit menu")

				selected, err := term.SelectFromList(
					"Select an action",
					options,
				)
				if err != nil {
					term.OutputErrorAndExit("Error selecting action: %v", err)
					return
				}

				if selected == "side-by-side" {
					diffUiSideBySide = true
					diffUiLineByLine = false
					relaunch = true
				} else if selected == "line-by-line" {
					diffUiSideBySide = false
					diffUiLineByLine = true
					relaunch = true
				} else if selected == "git diff" {
					showGitDiff()
				} else if selected == "exit menu" {
					fmt.Println()
					break
				}
			} else if string(char) == "g" {
				showGitDiff()
			} else if string(char) == "s" {
				diffUiSideBySide = true
				diffUiLineByLine = false
				relaunch = true
			} else if string(char) == "l" {
				diffUiSideBySide = false
				diffUiLineByLine = true
				relaunch = true
			} else if key == 13 || key == 10 || string(char) == "q" { // Check raw key codes for Enter/Return
				if term.IsRepl {
					fmt.Println()
					break
				} else {
					fmt.Println()
					break
				}
			} else if string(char) == "\x03" { // Ctrl+C
				os.Exit(0)
			} else {
				fmt.Println()
				term.OutputSimpleError("Invalid hotkey")
				fmt.Println()
			}
		}
	} else {
		if plainTextOutput {
			fmt.Println(diffs)
		} else {
			term.PageOutput(diffs)
		}
		fmt.Println()
	}
}

func showGitDiff() {
	_, err := lib.ExecPlandexCommandWithParams([]string{"diff", "--git"}, lib.ExecPlandexCommandParams{
		DisableSuggestions: true,
	})
	if err != nil {
		term.OutputErrorAndExit("Error showing git diff: %v", err)
	}
}

var htmlTemplate = `<!doctype html>
<html lang="en-us">
  <head>
    <meta charset="utf-8" />
    <!-- Make sure to load the highlight.js CSS file before the Diff2Html CSS file -->
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/vs.min.css" />
    <link
      rel="stylesheet"
      type="text/css"
      href="https://cdn.jsdelivr.net/npm/diff2html/bundles/css/diff2html.min.css"
    />
    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/diff2html/bundles/js/diff2html-ui.min.js"></script>
  </head>
  <script>
    // Parse the JSON-encoded diff content
    const diffString = {{.DiffContent}};

    document.addEventListener('DOMContentLoaded', function () {
      var targetElement = document.getElementById('myDiffElement');
      var configuration = {
        outputFormat: '{{.OutputFormat}}'
      };
      var diff2htmlUi = new Diff2HtmlUI(targetElement, diffString, configuration);
      diff2htmlUi.draw();
      diff2htmlUi.highlightCode();
    });
  </script>
  <body>
    <div id="myDiffElement"></div>
  </body>
</html>`


================================================
FILE: app/cli/cmd/invite.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var inviteCmd = &cobra.Command{
	Use:   "invite [email] [name] [org-role]",
	Short: "Invite a new user to the org",
	Run:   invite,
	Args:  cobra.MaximumNArgs(3),
}

func init() {
	RootCmd.AddCommand(inviteCmd)
}

func invite(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	email, name, orgRoleName := "", "", ""
	if len(args) >= 1 {
		email = args[0]
	}
	if len(args) >= 2 {
		name = args[1]
	}
	if len(args) == 3 {
		orgRoleName = args[2]
	}

	term.StartSpinner("")
	orgRoles, err := api.Client.ListOrgRoles()
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Failed to list org roles: %v", err)
	}

	if email == "" {
		var err error
		email, err = term.GetRequiredUserStringInput("Email:")
		if err != nil {
			term.OutputErrorAndExit("Failed to get email: %v", err)
		}
	}
	if name == "" {
		var err error
		name, err = term.GetRequiredUserStringInput("Name:")
		if err != nil {
			term.OutputErrorAndExit("Failed to get name: %v", err)
		}
	}

	if orgRoleName == "" {
		var orgRoleNames []string
		for _, orgRole := range orgRoles {
			orgRoleNames = append(orgRoleNames, orgRole.Label)
		}

		var err error
		orgRoleName, err = term.SelectFromList("Org role:", orgRoleNames)

		if err != nil {
			term.OutputErrorAndExit("Failed to select org role: %v", err)
		}
	}

	var orgRoleId string
	for _, orgRole := range orgRoles {
		if orgRole.Label == orgRoleName {
			orgRoleId = orgRole.Id
			break
		}
	}

	if orgRoleId == "" {
		term.OutputErrorAndExit("Org role '%s' not found", orgRoleName)
	}

	inviteRequest := shared.InviteRequest{
		Email:     email,
		Name:      name,
		OrgRoleId: orgRoleId,
	}

	term.StartSpinner("")
	apiErr := api.Client.InviteUser(inviteRequest)
	term.StopSpinner()
	if apiErr != nil {
		term.OutputErrorAndExit("Failed to invite user: %s", apiErr.Msg)
	}

	fmt.Println("✅ Invite sent")
}


================================================
FILE: app/cli/cmd/load.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"plandex-cli/types"

	"github.com/sashabaranov/go-openai"
	"github.com/spf13/cobra"
)

var (
	recursive       bool
	namesOnly       bool
	note            string
	forceSkipIgnore bool
	imageDetail     string
	defsOnly        bool
)

var contextLoadCmd = &cobra.Command{
	Use:     "load [files-or-urls...]",
	Aliases: []string{"l", "add"},
	Short:   "Load context from various inputs",
	Long:    `Load context from a file path, a directory, a URL, an image, a note, or piped data.`,
	Run:     contextLoad,
}

func init() {
	contextLoadCmd.Flags().StringVarP(&note, "note", "n", "", "Add a note to the context")
	contextLoadCmd.Flags().BoolVarP(&recursive, "recursive", "r", false, "Search directories recursively")
	contextLoadCmd.Flags().BoolVar(&namesOnly, "tree", false, "Load directory tree with file names only")
	contextLoadCmd.Flags().BoolVarP(&forceSkipIgnore, "force", "f", false, "Load files even when ignored by .gitignore or .plandexignore")
	contextLoadCmd.Flags().StringVarP(&imageDetail, "detail", "d", "high", "Image detail level (high or low)")
	contextLoadCmd.Flags().BoolVar(&defsOnly, "map", false, "Load file maps (function/method/class signatures, variable names, types, etc.)")
	RootCmd.AddCommand(contextLoadCmd)
}

func contextLoad(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
		return
	}

	lib.MustLoadContext(args, &types.LoadContextParams{
		Note:            note,
		Recursive:       recursive,
		NamesOnly:       namesOnly,
		ForceSkipIgnore: forceSkipIgnore,
		ImageDetail:     openai.ImageURLDetail(imageDetail),
		DefsOnly:        defsOnly,
		SessionId:       os.Getenv("PLANDEX_REPL_SESSION_ID"),
	})

	fmt.Println()
	term.PrintCmds("", "ls", "tell", "debug")
}


================================================
FILE: app/cli/cmd/log.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"time"

	"github.com/spf13/cobra"
)

// logCmd represents the log command
var logCmd = &cobra.Command{
	Use:     "log",
	Aliases: []string{"history", "logs"},
	Short:   "Show plan history",
	Long:    `Show plan history`,
	Args:    cobra.NoArgs,
	Run:     runLog,
}

func init() {
	// Add log command
	RootCmd.AddCommand(logCmd)
}

func runLog(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	res, apiErr := api.Client.ListLogs(lib.CurrentPlanId, lib.CurrentBranch)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting logs: %v", apiErr)
	}

	withLocalTimestamps, err := convertTimestampsToLocal(res.Body)

	if err != nil {
		term.OutputErrorAndExit("Error converting timestamps: %v", err)
	}

	term.PageOutput(withLocalTimestamps)

	fmt.Println()
	term.PrintCmds("", "rewind", "continue", "convo", "convo 1", "convo 2-5")

}

func convertTimestampsToLocal(input string) (string, error) {
	t := time.Now()
	zone, _ := t.Zone()
	re := lib.GitLogTimestampRegex

	// Function to convert matched timestamps assuming they are in UTC to local time.
	replaceFunc := func(match string) string {
		t, err := time.Parse(lib.GitLogTimestampFormat, match)
		if err != nil {
			// In case of an error, return the original match.
			return match
		}

		localDt := t.Local()
		formattedTs := localDt.Format("Mon Jan 2, 2006 | 3:04:05pm")

		if localDt.Day() == time.Now().Day() {
			formattedTs = localDt.Format("Today | 3:04:05pm")
		} else if localDt.Day() == time.Now().AddDate(0, 0, -1).Day() {
			formattedTs = localDt.Format("Yesterday | 3:04:05pm")
		}

		// Convert to local time and format back to a string without the timezone to match the original format.
		return formattedTs + " " + zone
	}

	// Find all matches and replace them.
	result := re.ReplaceAllStringFunc(input, replaceFunc)

	return result, nil
}


================================================
FILE: app/cli/cmd/ls.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/format"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var contextCmd = &cobra.Command{
	Use:     "ls",
	Aliases: []string{"list-context"},
	Short:   "List everything in context",
	Run:     listContext,
}

func listContext(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error listing context: %v", err)
	}

	planConfig, err := api.Client.GetPlanConfig(lib.CurrentPlanId)
	if err != nil {
		term.OutputErrorAndExit("Error getting plan config: %v", err)
	}
	term.StopSpinner()

	totalTokens := 0
	totalPlannerTokens := 0
	totalMapTokens := 0
	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"#", "Name", "Type", "🪙", "Added", "Updated"})
	table.SetAutoWrapText(false)

	if len(contexts) == 0 {
		fmt.Println("🤷‍♂️ No context")
		fmt.Println()
		term.PrintCmds("", "load")
		return
	}

	for i, context := range contexts {
		totalTokens += context.NumTokens

		if context.ContextType == shared.ContextMapType {
			totalMapTokens += context.NumTokens
		} else {
			totalPlannerTokens += context.NumTokens
		}

		t, icon := context.TypeAndIcon()

		name := context.Name
		if name == "" {
			name = context.FilePath
		}
		if len(name) > 40 {
			name = name[:20] + "⋯" + name[len(name)-20:]
		}

		row := []string{
			strconv.Itoa(i + 1),
			" " + icon + " " + name,
			t,
			strconv.Itoa(context.NumTokens), //+ " 🪙",
			format.Time(context.CreatedAt),
			format.Time(context.UpdatedAt),
		}
		table.Rich(row, []tablewriter.Colors{
			{tablewriter.Bold},
			{tablewriter.FgHiGreenColor, tablewriter.Bold},
		})
	}

	table.Render()

	tokensTbl := tablewriter.NewWriter(os.Stdout)
	tokensTbl.SetAutoWrapText(false)

	if planConfig.AutoLoadContext {
		tokensTbl.Append([]string{
			color.New(term.ColorHiCyan, color.Bold).Sprintf("Map tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalMapTokens),
			color.New(term.ColorHiCyan, color.Bold).Sprintf("Context tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalPlannerTokens),
		})
	} else {

		tokensTbl.Append([]string{color.New(term.ColorHiCyan, color.Bold).Sprintf("Total tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalTokens)})
	}
	tokensTbl.Render()

	fmt.Println()
	term.PrintCmds("", "load", "rm", "clear")

}

func init() {
	RootCmd.AddCommand(contextCmd)

}


================================================
FILE: app/cli/cmd/model_helpers.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/lib"
	"plandex-cli/term"
	shared "plandex-shared"

	"github.com/fatih/color"
)

func warnModelsFileLocalChanges(path, cmd string) (bool, error) {
	cmdPrefix := "\\"
	if !term.IsRepl {
		cmdPrefix = "plandex "
	}

	color.New(color.Bold, term.ColorHiYellow).Println("⚠️  The models file has local changes")

	fmt.Println()
	fmt.Println("Path → " + path)
	fmt.Println()

	fmt.Println("If you continue, local changes will be dropped in favor of the latest server state")

	fmt.Println()
	fmt.Printf("To keep the local version instead, quit and run %s\n", color.New(color.Bold, color.BgCyan, color.FgHiWhite).
		Sprintf(" %s%s --save ", cmdPrefix, cmd))
	fmt.Println()
	return term.ConfirmYesNo("Drop local changes and continue?")

}

type maybePromptAndOpenModelsFileResult struct {
	shouldReturn bool
	jsonData     []byte
}

func maybePromptAndOpenModelsFile(filePath, pathArg, cmd string, defaultConfig *shared.PlanConfig, planConfig *shared.PlanConfig) maybePromptAndOpenModelsFileResult {

	printManual := func() {
		cmdPrefix := "\\"
		if !term.IsRepl {
			cmdPrefix = "plandex "
		}
		fmt.Println("To save changes, run " +
			fmt.Sprintf(" %s ", color.New(color.Bold, color.BgCyan, color.FgHiWhite).
				Sprintf(" %s%s --save%s ", cmdPrefix, cmd, pathArg)))
	}

	selectedEditor := lib.MaybePromptAndOpen(filePath, defaultConfig, planConfig)

	if selectedEditor {
		fmt.Println("📝 Opened in editor")
		fmt.Println()

		confirmed, err := term.ConfirmYesNo("Ready to save?")
		if err != nil {
			term.OutputErrorAndExit("Error confirming: %v", err)
			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
		}

		if !confirmed {
			fmt.Println("🙅‍♂️ Update canceled")
			fmt.Println()

			printManual()
			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
		}

		// get updated file state
		jsonData, err := os.ReadFile(filePath)
		if err != nil {
			term.OutputErrorAndExit("Error reading JSON file: %v", err)
			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
		}

		return maybePromptAndOpenModelsFileResult{shouldReturn: false, jsonData: jsonData}
	} else {
		// No editor available or user chose manual
		fmt.Println("👨‍💻 Edit the file in your JSON editor of choice")
		fmt.Println()

		printManual()
		return maybePromptAndOpenModelsFileResult{shouldReturn: true}
	}
}


================================================
FILE: app/cli/cmd/model_packs.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var customModelPacksOnly bool

var modelPacksCmd = &cobra.Command{
	Use:   "model-packs",
	Short: "List all model packs",
	Run:   listModelPacks,
}

var createModelPackCmd = &cobra.Command{
	Use:   "create",
	Short: "Create a model pack",
	Run:   customModelsNotImplemented,
}

var deleteModelPackCmd = &cobra.Command{
	Use:     "delete",
	Aliases: []string{"rm"},
	Short:   "Delete a model pack by name or index",
	Run:     customModelsNotImplemented,
}

var updateModelPackCmd = &cobra.Command{
	Use:   "update",
	Short: "Update a model pack by name",
	Run:   customModelsNotImplemented,
}

var showModelPackCmd = &cobra.Command{
	Use:   "show [name]",
	Short: "Show a model pack by name",
	Args:  cobra.MaximumNArgs(1),
	Run:   showModelPack,
}

func init() {
	RootCmd.AddCommand(modelPacksCmd)
	modelPacksCmd.AddCommand(createModelPackCmd)
	modelPacksCmd.AddCommand(deleteModelPackCmd)
	modelPacksCmd.AddCommand(updateModelPackCmd)
	modelPacksCmd.AddCommand(showModelPackCmd)
	modelPacksCmd.Flags().BoolVarP(&customModelPacksOnly, "custom", "c", false, "Only show custom model packs")
	modelPacksCmd.Flags().BoolVarP(&allProperties, "all", "a", false, "Show all properties")
}

func listModelPacks(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")
	builtInModelPacks := shared.BuiltInModelPacks

	if auth.Current.IsCloud {
		filtered := []*shared.ModelPack{}
		for _, mp := range builtInModelPacks {
			if mp.LocalProvider == "" {
				filtered = append(filtered, mp)
			}
		}
		builtInModelPacks = filtered
	}

	customModelPacks, err := api.Client.ListModelPacks()
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error fetching model packs: %v", err)
		return
	}

	if !customModelPacksOnly {
		color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Model Packs")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(true)
		table.SetRowLine(true)
		table.SetHeader([]string{"Name", "Description"})
		for _, set := range builtInModelPacks {
			table.Append([]string{set.Name, set.Description})
		}
		table.Render()
		fmt.Println()
	}

	if len(customModelPacks) > 0 {
		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Model Packs")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(true)
		table.SetRowLine(true)
		table.SetHeader([]string{"#", "Name", "Description"})
		for i, set := range customModelPacks {
			table.Append([]string{fmt.Sprintf("%d", i+1), set.Name, set.Description})
		}
		table.Render()

		fmt.Println()
	} else if customModelPacksOnly {
		fmt.Println("🤷‍♂️ No custom model packs")
		fmt.Println()
	}

	if customModelPacksOnly && len(customModelPacks) > 0 {
		term.PrintCmds("", "model-packs show", "models custom")
	} else if len(customModelPacks) > 0 {
		term.PrintCmds("", "model-packs --custom", "model-packs show", "models custom")
	} else {
		term.PrintCmds("", "model-packs show", "models custom")
	}

}

func showModelPack(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")
	customModelPacks, apiErr := api.Client.ListModelPacks()
	if apiErr != nil {
		term.OutputErrorAndExit("Error fetching models: %v", apiErr)
	}
	customModels, err := api.Client.ListCustomModels()
	if err != nil {
		term.OutputErrorAndExit("Error fetching custom models: %v", err)
	}
	customModelsById := make(map[shared.ModelId]*shared.CustomModel)
	for _, m := range customModels {
		customModelsById[m.ModelId] = m
	}

	term.StopSpinner()

	modelPacks := []*shared.ModelPack{}
	modelPacks = append(modelPacks, customModelPacks...)

	builtInModelPacks := shared.BuiltInModelPacks
	if auth.Current.IsCloud {
		filtered := []*shared.ModelPack{}
		for _, mp := range builtInModelPacks {
			if mp.LocalProvider == "" {
				filtered = append(filtered, mp)
			}
		}
		builtInModelPacks = filtered
	}
	modelPacks = append(modelPacks, builtInModelPacks...)

	var name string
	if len(args) > 0 {
		name = args[0]
	}

	var modelPack *shared.ModelPack

	if name == "" {
		opts := make([]string, len(modelPacks))
		for i, mp := range modelPacks {
			opts[i] = mp.Name
		}

		selected, err := term.SelectFromList("Select a model pack:", opts)
		if err != nil {
			term.OutputErrorAndExit("Error selecting model pack: %v", err)
		}

		for _, mp := range modelPacks {
			if mp.Name == selected {
				modelPack = mp
				break
			}
		}
	} else {
		for _, mp := range modelPacks {
			if mp.Name == name {
				modelPack = mp
				break
			}
		}
	}

	if modelPack == nil {
		term.OutputErrorAndExit("Model pack not found")
		return
	}

	renderModelPack(modelPack, customModelsById, allProperties)

	fmt.Println()

	term.PrintCmds("", "set-model", "set-model default", "models custom")
}

// func getModelRoleConfig(customModels []*shared.CustomModel, modelRole shared.ModelRole) shared.ModelRoleConfig {
// 	_, modelConfig := getModelWithRoleConfig(customModels, modelRole)
// 	return modelConfig
// }

// func getModelWithRoleConfig(customModels []*shared.CustomModel, modelRole shared.ModelRole) (*shared.CustomModel, shared.ModelRoleConfig) {
// 	role := string(modelRole)

// 	modelId := getModelIdForRole(customModels, modelRole)

// 	temperatureStr, err := term.GetUserStringInputWithDefault("Temperature for "+role+":", fmt.Sprintf("%.1f", shared.DefaultConfigByRole[modelRole].Temperature))
// 	if err != nil {
// 		term.OutputErrorAndExit("Error reading temperature: %v", err)
// 	}
// 	temperature, err := strconv.ParseFloat(temperatureStr, 32)
// 	if err != nil {
// 		term.OutputErrorAndExit("Invalid number for temperature: %v", err)
// 	}

// 	topPStr, err := term.GetUserStringInputWithDefault("Top P for "+role+":", fmt.Sprintf("%.1f", shared.DefaultConfigByRole[modelRole].TopP))
// 	if err != nil {
// 		term.OutputErrorAndExit("Error reading top P: %v", err)
// 	}
// 	topP, err := strconv.ParseFloat(topPStr, 32)
// 	if err != nil {
// 		term.OutputErrorAndExit("Invalid number for top P: %v", err)
// 	}

// 	var reservedOutputTokens int
// 	if modelRole == shared.ModelRoleBuilder || modelRole == shared.ModelRolePlanner || modelRole == shared.ModelRoleWholeFileBuilder {
// 		reservedOutputTokensStr, err := term.GetUserStringInputWithDefault("Reserved output tokens for "+role+":", fmt.Sprintf("%d", model.ReservedOutputTokens))
// 		if err != nil {
// 			term.OutputErrorAndExit("Error reading reserved output tokens: %v", err)
// 		}
// 		reservedOutputTokens, err = strconv.Atoi(reservedOutputTokensStr)
// 		if err != nil {
// 			term.OutputErrorAndExit("Invalid number for reserved output tokens: %v", err)
// 		}
// 	}

// 	return model, shared.ModelRoleConfig{
// 		ModelId:              model.ModelId,
// 		Role:                 modelRole,
// 		Temperature:          float32(temperature),
// 		TopP:                 float32(topP),
// 		ReservedOutputTokens: reservedOutputTokens,
// 	}
// }

// func getPlannerRoleConfig(customModels []*shared.CustomModel) shared.PlannerRoleConfig {
// 	model, modelConfig := getModelWithRoleConfig(customModels, shared.ModelRolePlanner)

// 	return shared.PlannerRoleConfig{
// 		ModelRoleConfig: modelConfig,
// 		PlannerModelConfig: shared.PlannerModelConfig{
// 			MaxConvoTokens: model.DefaultMaxConvoTokens,
// 		},
// 	}
// }

// func getModelIdForRole(customModels []*shared.CustomModel, role shared.ModelRole) shared.ModelId {
// 	color.New(color.Bold).Printf("Select a model for the %s role 👇\n", role)
// 	return lib.SelectModelIdForRole(customModels, role)
// }


================================================
FILE: app/cli/cmd/model_providers.go
================================================
package cmd

import (
	"fmt"
	"os"
	"strconv"
	"strings"

	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var customProvidersOnly bool

var providersCmd = &cobra.Command{
	Use:   "providers",
	Short: "List built-in and custom model providers",
	Run:   listProviders,
}

var addProviderCmd = &cobra.Command{
	Use:     "add",
	Aliases: []string{"create"},
	Short:   "Add a custom model provider",
	Run:     customModelsNotImplemented,
}

var updateProviderCmd = &cobra.Command{
	Use:     "update",
	Aliases: []string{"edit"},
	Short:   "Update a custom model provider",
	Run:     customModelsNotImplemented,
}

func init() {
	RootCmd.AddCommand(providersCmd)
	providersCmd.Flags().BoolVarP(&customProvidersOnly, "custom", "c", false, "List custom providers only")
	providersCmd.AddCommand(addProviderCmd)
	providersCmd.AddCommand(updateProviderCmd)
}

func listProviders(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	var customProviders []*shared.CustomProvider
	var apiErr *shared.ApiError

	if customProvidersOnly && auth.Current.IsCloud {
		term.OutputErrorAndExit("Custom providers are not supported on Plandex Cloud")
		return
	}

	if !auth.Current.IsCloud {
		term.StartSpinner("")
		customProviders, apiErr = api.Client.ListCustomProviders()
		term.StopSpinner()
		if apiErr != nil {
			term.OutputErrorAndExit("Error fetching providers: %v", apiErr.Msg)
			return
		}
	}

	if customProvidersOnly && len(customProviders) == 0 {
		fmt.Println("🤷‍♂️  No custom providers")
		fmt.Println()
		term.PrintCmds("", "models custom")
		return
	}

	color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Providers")
	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(true)

	var header []string
	if auth.Current.IsCloud {
		header = []string{"ID", "API Key", "Other Vars"}
	} else {
		header = []string{"ID", "Base URL", "API Key", "Other Vars"}
	}
	table.SetHeader(header)
	for _, p := range shared.AllModelProviders {
		if p == shared.ModelProviderCustom {
			continue
		}
		config := shared.BuiltInModelProviderConfigs[p]
		if config.LocalOnly && auth.Current.IsCloud {
			continue
		}
		var apiKey string
		if config.ApiKeyEnvVar != "" {
			apiKey = config.ApiKeyEnvVar
		} else if config.SkipAuth {
			apiKey = "No Auth"
		} else if config.HasClaudeMaxAuth {
			apiKey = "Claude Max Oauth"
		}

		extraVars := []string{}
		if config.Provider == shared.ModelProviderAmazonBedrock {
			extraVars = append(extraVars, "PLANDEX_AWS_PROFILE")
		}
		for _, v := range config.ExtraAuthVars {
			extraVars = append(extraVars, v.Var)
		}

		if auth.Current.IsCloud {
			table.Append([]string{
				string(p),
				apiKey,
				strings.Join(extraVars, "\n"),
			})
		} else {
			table.Append([]string{
				string(p),
				config.BaseUrl,
				apiKey,
				strings.Join(extraVars, "\n"),
			})
		}
	}
	table.Render()
	fmt.Println()

	if len(customProviders) > 0 {
		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Providers")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"#", "Name", "Base URL", "API Key", "Other Vars"})
		for i, p := range customProviders {
			extraVars := []string{}
			for _, v := range p.ExtraAuthVars {
				extraVars = append(extraVars, v.Var)
			}
			apiKey := p.ApiKeyEnvVar
			if apiKey == "" && p.SkipAuth {
				apiKey = "No Auth"
			}

			table.Append([]string{
				strconv.Itoa(i + 1),
				p.Name,
				p.BaseUrl,
				apiKey,
				strings.Join(extraVars, "\n"),
			})
		}
		table.Render()
		fmt.Println()
	}

	fmt.Println(color.New(color.Bold, term.ColorHiCyan).Sprint("\n📖 Per-provider instructions"))
	fmt.Println("Go to → " + color.New(color.Bold).Sprint("https://docs.plandex.ai/models/model-providers"))
	fmt.Println()

	term.PrintCmds("", "models custom")
}


================================================
FILE: app/cli/cmd/models.go
================================================
package cmd

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"

	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var customModelsOnly bool
var allProperties bool
var saveCustomModels bool
var customModelsPath string

func init() {
	RootCmd.AddCommand(modelsCmd)

	modelsCmd.Flags().BoolVarP(&allProperties, "all", "a", false, "Show all properties")

	modelsCmd.AddCommand(listAvailableModelsCmd)
	modelsCmd.AddCommand(addCustomModelCmd)
	modelsCmd.AddCommand(updateCustomModelCmd)
	modelsCmd.AddCommand(manageCustomModelsCmd)
	modelsCmd.AddCommand(deleteCustomModelCmd)
	modelsCmd.AddCommand(defaultModelsCmd)

	manageCustomModelsCmd.Flags().BoolVar(&saveCustomModels, "save", false, "Save custom models")
	manageCustomModelsCmd.Flags().StringVarP(&customModelsPath, "file", "f", "", "Path to custom models file")

	listAvailableModelsCmd.Flags().BoolVarP(&customModelsOnly, "custom", "c", false, "List custom models only")
}

var modelsCmd = &cobra.Command{
	Use:   "models",
	Short: "Show plan model settings",
	Run:   models,
}

var defaultModelsCmd = &cobra.Command{
	Use:   "default",
	Short: "Show default model settings for new plans",
	Run:   defaultModels,
}

var listAvailableModelsCmd = &cobra.Command{
	Use:     "available",
	Aliases: []string{"avail"},
	Short:   "List all available models",
	Run:     listAvailableModels,
}

var manageCustomModelsCmd = &cobra.Command{
	Use:   "custom",
	Short: "Manage custom models, providers, and model packs",
	Run:   manageCustomModels,
}

var addCustomModelCmd = &cobra.Command{
	Use:     "add",
	Aliases: []string{"create"},
	Short:   "Add a custom model",
	Run:     customModelsNotImplemented,
}

var updateCustomModelCmd = &cobra.Command{
	Use:     "update",
	Aliases: []string{"edit"},
	Short:   "Update a custom model",
	Run:     customModelsNotImplemented,
}

var deleteCustomModelCmd = &cobra.Command{
	Use:     "rm",
	Aliases: []string{"remove", "delete"},
	Short:   "Remove a custom model",
	Args:    cobra.MaximumNArgs(1),
	Run:     customModelsNotImplemented,
}

func manageCustomModels(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")

	var serverModelsInput *shared.ModelsInput
	var defaultConfig *shared.PlanConfig

	errCh := make(chan error, 2)

	go func() {
		var err error
		serverModelsInput, err = lib.GetServerModelsInput()
		if err != nil {
			errCh <- fmt.Errorf("error getting server models input: %v", err)
			return
		}
		errCh <- nil
	}()

	go func() {
		var apiErr *shared.ApiError
		defaultConfig, apiErr = api.Client.GetDefaultPlanConfig()
		if apiErr != nil {
			errCh <- fmt.Errorf("error getting default config: %v", apiErr.Msg)
			return
		}
		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			term.OutputErrorAndExit(err.Error())
			return
		}
	}

	usingDefaultPath := false
	if customModelsPath == "" {
		usingDefaultPath = true
		customModelsPath = lib.GetCustomModelsPath(auth.Current.UserId)
	}

	exists, err := fs.FileExists(customModelsPath)
	if err != nil {
		term.OutputErrorAndExit("Error checking custom models file: %v", err)
		return
	}

	if saveCustomModels {
		if !exists {
			term.OutputErrorAndExit("File not found: %s", customModelsPath)
			return
		}
	} else {
		if serverModelsInput.IsEmpty() {
			jsonData, err := json.MarshalIndent(getExampleTemplate(auth.Current.IsCloud, auth.Current.IntegratedModelsMode), "", "  ")
			if err != nil {
				term.OutputErrorAndExit("Error marshalling template: %v", err)
				return
			}

			err = os.MkdirAll(filepath.Dir(customModelsPath), 0755)
			if err != nil {
				term.OutputErrorAndExit("Error creating directory: %v", err)
				return
			}

			err = os.WriteFile(customModelsPath, jsonData, 0644)
			if err != nil {
				term.OutputErrorAndExit("Error writing template file: %v", err)
				return
			}

			term.StopSpinner()

			fmt.Printf("🧠 Example models file → %s\n", customModelsPath)
			fmt.Println("👨‍💻 Edit it, then come back here to save")
			fmt.Println()
		} else {
			serverClientModelsInput := serverModelsInput.ToClientModelsInput()
			serverClientModelsInput.PrepareUpdate()

			var localModelsInput shared.ModelsInput

			if exists {
				// we only do a conflict check on the default path in the home dir
				// if user specifies the path and the file exists, just open the file without checking for conflicts
				if usingDefaultPath {
					res, err := lib.CustomModelsCheckLocalChanges(customModelsPath)
					if err != nil {
						term.OutputErrorAndExit("Error checking local changes: %v", err)
						return
					}

					localModelsInput = res.LocalModelsInput
					if res.HasLocalChanges {
						term.StopSpinner()

						res, err := warnModelsFileLocalChanges(customModelsPath, "models custom")
						if err != nil {
							term.OutputErrorAndExit("Error confirming: %v", err)
							return
						}
						if !res {
							return
						}
						fmt.Println()
						term.StartSpinner("")
					}
				}
			}

			if !serverModelsInput.Equals(localModelsInput) {
				err := lib.WriteCustomModelsFile(customModelsPath, serverModelsInput)
				if err != nil {
					term.OutputErrorAndExit("Error saving custom models file: %v", err)
					return
				}
			}

			term.StopSpinner()

			fmt.Printf("🧠 %s → %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Models file"), customModelsPath)
			fmt.Println("👨‍💻 Edit it, then come back here to save")
			fmt.Println()
		}

		pathArg := ""
		if !usingDefaultPath {
			pathArg = fmt.Sprintf(" --file %s", customModelsPath)
		}

		res := maybePromptAndOpenModelsFile(customModelsPath, pathArg, "models custom", defaultConfig, nil)
		if res.shouldReturn {
			return
		}
	}

	didUpdate := lib.MustSyncCustomModels(customModelsPath, serverModelsInput)

	if !didUpdate {
		fmt.Println("🤷‍♂️ No changes to custom models/providers/model packs")
	}
}

func models(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")

	plan, err := api.Client.GetPlan(lib.CurrentPlanId)

	if err != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting plan: %v", err)
		return
	}

	settings, err := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error getting settings: %v", err)
		return
	}

	title := fmt.Sprintf("%s Model Settings", color.New(color.Bold, term.ColorHiGreen).Sprint(plan.Name))

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.Append([]string{title})
	table.Render()
	fmt.Println()

	renderSettings(settings, allProperties)

	term.PrintCmds("", "set-model", "models available", "models default", "models custom")
}

func defaultModels(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")
	settings, err := api.Client.GetOrgDefaultSettings()

	if err != nil {
		term.OutputErrorAndExit("Error getting default model settings: %v", err)
		return
	}

	term.StopSpinner()

	title := fmt.Sprintf("%s Model Settings", color.New(color.Bold, term.ColorHiGreen).Sprint("Org-Wide Default"))
	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.Append([]string{title})
	table.Render()
	fmt.Println()

	renderSettings(settings, allProperties)

	term.PrintCmds("", "set-model default", "models available", "models")
}

func listAvailableModels(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	if customModelsOnly && auth.Current.IntegratedModelsMode {
		term.OutputErrorAndExit("Custom models are not supported in Integrated Models mode on Plandex Cloud")
		return
	}

	term.StartSpinner("")

	customModels, err := api.Client.ListCustomModels()

	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error fetching custom models: %v", err)
		return
	}

	if !customModelsOnly {
		color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Models")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"Model", "Input", "Output", "Reserved"})
		for _, model := range shared.BuiltInBaseModels {
			if auth.Current.IsCloud && model.IsLocalOnly() {
				continue
			}

			table.Append([]string{string(model.ModelId), fmt.Sprintf("%d 🪙", model.MaxTokens), fmt.Sprintf("%d 🪙", model.MaxOutputTokens), fmt.Sprintf("%d 🪙", model.ReservedOutputTokens)})
		}
		table.Render()
		fmt.Println()
	}

	if len(customModels) > 0 {
		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Models")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"#", "ID", "🪙"})
		for i, model := range customModels {
			table.Append([]string{fmt.Sprintf("%d", i+1), string(model.ModelId), strconv.Itoa(model.MaxTokens)})
		}
		table.Render()
	} else if customModelsOnly {
		fmt.Println("🤷‍♂️ No custom models")
	}
	fmt.Println()

	if customModelsOnly {
		if len(customModels) > 0 {
			term.PrintCmds("", "models", "set-model", "models custom")
		} else {
			term.PrintCmds("", "models custom")
		}
	} else {
		term.PrintCmds("", "models available --custom", "models", "set-model", "models custom")
	}
}

func renderSettings(settings *shared.PlanSettings, allProperties bool) {
	modelPack := settings.GetModelPack()

	color.New(color.Bold, term.ColorHiCyan).Println("🎛️  Current Model Pack")
	renderModelPack(modelPack, settings.CustomModelsById, allProperties)

	if allProperties {
		color.New(color.Bold, term.ColorHiCyan).Println("🧠 Planner Defaults")
		table := tablewriter.NewWriter(os.Stdout)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"Max Tokens", "Max Convo Tokens"})
		table.Append([]string{
			fmt.Sprintf("%d", modelPack.Planner.GetFinalLargeContextFallback().GetSharedBaseConfig(settings).MaxTokens),
			fmt.Sprintf("%d", modelPack.Planner.GetMaxConvoTokens(settings)),
		})
		table.Render()
		fmt.Println()
	}
}

func renderModelPack(modelPack *shared.ModelPack, customModelsById map[shared.ModelId]*shared.CustomModel, allProperties bool) {
	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoFormatHeaders(false)
	table.SetAutoWrapText(true)
	table.SetColWidth(64)
	table.SetHeader([]string{modelPack.Name})
	table.Append([]string{modelPack.Description})
	table.Render()
	fmt.Println()

	color.New(color.Bold, term.ColorHiCyan).Println("🤖 Models")
	table = tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	cols := []string{
		"Role",
		"Model",
	}
	align := []int{
		tablewriter.ALIGN_LEFT, // Role
		tablewriter.ALIGN_LEFT, // Model
	}
	if allProperties {
		cols = append(cols, []string{
			"Temperature",
			"Top P",
			"Max Input",
		}...)
		align = append(align, []int{
			tablewriter.ALIGN_RIGHT, // Temperature
			tablewriter.ALIGN_RIGHT, // Top P
			tablewriter.ALIGN_RIGHT, // Max Input
		}...)
	}
	table.SetHeader(cols)
	table.SetColumnAlignment(align)

	anyRoleParamsDisabled := false

	var addModelRow func(role string, config shared.ModelRoleConfig, indent int)
	addModelRow = func(role string, config shared.ModelRoleConfig, indent int) {
		if indent > 0 {
			role = "└─ " + role
			for i := 0; i < indent-1; i++ {
				role = " " + role
			}
		}

		var temp float32
		var topP float32
		var disabled bool

		sharedBaseConfig := config.GetSharedBaseConfigWithCustomModels(customModelsById)

		if sharedBaseConfig.RoleParamsDisabled {
			temp = 1
			topP = 1
			disabled = true
			anyRoleParamsDisabled = true
		} else {
			temp = config.Temperature
			topP = config.TopP
		}

		tempStr := fmt.Sprintf("%.1f", temp)
		if disabled {
			tempStr = "*" + tempStr
		}

		topPStr := fmt.Sprintf("%.1f", topP)
		if disabled {
			topPStr = "*" + topPStr
		}

		row := []string{
			role,
			string(config.GetModelId()),
		}

		if allProperties {
			row = append(row, []string{
				tempStr,
				topPStr,
				fmt.Sprintf("%d 🪙", sharedBaseConfig.MaxTokens-config.GetReservedOutputTokens(customModelsById)),
			}...)
		}
		table.Append(row)

		// Add large context and large output fallback(s) if present
		if config.LargeContextFallback != nil {
			addModelRow("large-context", *config.LargeContextFallback, indent+1)
		}

		if config.LargeOutputFallback != nil {
			addModelRow("large-output", *config.LargeOutputFallback, indent+1)
		}

		if config.StrongModel != nil {
			addModelRow("strong", *config.StrongModel, indent+1)
		}

		if config.ErrorFallback != nil {
			addModelRow("error", *config.ErrorFallback, indent+1)
		}
	}

	addModelRow(string(shared.ModelRolePlanner), modelPack.Planner.ModelRoleConfig, 0)

	addModelRow(string(shared.ModelRoleArchitect), modelPack.GetArchitect(), 0)
	addModelRow(string(shared.ModelRoleCoder), modelPack.GetCoder(), 0)
	addModelRow(string(shared.ModelRolePlanSummary), modelPack.PlanSummary, 0)
	addModelRow(string(shared.ModelRoleBuilder), modelPack.Builder, 0)
	addModelRow(string(shared.ModelRoleWholeFileBuilder), modelPack.GetWholeFileBuilder(), 0)
	addModelRow(string(shared.ModelRoleName), modelPack.Namer, 0)
	addModelRow(string(shared.ModelRoleCommitMsg), modelPack.CommitMsg, 0)
	addModelRow(string(shared.ModelRoleExecStatus), modelPack.ExecStatus, 0)
	table.Render()

	if anyRoleParamsDisabled && allProperties {
		fmt.Println("* these models do not support changing temperature or top p")
	}

	fmt.Println()

}

func customModelsNotImplemented(cmd *cobra.Command, args []string) {
	color.New(color.Bold, color.FgHiRed).Println("⛔️ Not implemented")
	fmt.Println()
	fmt.Println("Use " + color.New(color.BgCyan, color.FgHiWhite).Sprint(" plandex models custom ") + " to manage custom models, providers, and model packs")
	os.Exit(1)
}

func getExampleTemplate(isCloud, isCloudIntegratedModels bool) shared.ClientModelsInput {
	exampleProviderName := "togetherai"

	var customProviders []*shared.CustomProvider
	usesProviders := []shared.BaseModelUsesProvider{}
	if !isCloud {
		customProviders = append(customProviders, &shared.CustomProvider{
			Name:         exampleProviderName,
			BaseUrl:      "https://api.together.xyz/v1",
			ApiKeyEnvVar: "TOGETHER_API_KEY",
		})

		usesProviders = append(usesProviders, shared.BaseModelUsesProvider{
			Provider:       shared.ModelProviderCustom,
			CustomProvider: &exampleProviderName,
			ModelName:      "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
		})
	}
	usesProviders = append(usesProviders, shared.BaseModelUsesProvider{
		Provider:  shared.ModelProviderOpenRouter,
		ModelName: "meta-llama/llama-4-maverick",
	})

	var customModels []*shared.CustomModel
	if !isCloudIntegratedModels {
		customModels = []*shared.CustomModel{
			{
				ModelId:     shared.ModelId("meta-llama/llama-4-maverick"),
				Publisher:   shared.ModelPublisher("meta-llama"),
				Description: "Meta Llama 4 Maverick",

				BaseModelShared: shared.BaseModelShared{
					DefaultMaxConvoTokens: 75000,
					MaxTokens:             1048576,
					MaxOutputTokens:       16000,
					ReservedOutputTokens:  16000,
					ModelCompatibility:    shared.FullCompatibility,
					PreferredOutputFormat: shared.ModelOutputFormatXml,
				},

				Providers: usesProviders,
			},
		}
	}

	lightModelId := "meta-llama/llama-4-maverick"
	if len(customModels) == 0 {
		lightModelId = "mistral/devstral-small"
	}

	return shared.ClientModelsInput{
		SchemaUrl:       shared.SchemaUrlInputConfig,
		CustomProviders: customProviders,
		CustomModels:    customModels,
		CustomModelPacks: []*shared.ClientModelPackSchema{
			{
				Name:        "example-model-pack",
				Description: "Example model pack",
				ClientModelPackSchemaRoles: shared.ClientModelPackSchemaRoles{
					Planner:   "deepseek/r1",
					Architect: "deepseek/r1",
					Coder: &shared.ModelRoleConfigSchema{
						ModelId: "deepseek/v3",
						LargeContextFallback: &shared.ModelRoleConfigSchema{
							ModelId: "google/gemini-2.5-pro",
						},
						ErrorFallback: &shared.ModelRoleConfigSchema{
							ModelId: "deepseek/r1-hidden",
						},
					},
					PlanSummary: lightModelId,
					Builder: shared.ModelRoleConfigSchema{
						ModelId: "deepseek/r1-hidden",
						StrongModel: &shared.ModelRoleConfigSchema{
							ModelId: "openai/o3-medium",
						},
					},
					WholeFileBuilder: shared.ModelRoleConfigSchema{
						ModelId: "deepseek/r1-hidden",
						LargeContextFallback: &shared.ModelRoleConfigSchema{
							ModelId: "google/gemini-2.5-pro",
							LargeOutputFallback: &shared.ModelRoleConfigSchema{
								ModelId: "openai/o3-low",
							},
						},
						LargeOutputFallback: &shared.ModelRoleConfigSchema{
							ModelId: "openai/o3-low",
						},
					},
					ExecStatus: "deepseek/r1-hidden",
					Namer:      lightModelId,
					CommitMsg:  lightModelId,
				},
			},
		},
	}
}


================================================
FILE: app/cli/cmd/new.go
================================================
package cmd

import (
	"fmt"

	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"plandex-cli/types"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var name string
var contextBaseDir string

// newCmd represents the new command
var newCmd = &cobra.Command{
	Use:     "new",
	Aliases: []string{"n"},
	Short:   "Start a new plan",
	// Long:  ``,
	Args: cobra.ExactArgs(0),
	Run:  new,
}

func init() {
	RootCmd.AddCommand(newCmd)
	newCmd.Flags().StringVarP(&name, "name", "n", "", "Name of the new plan")
	newCmd.Flags().StringVar(&contextBaseDir, "context-dir", ".", "Base directory to auto-load context from")

	AddNewPlanFlags(newCmd)
}

func new(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveOrCreateProject()

	term.StartSpinner("")

	errCh := make(chan error, 2)

	var planId string
	var config *shared.PlanConfig

	go func() {
		res, apiErr := api.Client.CreatePlan(lib.CurrentProjectId, shared.CreatePlanRequest{Name: name})
		if apiErr != nil {
			errCh <- fmt.Errorf("error creating plan: %v", apiErr.Msg)
			return
		}
		planId = res.Id
		errCh <- nil
	}()

	go func() {
		var apiErr *shared.ApiError
		config, apiErr = api.Client.GetDefaultPlanConfig()
		if apiErr != nil {
			errCh <- fmt.Errorf("error getting plan config: %v", apiErr.Msg)
			return
		}
		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			term.OutputErrorAndExit("Error: %v", err)
		}
	}

	err := lib.WriteCurrentPlan(planId)

	if err != nil {
		term.OutputErrorAndExit("Error setting current plan: %v", err)
	}

	err = lib.WriteCurrentBranch("main")
	if err != nil {
		term.OutputErrorAndExit("Error setting current branch: %v", err)
	}

	if name == "" {
		name = "draft"
	}

	term.StopSpinner()

	fmt.Printf("✅ Started new plan %s and set it to current plan\n", color.New(color.Bold, term.ColorHiGreen).Sprint(name))
	fmt.Printf("⚙️  Using default config\n")

	resolveAutoMode(config)

	resolveModelPack()

	// autoModeLabel := shared.ConfigSettingsByKey["automode"].KeyToLabel(string(config.AutoMode))
	// fmt.Println("⚡️ Auto-mode:", autoModeLabel)

	if config.AutoLoadContext {
		fmt.Println("📥 Automatic context loading is enabled")

		baseDir := contextBaseDir
		if baseDir == "" {
			baseDir = "."
		}

		lib.MustLoadContext([]string{baseDir}, &types.LoadContextParams{
			DefsOnly:          true,
			SkipIgnoreWarning: true,
			AutoLoaded:        true,
		})
	} else {
		fmt.Println()
	}

	var cmds []string
	if term.IsRepl {
		cmds = []string{"config", "plans", "cd", "models"}
	} else {
		cmds = []string{"tell", "chat", "config"}
	}

	if !config.AutoLoadContext {
		cmds = append([]string{"load"}, cmds...)
	}

	fmt.Println()
	term.PrintCmds("", cmds...)
}


================================================
FILE: app/cli/cmd/plan_exec_helpers.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

const (
	EditorTypeVim  string = "vim"
	EditorTypeNano string = "nano"
)

var defaultEditor = EditorTypeVim

const defaultAutoDebugTries = 5

var autoConfirm bool

var tellPromptFile string
var tellBg bool
var tellStop bool
var tellNoBuild bool
var tellAutoApply bool
var tellAutoContext bool
var tellSmartContext bool
var tellSkipMenu bool
var noExec bool
var autoDebug int

var editor = EditorTypeVim // default to vim
var editorSetByFlag bool

func init() {
	envEditor := os.Getenv("EDITOR")
	if envEditor == "" {
		envEditor = os.Getenv("VISUAL")
	}

	if envEditor != "" {
		defaultEditor = envEditor
	}
}

type initExecFlagsParams struct {
	omitFile         bool
	omitNoBuild      bool
	omitEditor       bool
	omitStop         bool
	omitBg           bool
	omitApply        bool
	omitExec         bool
	omitAutoContext  bool
	omitSmartContext bool
	omitSkipMenu     bool
}

func initExecFlags(cmd *cobra.Command, params initExecFlagsParams) {
	if !params.omitFile {
		cmd.Flags().StringVarP(&tellPromptFile, "file", "f", "", "File containing prompt")
	}

	if !params.omitBg {
		cmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")
	}

	if !params.omitStop {
		cmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")
	}

	if !params.omitNoBuild {
		cmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")
	}

	cmd.Flags().BoolVar(&autoConfirm, "auto-update-context", false, shared.ConfigSettingsByKey["auto-update-context"].Desc)

	if !params.omitAutoContext {
		cmd.Flags().BoolVar(&tellAutoContext, "auto-load-context", false, shared.ConfigSettingsByKey["auto-load-context"].Desc)
	}

	if !params.omitSmartContext {
		cmd.Flags().BoolVar(&tellSmartContext, "smart-context", false, shared.ConfigSettingsByKey["smart-context"].Desc)
	}

	if !params.omitApply {
		cmd.Flags().BoolVar(&tellAutoApply, "apply", false, "Automatically apply changes")
		initApplyFlags(cmd, true)
	}

	if !params.omitExec {
		initExecScriptFlags(cmd)
	}

	if !params.omitEditor {
		cmd.Flags().Var(newEditorValue(&editor), "editor", "Write prompt in system editor")
		cmd.Flag("editor").NoOptDefVal = defaultEditor
	}

	if !params.omitSkipMenu {
		cmd.Flags().BoolVar(&tellSkipMenu, "skip-menu", false, shared.ConfigSettingsByKey["skip-changes-menu"].Desc)
	}
}

func initApplyFlags(cmd *cobra.Command, applyFlag bool) {
	commitDesc := "Commit changes to git"
	if applyFlag {
		commitDesc += " when --apply is passed"
	}

	skipCommitDesc := "Skip committing changes to git"
	if applyFlag {
		skipCommitDesc += " when --apply is passed"
	}
	cmd.Flags().BoolVarP(&autoCommit, "commit", "c", false, commitDesc)
	cmd.Flags().BoolVar(&skipCommit, "skip-commit", false, skipCommitDesc)
}

func initExecScriptFlags(cmd *cobra.Command) {
	cmd.Flags().BoolVar(&noExec, "no-exec", false, "Disable command execution")
	cmd.Flags().BoolVar(&autoExec, "auto-exec", false, "Automatically execute commands without confirmation")
	cmd.Flags().Var(newAutoDebugValue(&autoDebug), "debug", "Automatically execute and debug failing commands (optionally specify number of tries—default is 5)")
	cmd.Flag("debug").NoOptDefVal = strconv.Itoa(defaultAutoDebugTries)
}

func validatePlanExecFlags(isApply bool) {
	if autoDebug > 0 && noExec {
		term.OutputErrorAndExit("--debug can't be used with --no-exec")
	}

	if tellAutoContext && tellBg {
		term.OutputErrorAndExit("--auto-context/-c can't be used with --bg")
	}

	if !isApply {
		if autoDebug > 0 && !tellAutoApply {
			term.OutputErrorAndExit("--debug can only be used with --apply")
		}

		if autoExec && !tellAutoApply {
			term.OutputErrorAndExit("--auto-exec can only be used with --apply")
		}

		if tellAutoApply && tellNoBuild {
			term.OutputErrorAndExit("--apply can't be used with --no-build/-n")
		}
		if tellAutoApply && tellBg {
			term.OutputErrorAndExit("--apply can't be used with --bg")
		}
	}
}

func mustSetPlanExecFlags(cmd *cobra.Command, isApply bool) {
	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	config := lib.MustGetCurrentPlanConfig()

	// Set flag vars from config when flags aren't explicitly set
	if !cmd.Flags().Changed("stop") {
		tellStop = !config.AutoContinue
	}

	if !cmd.Flags().Changed("no-build") {
		tellNoBuild = !config.AutoBuild
	}

	if !cmd.Flags().Changed("auto-update-context") {
		autoConfirm = config.AutoUpdateContext
	}
	if !cmd.Flags().Changed("apply") {
		tellAutoApply = config.AutoApply
	}
	if !cmd.Flags().Changed("skip-commit") {
		skipCommit = config.SkipCommit
	}
	if !cmd.Flags().Changed("commit") {
		autoCommit = config.AutoCommit
	}
	if !cmd.Flags().Changed("auto-load-context") {
		tellAutoContext = config.AutoLoadContext
	}
	if !cmd.Flags().Changed("smart-context") {
		tellSmartContext = config.SmartContext
	}
	if !cmd.Flags().Changed("no-exec") {
		noExec = !config.CanExec
	}
	if !cmd.Flags().Changed("auto-exec") {
		autoExec = config.AutoExec
	}
	if !cmd.Flags().Changed("debug") {
		autoDebug = config.AutoDebugTries
		// Only set autoDebug if AutoDebug is enabled in config
		if !config.AutoDebug {
			autoDebug = 0
		}
	}

	if !cmd.Flags().Changed("skip-menu") {
		tellSkipMenu = config.SkipChangesMenu
	}

	// tell command editor is no longer tied to config *unless* it's set to vim or nano
	// otherwise, the flag or EDITOR env var are used
	// config.Editor is now used for mainly for JSON editing (and perhaps other purposes)
	// this is because it's pretty rare to use the editor for writing prompts now rather than the REPL
	if !editorSetByFlag && (config.Editor == shared.EditorTypeVim || config.Editor == shared.EditorTypeNano) {
		editor = config.Editor
	}

	validatePlanExecFlags(isApply)
}

// AutoDebugValue implements the flag.Value interface
type autoDebugValue struct {
	value *int
}

func newAutoDebugValue(p *int) *autoDebugValue {
	*p = 0 // Default to 0 (disabled)
	return &autoDebugValue{p}
}

func (f *autoDebugValue) Set(s string) error {
	if s == "" {
		*f.value = defaultAutoDebugTries
		return nil
	}
	v, err := strconv.Atoi(s)
	if err != nil {
		return fmt.Errorf("invalid value for --debug: %v", err)
	}
	if v <= 0 {
		return fmt.Errorf("--debug value must be greater than 0")
	}
	*f.value = v
	return nil
}

func (f *autoDebugValue) String() string {
	if f.value == nil {
		return "0"
	}
	return strconv.Itoa(*f.value)
}

func (f *autoDebugValue) Type() string {
	return "int"
}

// EditorValue implements the flag.Value interface
type editorValue struct {
	value *string
}

func newEditorValue(p *string) *editorValue {
	*p = defaultEditor
	return &editorValue{p}
}

func (f *editorValue) Set(s string) error {
	if s == "" {
		*f.value = defaultEditor
		return nil
	}
	*f.value = s
	editorSetByFlag = true
	return nil
}

func (f *editorValue) String() string {
	if f.value == nil {
		return ""
	}
	return *f.value
}

func (f *editorValue) Type() string {
	return "string"
}


================================================
FILE: app/cli/cmd/plan_start_helpers.go
================================================
package cmd

import (
	"os"
	"plandex-cli/api"
	"plandex-cli/lib"
	"plandex-cli/term"
	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var (
	// Tier flags
	noAuto    bool
	basicAuto bool
	plusAuto  bool
	semiAuto  bool
	fullAuto  bool

	// Type flags
	dailyModels             bool
	reasoningModels         bool
	strongModels            bool
	ossModels               bool
	cheapModels             bool
	geminiPlannerModels     bool
	o3PlannerModels         bool
	r1PlannerModels         bool
	perplexityPlannerModels bool
	opusPlannerModels       bool
)

func AddNewPlanFlags(cmd *cobra.Command) {
	// Add tier flags
	cmd.Flags().BoolVar(&noAuto, "no-auto", false, shared.AutoModeDescriptions[shared.AutoModeNone])
	cmd.Flags().BoolVar(&basicAuto, "basic", false, shared.AutoModeDescriptions[shared.AutoModeBasic])
	cmd.Flags().BoolVar(&plusAuto, "plus", false, shared.AutoModeDescriptions[shared.AutoModePlus])
	cmd.Flags().BoolVar(&semiAuto, "semi", false, shared.AutoModeDescriptions[shared.AutoModeSemi])
	cmd.Flags().BoolVar(&fullAuto, "full", false, shared.AutoModeDescriptions[shared.AutoModeFull])

	// Add type flags
	cmd.Flags().BoolVar(&dailyModels, "daily", false, shared.DailyDriverModelPack.Description)
	cmd.Flags().BoolVar(&reasoningModels, "reasoning", false, shared.ReasoningModelPack.Description)
	cmd.Flags().BoolVar(&strongModels, "strong", false, shared.StrongModelPack.Description)
	cmd.Flags().BoolVar(&cheapModels, "cheap", false, shared.CheapModelPack.Description)
	cmd.Flags().BoolVar(&ossModels, "oss", false, shared.OSSModelPack.Description)

	cmd.Flags().BoolVar(&geminiPlannerModels, "gemini-planner", false, shared.GeminiPlannerModelPack.Description)
	cmd.Flags().BoolVar(&o3PlannerModels, "o3-planner", false, shared.O3PlannerModelPack.Description)
	cmd.Flags().BoolVar(&r1PlannerModels, "r1-planner", false, shared.R1PlannerModelPack.Description)
	cmd.Flags().BoolVar(&perplexityPlannerModels, "perplexity-planner", false, shared.PerplexityPlannerModelPack.Description)
	cmd.Flags().BoolVar(&opusPlannerModels, "opus-planner", false, shared.OpusPlannerModelPack.Description)
}

func resolveAutoMode(config *shared.PlanConfig) (bool, *shared.PlanConfig) {
	didUpdate, updatedConfig, _ := resolveAutoModeWithArgs(config, false)
	return didUpdate, updatedConfig
}

func resolveAutoModeSilent(config *shared.PlanConfig) (bool, *shared.PlanConfig, func()) {
	return resolveAutoModeWithArgs(config, true)
}

func resolveAutoModeWithArgs(config *shared.PlanConfig, silent bool) (bool, *shared.PlanConfig, func()) {
	currentAutoMode := config.AutoMode
	var toSetAutoMode shared.AutoModeType
	if noAuto {
		toSetAutoMode = shared.AutoModeNone
	} else if basicAuto {
		toSetAutoMode = shared.AutoModeBasic
	} else if plusAuto {
		toSetAutoMode = shared.AutoModePlus
	} else if semiAuto {
		toSetAutoMode = shared.AutoModeSemi
	} else if fullAuto {
		toSetAutoMode = shared.AutoModeFull
	}

	if toSetAutoMode != "" && toSetAutoMode != currentAutoMode {
		if !silent {
			term.StartSpinner("")
		}
		_, updatedConfig := updateConfig([]string{"auto-mode", string(toSetAutoMode)}, config)
		apiErr := api.Client.UpdatePlanConfig(lib.CurrentPlanId, shared.UpdatePlanConfigRequest{
			Config: updatedConfig,
		})
		lib.SetCachedPlanConfig(updatedConfig)
		if !silent {
			term.StopSpinner()
		}

		if apiErr != nil {
			term.OutputErrorAndExit("Error updating config auto-mode: %v", apiErr)
		}

		fn := func() {
			printAutoModeTable(config)
		}

		if !silent {
			fn()
			return true, updatedConfig, fn
		}

		return true, updatedConfig, fn
	}

	return false, config, nil
}

func resolveModelPack() {
	resolveModelPackWithArgs(nil, false)
}

func resolveModelPackSilent(settings *shared.PlanSettings) (*shared.PlanSettings, func()) {
	return resolveModelPackWithArgs(settings, true)
}

func resolveModelPackWithArgs(settings *shared.PlanSettings, silent bool) (*shared.PlanSettings, func()) {

	var originalSettings *shared.PlanSettings
	var apiErr *shared.ApiError
	if settings == nil {
		if !silent {
			term.StartSpinner("")
		}
		originalSettings, apiErr = api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
	} else {
		originalSettings = settings
	}

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting current settings: %v", apiErr)
		return nil, nil
	}

	var packName string

	if ossModels {
		packName = shared.OSSModelPack.Name
	} else if strongModels {
		packName = shared.StrongModelPack.Name
	} else if cheapModels {
		packName = shared.CheapModelPack.Name
	} else if reasoningModels {
		packName = shared.ReasoningModelPack.Name
	} else if dailyModels {
		packName = shared.DailyDriverModelPack.Name
	} else if geminiPlannerModels {
		packName = shared.GeminiPlannerModelPack.Name
	} else if o3PlannerModels {
		packName = shared.O3PlannerModelPack.Name
	} else if r1PlannerModels {
		packName = shared.R1PlannerModelPack.Name
	} else if perplexityPlannerModels {
		packName = shared.PerplexityPlannerModelPack.Name
	} else if opusPlannerModels {
		packName = shared.OpusPlannerModelPack.Name
	}

	if packName != "" && packName != originalSettings.GetModelPack().Name {
		if !silent {
			term.StartSpinner("")
		}
		updatedSettings := updateModelSettings([]string{packName}, originalSettings, "")
		_, apiErr = api.Client.UpdateSettings(lib.CurrentPlanId, lib.CurrentBranch, shared.UpdateSettingsRequest{
			ModelPackName: updatedSettings.ModelPackName,
			ModelPack:     updatedSettings.ModelPack,
		})
		if !silent {
			term.StopSpinner()
		}

		if apiErr != nil {
			term.OutputErrorAndExit("Error setting model pack: %v", apiErr)
			return nil, nil
		}

		fn := func() {
			printModelPackTable(packName)
		}

		if !silent {
			fn()
			return updatedSettings, fn
		}

		return updatedSettings, fn
	} else {
		if !silent {
			term.StopSpinner()
		}
		fn := func() {
			printModelPackTable(originalSettings.GetModelPack().Name)
		}

		if !silent {
			fn()
			return originalSettings, fn
		}

		return originalSettings, fn
	}
}

func printModelPackTable(packName string) {
	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"🧠 Model Pack"})
	table.Append([]string{color.New(color.Bold, term.ColorHiMagenta).Sprint(packName)})
	table.Render()
}

func printAutoModeTable(config *shared.PlanConfig) {
	var contextMode string
	if config.AutoLoadContext {
		contextMode = "auto"
	} else {
		contextMode = "manual"
	}

	var applyMode string
	if config.AutoApply {
		applyMode = "auto"
	} else {
		applyMode = "approve"
	}

	var executionMode string
	if config.AutoExec {
		executionMode = "auto"
	} else if config.CanExec {
		executionMode = "approve"
	} else {
		executionMode = "disabled"
	}

	var commitMode string
	if config.AutoCommit {
		commitMode = "auto"
	} else if config.SkipCommit {
		commitMode = "skip"
	} else {
		commitMode = "manual"
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{
		"🚀 Auto Mode",
		"Context",
		"Apply",
		"Execution",
		"Commits",
	})
	table.Append([]string{
		color.New(color.Bold, term.ColorHiMagenta).Sprint(config.AutoMode),
		contextMode,
		applyMode,
		executionMode,
		commitMode,
	})
	table.Render()

}


================================================
FILE: app/cli/cmd/plans.go
================================================
package cmd

import (
	"context"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"time"

	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/format"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
	"github.com/xlab/treeprint"
)

var archivedOnly bool

func init() {
	RootCmd.AddCommand(plansCmd)
	plansCmd.Flags().BoolVarP(&archivedOnly, "archived", "a", false, "List archived plans")
}

// plansCmd represents the list command
var plansCmd = &cobra.Command{
	Use:     "plans",
	Aliases: []string{"pl"},
	Short:   "List plans",
	Run:     plans,
}

func plans(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MaybeResolveProject()

	if archivedOnly {
		listArchived()
	} else {
		listActive()
	}
}

func listActive() {
	errCh := make(chan error)

	var parentProjectIdsWithPaths [][2]string
	var childProjectIdsWithPaths [][2]string

	go func() {
		res, err := fs.GetParentProjectIdsWithPaths(auth.Current.UserId)

		if err != nil {
			errCh <- fmt.Errorf("error getting parent project ids with paths: %v", err)
			return
		}

		parentProjectIdsWithPaths = res
		errCh <- nil
	}()

	go func() {
		ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
		defer cancel()

		res, err := fs.GetChildProjectIdsWithPaths(ctx, auth.Current.UserId)

		if err != nil {
			log.Println(err.Error())

			if err.Error() == "context timeout" {
				errCh <- nil
				return
			}

			errCh <- fmt.Errorf("error getting child project ids with paths: %v", err)
			return
		}

		childProjectIdsWithPaths = res
		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			term.OutputErrorAndExit("%v", err)
		}
	}

	var projectIds []string

	if lib.CurrentProjectId != "" {
		projectIds = append(projectIds, lib.CurrentProjectId)
	}

	for _, p := range parentProjectIdsWithPaths {
		projectIds = append(projectIds, p[1])
	}
	for _, p := range childProjectIdsWithPaths {
		projectIds = append(projectIds, p[1])
	}

	if len(projectIds) == 0 {
		fmt.Println("🤷‍♂️ No plans")
		fmt.Println()
		term.PrintCmds("", "new")
		return
	}

	term.StartSpinner("")
	plans, apiErr := api.Client.ListPlans(projectIds)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No plans")
		fmt.Println()
		term.PrintCmds("", "new")
		return
	}

	plansByProjectId := make(map[string][]*shared.Plan)
	var currentProjectPlanIds []string
	for _, p := range plans {
		plansByProjectId[p.ProjectId] = append(plansByProjectId[p.ProjectId], p)
		if p.ProjectId == lib.CurrentProjectId {
			currentProjectPlanIds = append(currentProjectPlanIds, p.Id)
		}
	}

	for projectId, plans := range plansByProjectId {
		if projectId != lib.CurrentProjectId {
			// sort non-current-project plans alphabetically
			sort.Slice(plans, func(i, j int) bool {
				return plans[i].Name < plans[j].Name
			})
		}
	}

	// remove paths with no plans from parentProjectIdsWithPaths and childProjectIdsWithPaths
	var parentProjectIdsWithPathsFiltered [][2]string
	for _, p := range parentProjectIdsWithPaths {
		if len(plansByProjectId[p[1]]) > 0 {
			parentProjectIdsWithPathsFiltered = append(parentProjectIdsWithPathsFiltered, p)
		}
	}
	parentProjectIdsWithPaths = parentProjectIdsWithPathsFiltered

	var childProjectIdsWithPathsFiltered [][2]string
	for _, p := range childProjectIdsWithPaths {
		if len(plansByProjectId[p[1]]) > 0 {
			childProjectIdsWithPathsFiltered = append(childProjectIdsWithPathsFiltered, p)
		}
	}
	childProjectIdsWithPaths = childProjectIdsWithPathsFiltered

	var b strings.Builder

	if len(currentProjectPlanIds) > 0 {
		currentBranchNamesByPlanId, err := lib.GetCurrentBranchNamesByPlanId(currentProjectPlanIds)

		if err != nil {
			term.OutputErrorAndExit("Error getting current branches: %v", err)
		}

		currentBranchesByPlanId, apiErr := api.Client.GetCurrentBranchByPlanId(lib.CurrentProjectId, shared.GetCurrentBranchByPlanIdRequest{
			CurrentBranchByPlanId: currentBranchNamesByPlanId,
		})

		if apiErr != nil {
			term.OutputErrorAndExit("Error getting current branches: %v", apiErr)
		}

		table := tablewriter.NewWriter(&b)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"#", "Name", "Updated" /*, "Created" /*"Branches",*/, "Branch", "Context", "Convo"})

		currentProjectPlans := plansByProjectId[lib.CurrentProjectId]
		if len(parentProjectIdsWithPaths) > 0 || len(childProjectIdsWithPaths) > 0 {
			b.WriteString(color.New(color.Bold, term.ColorHiGreen).Sprint("Plans in current directory\n"))
		} else {
			b.WriteString("\n")
		}
		for i, p := range currentProjectPlans {
			num := strconv.Itoa(i + 1)
			if p.Id == lib.CurrentPlanId {
				num = color.New(color.Bold, term.ColorHiGreen).Sprint(num)
			}

			var name string
			if p.Id == lib.CurrentPlanId {
				name = color.New(color.Bold, term.ColorHiGreen).Sprint(p.Name) + fmt.Sprint(" 👈")
			} else {
				name = p.Name
			}

			currentBranch := currentBranchesByPlanId[p.Id]

			row := []string{
				num,
				name,
				format.Time(p.UpdatedAt),
				// format.Time(p.CreatedAt),
				// strconv.Itoa(p.ActiveBranches),
				currentBranch.Name,
				strconv.Itoa(currentBranch.ContextTokens) + " 🪙",
				strconv.Itoa(currentBranch.ConvoTokens) + " 🪙",
			}

			var style []tablewriter.Colors
			if p.Name == lib.CurrentPlanId {
				style = []tablewriter.Colors{
					{tablewriter.FgHiGreenColor, tablewriter.Bold},
				}
			} else {
				style = []tablewriter.Colors{
					{tablewriter.Bold},
				}
			}

			table.Rich(row, style)

		}
		table.Render()

	} else {
		b.WriteString("🤷‍♂️ No plans in current directory\n")
	}

	var addPathToTreeFn func(tree treeprint.Tree, basePath, localPath, projectId string, isParent bool)
	addPathToTreeFn = func(tree treeprint.Tree, basePath, localPath, projectId string, isParent bool) {
		var base string
		var tail string
		split := strings.Split(localPath, string(os.PathSeparator))

		var baseBranch treeprint.Tree
		for _, part := range split {
			base = filepath.Join(base, part)
			tail = strings.TrimPrefix(localPath, base+string(os.PathSeparator))

			var searchBranch string
			if isParent {
				baseFull := filepath.Join(fs.HomeDir, basePath, base)
				baseRel, _ := filepath.Rel(fs.Cwd, baseFull)
				searchBranch = fmt.Sprintf("%s (%s)", base, baseRel)

				// 	log.Println("Project root:", fs.Cwd)
				// 	log.Println("searchBranch:", searchBranch)
				// 	log.Println("base:", base)
				// 	log.Println("tail:", tail)
				// 	log.Println("basePath:", basePath)
				// 	log.Println("baseFull:", baseFull)
				// 	log.Println("baseRel:", baseRel)
			} else {
				searchBranch = base
			}

			baseBranch = tree.FindByValue(searchBranch)
			if baseBranch != nil {
				addPathToTreeFn(baseBranch, filepath.Join(basePath, base), tail, projectId, isParent)
				return
			}
		}

		if baseBranch == nil {
			label := localPath
			if isParent {
				pathFull := filepath.Join(fs.HomeDir, basePath, localPath)
				pathRel, _ := filepath.Rel(fs.Cwd, pathFull)
				label = fmt.Sprintf("%s (%s)", localPath, pathRel)

			}

			branch := tree.AddBranch(label)
			plans := plansByProjectId[projectId]

			for _, p := range plans {
				branch.AddNode(color.New(term.ColorHiCyan).Sprint(p.Name))
			}
		}
	}

	var c color.Attribute
	if term.IsDarkBg {
		c = color.FgWhite
	} else {
		c = color.FgBlack
	}

	if len(parentProjectIdsWithPaths) > 0 {
		b.WriteString("\n")

		b.WriteString(color.New(color.Bold).Sprint("Plans in parent directories\n"))
		b.WriteString(color.New(c).Sprint("cd into a directory to work on a plan in that directory\n"))
		parentTree := treeprint.NewWithRoot("~")

		for i := len(parentProjectIdsWithPaths) - 1; i >= 0; i-- {
			p := parentProjectIdsWithPaths[i]

			rel, err := filepath.Rel(fs.HomeDir, p[0])

			if err != nil {
				term.OutputErrorAndExit("Error getting relative path: %v", err)
			}

			addPathToTreeFn(parentTree, "", rel, p[1], true)
		}
		b.WriteString(parentTree.String())
	}

	if len(childProjectIdsWithPaths) > 0 {
		b.WriteString("\n")
		b.WriteString(color.New(color.Bold).Sprint("Plans in child directories\n"))
		b.WriteString(color.New(c).Sprint("cd into a directory to work on a plan in that directory\n"))
		childTree := treeprint.New()
		for _, p := range childProjectIdsWithPaths {
			rel, err := filepath.Rel(fs.Cwd, p[0])

			if err != nil {
				term.OutputErrorAndExit("Error getting relative path: %v", err)
			}

			addPathToTreeFn(childTree, "", rel, p[1], false)
		}
		b.WriteString(childTree.String())
	} else {
		b.WriteString("\n")
	}

	term.PageOutput(b.String())

	fmt.Println()
	if len(currentProjectPlanIds) > 0 {
		term.PrintCmds("", "new", "cd", "delete-plan", "plans --archived", "archive")
	} else {
		term.PrintCmds("", "new", "plans --archived")
	}
}

func listArchived() {
	var projectIds []string

	if lib.CurrentProjectId != "" {
		projectIds = append(projectIds, lib.CurrentProjectId)
	}

	term.StartSpinner("")
	plans, apiErr := api.Client.ListArchivedPlans(projectIds)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No archived plans")
		fmt.Println()
		term.PrintCmds("", "archive")
		return
	}

	var b strings.Builder
	table := tablewriter.NewWriter(&b)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{"#", "Name", "Updated"})

	for i, p := range plans {
		num := strconv.Itoa(i + 1)
		if p.Id == lib.CurrentPlanId {
			num = color.New(color.Bold, term.ColorHiGreen).Sprint(num)
		}

		row := []string{
			num,
			p.Name,
			format.Time(p.UpdatedAt),
		}

		var style []tablewriter.Colors
		if p.Name == lib.CurrentPlanId {
			style = []tablewriter.Colors{
				{tablewriter.FgHiGreenColor, tablewriter.Bold},
			}
		} else {
			style = []tablewriter.Colors{
				{tablewriter.Bold},
			}
		}

		table.Rich(row, style)

	}
	table.Render()

	term.PageOutput(b.String())

	fmt.Println()
	term.PrintCmds("", "unarchive")
}


================================================
FILE: app/cli/cmd/ps.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/format"
	"plandex-cli/lib"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var psCmd = &cobra.Command{
	Use:   "ps",
	Short: "List plans with active or recently finished streams",
	Run:   ps,
}

func init() {
	RootCmd.AddCommand(psCmd)
}

func ps(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	res, apiErr := api.Client.ListPlansRunning([]string{lib.CurrentProjectId}, true)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting running plans: %v", apiErr)
		return
	}

	if len(res.Branches) == 0 {
		fmt.Println("🤷‍♂️ No active or recently finished streams")
		return
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{"Pid", "Plan", "Branch", "Started", "Status"})

	for _, b := range res.Branches {
		id := res.StreamIdByBranchId[b.Id]
		plan := res.PlansById[b.PlanId]

		status := "Active"
		finishedAt := res.StreamFinishedAtByBranchId[b.Id]
		switch b.Status {
		case shared.PlanStatusFinished:
			status = "Finished " + format.Time(finishedAt)
		case shared.PlanStatusError:
			status = "Error " + format.Time(finishedAt)
		case shared.PlanStatusStopped:
			status = "Stopped " + format.Time(finishedAt)
		case shared.PlanStatusMissingFile:
			status = "Missing file"
		}

		row := []string{
			id[:4],
			plan.Name,
			b.Name,
			format.Time(res.StreamStartedAtByBranchId[b.Id]),
			status,
		}

		var style []tablewriter.Colors
		if b.Name == lib.CurrentPlanId {
			style = []tablewriter.Colors{
				{tablewriter.FgGreenColor, tablewriter.Bold},
			}
		} else {
			style = []tablewriter.Colors{
				{tablewriter.Bold},
			}
		}

		table.Rich(row, style)

	}
	table.Render()

	fmt.Println()
	term.PrintCmds("", "connect", "stop")

}


================================================
FILE: app/cli/cmd/reject.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"sort"

	"github.com/plandex-ai/survey/v2"
	"github.com/spf13/cobra"
)

var rejectAll bool

func init() {
	RootCmd.AddCommand(rejectCmd)

	rejectCmd.Flags().BoolVarP(&rejectAll, "all", "a", false, "Reject all pending changes")
}

var rejectCmd = &cobra.Command{
	Use:     "reject [files...]",
	Aliases: []string{"rj"},
	Short:   "Reject pending changes",
	Run:     reject,
}

func reject(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")

	currentPlanState, apiErr := api.Client.GetCurrentPlanState(lib.CurrentPlanId, lib.CurrentBranch)

	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting current plan state: %v", apiErr)
	}

	currentFiles := currentPlanState.CurrentPlanFiles.Files

	if len(currentFiles) == 0 {
		term.StopSpinner()
		term.OutputErrorAndExit("No pending changes to reject")
	}

	if rejectAll {
		numToReject := len(currentFiles)
		suffix := ""
		if numToReject > 1 {
			suffix = "s"
		}

		apiErr := api.Client.RejectAllChanges(lib.CurrentPlanId, lib.CurrentBranch)

		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Error rejecting all changes: %v", apiErr)
		}

		term.StopSpinner()
		fmt.Printf("✅ Rejected changes to %d file%s\n", numToReject, suffix)

		sortedFiles := make([]string, 0, len(currentFiles))
		for file := range currentFiles {
			sortedFiles = append(sortedFiles, file)
		}
		sort.Strings(sortedFiles)

		for _, file := range sortedFiles {
			fmt.Printf("• 📄 %s\n", file)
		}

		return
	}

	if len(args) > 0 {
		for _, path := range args {
			if _, ok := currentFiles[path]; !ok {
				term.StopSpinner()
				term.OutputErrorAndExit("File %s not found in plan or has no changes to reject", path)
			}
		}

		numToReject := len(args)
		suffix := ""
		if numToReject > 1 {
			suffix = "s"
		}

		apiErr = api.Client.RejectFiles(lib.CurrentPlanId, lib.CurrentBranch, args)
		term.StopSpinner()

		if apiErr != nil {
			term.OutputErrorAndExit("Error rejecting changes: %v", apiErr)
		}

		fmt.Printf("✅ Rejected changes to %d file%s\n", numToReject, suffix)

		sortedFiles := append([]string{}, args...)
		sort.Strings(sortedFiles)

		for _, file := range sortedFiles {
			fmt.Printf("• 📄 %s\n", file)
		}

		return
	}

	// No args provided - use survey multiselect
	term.StopSpinner()

	pathsToSort := make([]string, 0, len(currentFiles))
	for path := range currentFiles {
		pathsToSort = append(pathsToSort, path)
	}
	sort.Strings(pathsToSort)

	var selectedFiles []string
	prompt := &survey.MultiSelect{
		Message: "Select files to reject:",
		Options: pathsToSort,
	}

	err := survey.AskOne(prompt, &selectedFiles)
	if err != nil {
		term.OutputErrorAndExit("Error getting file selection: %v", err)
	}

	if len(selectedFiles) == 0 {
		fmt.Println("No files selected")
		return
	}

	term.StartSpinner("")
	apiErr = api.Client.RejectFiles(lib.CurrentPlanId, lib.CurrentBranch, selectedFiles)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error rejecting changes: %v", apiErr)
	}

	suffix := ""
	if len(selectedFiles) > 1 {
		suffix = "s"
	}
	fmt.Printf("✅ Rejected changes to %d file%s\n", len(selectedFiles), suffix)

	sortedFiles := append([]string{}, selectedFiles...)
	sort.Strings(sortedFiles)

	for _, file := range sortedFiles {
		fmt.Printf("• 📄 %s\n", file)
	}
}


================================================
FILE: app/cli/cmd/rename.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var renameCmd = &cobra.Command{
	Use:   "rename [new-name]",
	Short: "Rename the current plan",
	Args:  cobra.MaximumNArgs(1),
	Run:   rename,
}

func init() {
	RootCmd.AddCommand(renameCmd)
}

func rename(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	var newName string
	if len(args) > 0 {
		newName = args[0]
	} else {
		var err error
		newName, err = term.GetRequiredUserStringInput("New name:")
		if err != nil {
			term.OutputErrorAndExit("Error reading new name: %v", err)
		}
	}

	if newName == "" {
		fmt.Println("🤷‍♂️ No new name provided")
		return
	}

	term.StartSpinner("")
	err := api.Client.RenamePlan(lib.CurrentPlanId, newName)
	term.StopSpinner()

	if err != nil {
		term.OutputErrorAndExit("Error renaming plan: %v", err)
	}

	fmt.Printf("✅ Plan renamed to %s\n", color.New(color.Bold, term.ColorHiGreen).Sprint(newName))
}


================================================
FILE: app/cli/cmd/repl.go
================================================
package cmd

import (
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/version"
	shared "plandex-shared"
	"regexp"
	"sort"
	"strings"
	"unicode"

	"github.com/fatih/color"
	"github.com/google/uuid"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"

	"github.com/plandex-ai/go-prompt"
	pstrings "github.com/plandex-ai/go-prompt/strings"

	"github.com/lithammer/fuzzysearch/fuzzy"
)

var replCmd = &cobra.Command{
	Use:   "repl",
	Short: "Start interactive Plandex REPL",
	Run:   runRepl,
}

var cliSuggestions []prompt.Suggest
var projectPaths *types.ProjectPaths
var currentPrompt *prompt.Prompt

var replConfig *shared.PlanConfig

var sessionId string

func init() {
	RootCmd.AddCommand(replCmd)

	replCmd.Flags().BoolP("chat", "c", false, "Start in chat mode")
	replCmd.Flags().BoolP("tell", "t", false, "Start in tell mode")

	AddNewPlanFlags(replCmd)

	for _, config := range term.CliCommands {
		if config.Repl {
			desc := config.Desc
			if config.Alias != "" {
				desc = fmt.Sprintf("(\\%s) %s", config.Alias, desc)
			}
			cliSuggestions = append(cliSuggestions, prompt.Suggest{Text: "\\" + config.Cmd, Description: desc})
		}
	}
}

func setReplConfig() {
	replConfig = lib.MustGetCurrentPlanConfig()
}

func runRepl(cmd *cobra.Command, args []string) {
	sessionId = uuid.New().String()

	term.SetIsRepl(true)

	auth.MustResolveAuthWithOrg()
	lib.MustResolveOrCreateProject()

	term.StartSpinner("")
	lib.LoadState()

	chatFlag, err := cmd.Flags().GetBool("chat")
	if err != nil {
		term.OutputErrorAndExit("Error getting chat flag: %v", err)
	}

	tellFlag, err := cmd.Flags().GetBool("tell")
	if err != nil {
		term.OutputErrorAndExit("Error getting tell flag: %v", err)
	}

	if chatFlag && tellFlag {
		term.OutputErrorAndExit("Cannot specify both --chat and --tell flags")
	}

	if chatFlag {
		lib.CurrentReplState.Mode = lib.ReplModeChat
		lib.WriteState()
	} else if tellFlag {
		lib.CurrentReplState.Mode = lib.ReplModeTell
		lib.WriteState()
	}

	afterNew := false

	if lib.CurrentPlanId == "" {
		os.Setenv("PLANDEX_DISABLE_SUGGESTIONS", "1")
		args := []string{}

		if noAuto {
			args = append(args, "--no-auto")
		} else if basicAuto {
			args = append(args, "--basic")
		} else if plusAuto {
			args = append(args, "--plus")
		} else if semiAuto {
			args = append(args, "--semi")
		} else if fullAuto {
			args = append(args, "--full")
		}

		if ossModels {
			args = append(args, "--oss")
		} else if strongModels {
			args = append(args, "--strong")
		} else if cheapModels {
			args = append(args, "--cheap")
		} else if dailyModels {
			args = append(args, "--daily")
		} else if reasoningModels {
			args = append(args, "--reasoning")
		} else if geminiPlannerModels {
			args = append(args, "--gemini-planner")
		} else if o3PlannerModels {
			args = append(args, "--o3-planner")
		} else if r1PlannerModels {
			args = append(args, "--r1-planner")
		} else if perplexityPlannerModels {
			args = append(args, "--perplexity-planner")
		} else if opusPlannerModels {
			args = append(args, "--opus-planner")
		}

		newCmd.Run(newCmd, args)
		os.Setenv("PLANDEX_DISABLE_SUGGESTIONS", "")
		afterNew = true
	}

	setReplConfig()

	lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode)

	projectPaths, err = fs.GetProjectPaths(fs.Cwd)
	if err != nil {
		color.New(term.ColorHiRed).Printf("Error getting project paths: %v\n", err)
	}

	settings, apiErr := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
	if apiErr != nil {
		term.OutputErrorAndExit("Error getting settings: %v", apiErr.Msg)
	}

	var printAutoFn func()
	var printModelFn func()
	if !afterNew {
		var didUpdateConfig bool
		var updatedConfig *shared.PlanConfig
		var updatedSettings *shared.PlanSettings
		didUpdateConfig, updatedConfig, printAutoFn = resolveAutoModeSilent(replConfig)
		updatedSettings, printModelFn = resolveModelPackSilent(settings)

		if didUpdateConfig {
			loadMapIfNeeded(replConfig, updatedConfig)
			removeMapIfNeeded(replConfig, updatedConfig)

			if updatedConfig != nil {
				replConfig = updatedConfig
			}
		}

		if updatedSettings != nil {
			settings = updatedSettings
		}
	}

	replWelcome(replWelcomeParams{
		afterNew:     afterNew,
		isHelp:       false,
		printAutoFn:  printAutoFn,
		printModelFn: printModelFn,
		config:       replConfig,
		packName:     settings.GetModelPack().Name,
	})

	var p *prompt.Prompt
	p = prompt.New(
		func(in string) { executor(in, p) },
		prompt.WithPrefixCallback(func() string {
			// Get last part of current working directory
			// cwd := fs.Cwd
			// dirName := filepath.Base(cwd)

			// Build prefix with directory and mode indicator
			var modeIcon string
			if lib.CurrentReplState.Mode == lib.ReplModeTell {
				modeIcon = "⚡️"
				if replConfig.AutoApply && replConfig.AutoExec {
					modeIcon += "❗️" // warning reminder for auto apply and auto exec
				}
			} else if lib.CurrentReplState.Mode == lib.ReplModeChat {
				modeIcon = "💬"
			}
			return fmt.Sprintf("%s ", modeIcon)
		}),
		prompt.WithTitle("Plandex "+version.Version),
		prompt.WithSelectedSuggestionBGColor(prompt.LightGray),
		prompt.WithSuggestionBGColor(prompt.DarkGray),
		prompt.WithCompletionOnDown(),
		prompt.WithCompleter(completer),
		prompt.WithExecuteOnEnterCallback(executeOnEnter),
		prompt.WithHistory(lib.GetHistory()),
	)
	currentPrompt = p
	p.Run()
}

func getSuggestions() []prompt.Suggest {
	suggestions := []prompt.Suggest{}

	if lib.CurrentReplState.IsMulti {
		suggestions = append(suggestions, []prompt.Suggest{
			{Text: "\\send", Description: "(\\s) Send the current prompt"},
			{Text: "\\multi", Description: "(\\m) Turn multi-line mode off"},
			{Text: "\\run", Description: "(\\r) Run a file through tell/chat based on current mode"},
			{Text: "\\quit", Description: "(\\q) Exit the REPL"},
		}...)

	}

	if lib.CurrentReplState.Mode == lib.ReplModeTell {
		suggestions = append(suggestions, []prompt.Suggest{
			{Text: "\\chat", Description: "(\\ch) Switch to 'chat' mode to have a conversation without making changes"},
		}...)
	} else if lib.CurrentReplState.Mode == lib.ReplModeChat {
		suggestions = append(suggestions, []prompt.Suggest{
			{Text: "\\tell", Description: "(\\t) Switch to 'tell' mode for implementation"},
		}...)
	}

	if !lib.CurrentReplState.IsMulti {
		suggestions = append(suggestions, []prompt.Suggest{
			{Text: "\\multi", Description: "(\\m) Turn multi-line mode on"},
			{Text: "\\run", Description: "(\\r) Run a file through tell/chat based on current mode"},
			{Text: "\\quit", Description: "(\\q) Exit the REPL"},
		}...)
	}

	// Add help command suggestion
	suggestions = append(suggestions, prompt.Suggest{Text: "\\help", Description: "(\\h) REPL info and list of commands"})
	suggestions = append(suggestions, cliSuggestions...)

	for path := range projectPaths.ActivePaths {
		if path == "." {
			continue
		}

		isDir := projectPaths.ActiveDirs[path]

		if isDir {
			path += "/"
		}

		suggestions = append(suggestions, prompt.Suggest{Text: "@" + path})

		loadArgs := path
		if isDir {
			loadArgs += " -r"
		}
		suggestions = append(suggestions, prompt.Suggest{Text: "\\load " + loadArgs})

		if isDir {
			loadArgs = path
			loadArgs += " --map"
			suggestions = append(suggestions, prompt.Suggest{Text: "\\load " + loadArgs})

			loadArgs = path
			loadArgs += " --tree"
			suggestions = append(suggestions, prompt.Suggest{Text: "\\load " + loadArgs})
		}

		if filepath.Ext(path) == ".md" || filepath.Ext(path) == ".txt" {
			suggestions = append(suggestions, prompt.Suggest{Text: "\\run " + path})
		}
	}

	return suggestions
}

func executeOnEnter(p *prompt.Prompt, indentSize int) (int, bool) {
	input := p.Buffer().Text()
	cmd, _ := parseCommand(input)

	if cmd != "" {
		return 0, true
	}

	if lib.CurrentReplState.IsMulti {
		return 0, false
	}

	return 0, true
}

const cancelOpt = "Cancel"

func executor(in string, p *prompt.Prompt) {
	defer lib.WriteHistory(in)

	in = strings.TrimSpace(in)
	lines := strings.Split(in, "\n")
	lastLine := lines[len(lines)-1]
	lastLine = strings.TrimSpace(lastLine)

	trimmedInput := strings.TrimSpace(in)
	if trimmedInput == "" {
		return
	}
	// condense whitespace
	condensedInput := strings.Join(strings.Fields(trimmedInput), " ")

	// Handle plandex/pdx command prefix
	if strings.HasPrefix(lastLine, "plandex ") || strings.HasPrefix(lastLine, "pdx ") {
		fmt.Println()
		parts := strings.Fields(lastLine)
		if len(parts) > 1 {
			args := parts[1:] // Skip the "plandex" or "pdx" command
			_, err := lib.ExecPlandexCommandWithParams(args, lib.ExecPlandexCommandParams{
				SessionId: sessionId,
			})
			if err != nil {
				color.New(term.ColorHiRed).Printf("Error executing command: %v\n", err)
			}
		}
		fmt.Println()
		return
	}

	// Find the last \ or @ in the last line
	lastBackslashIndex := strings.LastIndex(lastLine, "\\")
	lastAtIndex := strings.LastIndex(lastLine, "@")

	var preservedBuffer string
	if len(lines) > 1 {
		preservedBuffer = strings.Join(lines[:len(lines)-1], "\n") + "\n"
	}

	suggestions, _, _ := completer(prompt.Document{Text: in})

	// Handle file references
	if lastAtIndex != -1 && lastAtIndex > lastBackslashIndex {
		paths := strings.Split(lastLine, "@")
		numPaths := len(paths)

		filteredPaths := []string{}

		for i, path := range paths {
			p := strings.TrimSpace(path)
			if i == 0 {
				// text before the @
				preservedBuffer += p + " "
				continue
			}

			if (p == "" || !projectPaths.ActivePaths[p]) && len(suggestions) > 0 && i == numPaths-1 {
				p = strings.Replace(suggestions[0].Text, "@", "", 1)
				filteredPaths = append(filteredPaths, p)
			} else if projectPaths.ActivePaths[p] {
				filteredPaths = append(filteredPaths, p)
			}
		}

		if len(filteredPaths) > 0 {
			args := []string{"load"}
			args = append(args, filteredPaths...)
			args = append(args, "-r")
			fmt.Println()
			_, err := lib.ExecPlandexCommandWithParams(args, lib.ExecPlandexCommandParams{
				SessionId: sessionId,
			})
			if err != nil {
				color.New(term.ColorHiRed).Printf("Error executing command: %v\n", err)
			}
			fmt.Println()
			if preservedBuffer != "" {
				p.InsertTextMoveCursor(preservedBuffer, true)
			}
			return
		}
	}

	// Handle commands
	if lastBackslashIndex != -1 {
		cmdString := strings.TrimSpace(lastLine[lastBackslashIndex+1:])
		if cmdString == "" {
			return
		}
		res := execWithInput(execWithInputParams{
			cmdString:          cmdString,
			in:                 condensedInput,
			lastBackslashIndex: lastBackslashIndex,
			preservedBuffer:    preservedBuffer,
			p:                  p,
			lastLine:           lastLine,
			condensedInput:     condensedInput,
			trimmedInput:       trimmedInput,
			lines:              lines,
			suggestions:        suggestions,
		})
		if res.shouldReturn {
			return
		}
		condensedInput = res.condensedInput
		trimmedInput = res.trimmedInput
	} else if len(lines) == 1 {
		// Check for likely accidental command inputs (with no backslash) and confirm with user
		var allCommands []string
		for replCmd := range lib.ReplCmdAliases {
			allCommands = append(allCommands, replCmd)
		}
		for _, config := range term.CliCommands {
			if config.Repl {
				allCommands = append(allCommands, config.Cmd)
			}
		}

		// Only suggest commands if they're close enough matches
		maybeCmds := findSimilarCommands(lastLine, allCommands)

		if len(maybeCmds) > 0 {
			res := suggestCmds(maybeCmds, getPromptOpt(lastLine))
			if res.shouldReturn {
				return
			}
			matchedCmd := res.matchedCmd
			if matchedCmd != "" {
				res := execWithInput(execWithInputParams{
					cmdString:          matchedCmd,
					in:                 condensedInput,
					lastBackslashIndex: lastBackslashIndex,
					preservedBuffer:    preservedBuffer,
					p:                  p,
					lastLine:           lastLine,
					condensedInput:     condensedInput,
					trimmedInput:       trimmedInput,
					lines:              lines,
					suggestions:        suggestions,
				})
				if res.shouldReturn {
					return
				}
				condensedInput = res.condensedInput
				trimmedInput = res.trimmedInput
			}
		}
	}

	// Handle non-command input based on mode
	if lib.CurrentReplState.Mode == lib.ReplModeTell {
		fmt.Println()
		args := []string{"tell", trimmedInput}
		var err error
		_, err = lib.ExecPlandexCommandWithParams(args, lib.ExecPlandexCommandParams{
			SessionId: sessionId,
		})
		if err != nil {
			color.New(term.ColorHiRed).Printf("Error executing tell: %v\n", err)
		}
	} else if lib.CurrentReplState.Mode == lib.ReplModeChat {
		fmt.Println()
		args := []string{"chat", trimmedInput}
		output, err := lib.ExecPlandexCommandWithParams(args, lib.ExecPlandexCommandParams{
			SessionId: sessionId,
		})
		if err != nil {
			color.New(term.ColorHiRed).Printf("Error executing chat: %v\n", err)
		}

		replacer := strings.NewReplacer("'", "", "\"", "", "*", "", "`", "", "_", "")
		output = replacer.Replace(output)

		rx := regexp.MustCompile(`(?i)(switch|start|continue|begin|change|chang|move|proceed|go|transition)(ing)?( to | with | into )?(tell|implementation|coding|development)( mode)?`)

		if rx.MatchString(output) {
			fmt.Println()
			res, err := term.ConfirmYesNo("Switch to tell mode for implementation?")
			if err != nil {
				color.New(term.ColorHiRed).Printf("Error confirming yes/no: %v\n", err)
			}
			if res {
				lib.CurrentReplState.Mode = lib.ReplModeTell
				lib.WriteState()
				fmt.Println()
				color.New(color.BgMagenta, color.FgHiWhite, color.Bold).Println(" ⚡️ Tell mode is enabled ")
				fmt.Println()
				fmt.Println("Now that you're in tell mode, you can either begin the implementation based on the conversation so far, or you can send another prompt to begin the implementation with additional information or instructions.")
				fmt.Println()
				beginImplOpt := "Begin implementation"
				anotherPromptOpt := "Send another prompt"
				sel, err := term.SelectFromList("What would you like to do?", []string{beginImplOpt, anotherPromptOpt})
				if err != nil {
					color.New(term.ColorHiRed).Printf("Error selecting from list: %v\n", err)
				}
				if sel == beginImplOpt {
					fmt.Println()
					args := []string{"tell", "--from-chat"}
					_, err := lib.ExecPlandexCommandWithParams(args, lib.ExecPlandexCommandParams{
						SessionId: sessionId,
					})
					if err != nil {
						color.New(term.ColorHiRed).Printf("Error executing tell: %v\n", err)
					}
				}
			}
		}
	}
	fmt.Println()
}

func completer(in prompt.Document) ([]prompt.Suggest, pstrings.RuneNumber, pstrings.RuneNumber) {
	// Don't show suggestions if we're navigating history
	if currentPrompt.IsNavigatingHistory() {
		return []prompt.Suggest{}, 0, 0
	}

	endIndex := in.CurrentRuneIndex()

	lines := strings.Split(in.Text, "\n")
	currentLineNum := strings.Count(in.TextBeforeCursor(), "\n")

	// Don't show suggestions if we're not on the last line
	if currentLineNum < len(lines)-1 {
		return []prompt.Suggest{}, 0, 0
	}

	lastLine := lines[len(lines)-1]
	if strings.TrimSpace(lastLine) == "" && len(lines) > 1 {
		lastLine = lines[len(lines)-2]
	}

	// Handle plandex/pdx command prefix
	if strings.HasPrefix(lastLine, "plandex ") || strings.HasPrefix(lastLine, "pdx ") {
		parts := strings.Fields(lastLine)
		var prefix string
		if len(parts) > 1 {
			prefix = parts[len(parts)-1]
		}
		startIndex := endIndex - pstrings.RuneNumber(len(prefix))

		suggestions := []prompt.Suggest{}
		for _, config := range term.CliCommands {
			suggestions = append(suggestions, prompt.Suggest{
				Text:        config.Cmd,
				Description: config.Desc,
			})
		}

		filtered := prompt.FilterFuzzy(suggestions, prefix, true)
		return filtered, startIndex, endIndex
	}

	// Find the last valid \ or @ in the current line
	lastBackslashIndex := -1
	lastAtIndex := -1

	// Helper function to check if character at index is valid (start of line or after space)
	isValidPosition := func(str string, index int) bool {
		if index <= 0 {
			return true // Start of line
		}
		return unicode.IsSpace(rune(str[index-1])) // After whitespace
	}

	// Find last valid backslash
	for i := len(lastLine) - 1; i >= 0; i-- {
		if lastLine[i] == '\\' && isValidPosition(lastLine, i) {
			lastBackslashIndex = i
			break
		}
	}

	// Find last valid @
	for i := len(lastLine) - 1; i >= 0; i-- {
		if lastLine[i] == '@' && isValidPosition(lastLine, i) {
			lastAtIndex = i
			break
		}
	}

	var w string
	var startIndex pstrings.RuneNumber

	if lastBackslashIndex == -1 && lastAtIndex == -1 {
		return []prompt.Suggest{}, 0, 0
	}

	// Use the rightmost special character
	if lastBackslashIndex > lastAtIndex {
		// Get everything after the last backslash
		w = lastLine[lastBackslashIndex:]
		startIndex = endIndex - pstrings.RuneNumber(len(w))
	} else if lastAtIndex != -1 {
		// Get everything after the last @
		w = lastLine[lastAtIndex:]
		startIndex = endIndex - pstrings.RuneNumber(len(w))
	}

	// Verify this is at the end of the line (allowing for trailing spaces)
	if !strings.HasSuffix(strings.TrimSpace(lastLine), strings.TrimSpace(w)) {
		return []prompt.Suggest{}, 0, 0
	}

	wTrimmed := strings.TrimSpace(strings.TrimPrefix(w, "\\"))
	parts := strings.Split(wTrimmed, " ")
	wCmd := parts[0]

	// For commands, verify it starts with an actual command
	if strings.HasPrefix(w, "\\") {
		isValidCommand := false
		for _, config := range term.CliCommands {
			if !config.Repl {
				continue
			}
			if strings.HasPrefix(config.Cmd, wCmd) ||
				(config.Alias != "" && strings.HasPrefix(config.Alias, wCmd)) {
				isValidCommand = true
				break
			}
		}
		// Also check built-in REPL commands
		if strings.HasPrefix("quit", wCmd) ||
			strings.HasPrefix("multi", wCmd) ||
			strings.HasPrefix("tell", wCmd) ||
			strings.HasPrefix("chat", wCmd) ||
			strings.HasPrefix("send", wCmd) ||
			strings.HasPrefix("run", wCmd) {
			isValidCommand = true
		}
		if !isValidCommand && wCmd != "" {
			return []prompt.Suggest{}, 0, 0
		}
	}

	fuzzySuggestions := prompt.FilterFuzzy(getSuggestions(), w, true)
	prefixMatches := prompt.FilterHasPrefix(getSuggestions(), w, true)

	runFilteredFuzzy := []prompt.Suggest{}
	runFilteredPrefixMatches := []prompt.Suggest{}
	for _, s := range fuzzySuggestions {
		if strings.HasPrefix(s.Text, "\\run ") {
			if wCmd == "run" {
				runFilteredFuzzy = append(runFilteredFuzzy, s)
			}
		} else {
			runFilteredFuzzy = append(runFilteredFuzzy, s)
		}
	}
	for _, s := range prefixMatches {
		if strings.HasPrefix(s.Text, "\\run ") {
			if wCmd == "run" {
				runFilteredPrefixMatches = append(runFilteredPrefixMatches, s)
			}
		} else {
			runFilteredPrefixMatches = append(runFilteredPrefixMatches, s)
		}
	}
	fuzzySuggestions = runFilteredFuzzy
	prefixMatches = runFilteredPrefixMatches

	loadFilteredFuzzy := []prompt.Suggest{}
	loadFilteredPrefixMatches := []prompt.Suggest{}
	for _, s := range fuzzySuggestions {
		if strings.HasPrefix(s.Text, "\\load ") {
			if wCmd == "load" {
				loadFilteredFuzzy = append(loadFilteredFuzzy, s)
			}
		} else {
			loadFilteredFuzzy = append(loadFilteredFuzzy, s)
		}
	}
	for _, s := range prefixMatches {
		if strings.HasPrefix(s.Text, "\\load ") {
			if wCmd == "load" {
				loadFilteredPrefixMatches = append(loadFilteredPrefixMatches, s)
			}
		} else {
			loadFilteredPrefixMatches = append(loadFilteredPrefixMatches, s)
		}
	}
	fuzzySuggestions = loadFilteredFuzzy
	prefixMatches = loadFilteredPrefixMatches

	if strings.TrimSpace(w) != "\\" {
		sort.Slice(prefixMatches, func(i, j int) bool {
			iTxt := prefixMatches[i].Text
			jTxt := prefixMatches[j].Text
			if iTxt == "\\chat" || iTxt == "\\tell" || iTxt == "\\multi" || iTxt == "\\quit" || iTxt == "\\send" || iTxt == "\\run" {
				return true
			}
			if jTxt == "\\chat" || jTxt == "\\tell" || jTxt == "\\multi" || jTxt == "\\quit" || jTxt == "\\send" || jTxt == "\\run" {
				return false
			}
			return prefixMatches[i].Text < prefixMatches[j].Text
		})
	}

	if len(prefixMatches) > 0 {
		// Remove prefix matches from fuzzy results to avoid duplicates
		prefixMatchSet := make(map[string]bool)
		for _, s := range prefixMatches {
			prefixMatchSet[s.Text] = true
		}

		nonPrefixFuzzy := make([]prompt.Suggest, 0)
		for _, s := range fuzzySuggestions {
			if !prefixMatchSet[s.Text] {
				nonPrefixFuzzy = append(nonPrefixFuzzy, s)
			}
		}

		fuzzySuggestions = append(prefixMatches, nonPrefixFuzzy...)
	}

	var aliasMatch string

	if lib.ReplCmdAliases[wTrimmed] != "" {
		aliasMatch = "\\" + lib.ReplCmdAliases[wTrimmed]
	} else {
		for _, s := range term.CliCommands {
			if s.Alias == wTrimmed {
				aliasMatch = "\\" + s.Cmd
				break
			}
		}
	}

	if aliasMatch != "" {
		// put the suggestion with the alias match at the beginning
		var matched prompt.Suggest
		found := false
		for _, s := range fuzzySuggestions {
			if s.Text == aliasMatch {
				matched = s
				found = true
				break
			}
		}
		if found {
			newSuggestions := []prompt.Suggest{}
			newSuggestions = append(newSuggestions, matched)
			for _, s := range fuzzySuggestions {
				if s.Text != aliasMatch {
					newSuggestions = append(newSuggestions, s)
				}
			}
			fuzzySuggestions = newSuggestions
		}
	}

	return fuzzySuggestions, startIndex, endIndex
}

type replWelcomeParams struct {
	afterNew     bool
	isHelp       bool
	printAutoFn  func()
	printModelFn func()
	packName     string
	config       *shared.PlanConfig
}

func replWelcome(params replWelcomeParams) {
	// print REPL welcome message and basic info
	// have to make these requests serially in case re-authentication is needed

	afterNew := params.afterNew
	isHelp := params.isHelp
	printAutoFn := params.printAutoFn
	printModelFn := params.printModelFn
	packName := params.packName

	plan, apiErr := api.Client.GetPlan(lib.CurrentPlanId)
	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plan: %v", apiErr.Msg)
	}

	config := params.config
	if config == nil {
		config, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
		if apiErr != nil {
			term.OutputErrorAndExit("Error getting plan config: %v", apiErr.Msg)
		}
	}

	currentBranchesByPlanId, err := api.Client.GetCurrentBranchByPlanId(lib.CurrentProjectId, shared.GetCurrentBranchByPlanIdRequest{
		CurrentBranchByPlanId: map[string]string{
			lib.CurrentPlanId: lib.CurrentBranch,
		},
	})

	if err != nil {
		term.OutputErrorAndExit("Error getting current branches: %v", err)
	}

	term.StopSpinner()

	if !afterNew {
		fmt.Println()
	}

	color.New(color.FgHiWhite, color.BgBlue, color.Bold).Print(" 👋 Welcome to Plandex ")

	versionStr := version.Version
	if versionStr != "development" {
		color.New(color.FgHiWhite, color.BgHiBlack).Printf(" v%s ", versionStr)
	}

	fmt.Println()
	fmt.Println()

	fmt.Println(lib.GetCurrentPlanTable(plan, currentBranchesByPlanId, nil))

	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(false)

	var contextMode string
	if config.AutoLoadContext {
		contextMode = "auto"
	} else {
		contextMode = "manual"
	}

	filesStr := "%s for loading files into context"
	if contextMode == "auto" {
		filesStr += " manually (optional)"
	}
	filesStr += "\n"

	color.New(color.FgHiWhite).Printf("%s for commands\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\"))
	color.New(color.FgHiWhite).Printf(filesStr, color.New(term.ColorHiCyan, color.Bold).Sprint("@"))
	color.New(color.FgHiWhite).Printf("%s (\\h) for help\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\help"))
	color.New(color.FgHiWhite).Printf("%s (\\q) to exit\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\quit"))

	fmt.Println()

	if printAutoFn != nil {
		printAutoFn()
	} else {
		printAutoModeTable(config)
	}

	color.New(color.FgHiWhite).Printf("%s to change auto mode\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\set-auto"))
	color.New(color.FgHiWhite).Printf("%s to see config\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\config"))
	color.New(color.FgHiWhite).Printf("%s to customize config\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\set-config"))
	fmt.Println()

	if printModelFn != nil {
		printModelFn()
	} else {
		printModelPackTable(packName)
	}
	color.New(color.FgHiWhite).Printf("%s to see model details\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\models"))
	color.New(color.FgHiWhite).Printf("%s to change models\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\set-model"))

	showReplMode()
	showMultiLineMode()
	fmt.Println()

	if !isHelp {
		if lib.CurrentReplState.Mode == lib.ReplModeTell {
			color.New(color.FgHiWhite, color.BgBlue, color.Bold).Println(" Describe a coding task 👇 ")
		} else {
			color.New(color.FgHiWhite, color.BgBlue, color.Bold).Println(" Ask a question or chat 👇 ")
		}

		fmt.Println()
	}
}

func replHelp() {
	replWelcome(replWelcomeParams{
		afterNew: false,
		isHelp:   true,
	})
	term.PrintHelpAllCommands()
}

func showReplMode() {
	fmt.Println()
	if lib.CurrentReplState.Mode == lib.ReplModeTell {
		color.New(color.BgMagenta, color.FgHiWhite, color.Bold).Println(" ⚡️ Tell mode is enabled ")
		color.New(color.FgHiWhite).Printf("%s (\\ch) switch to chat mode to chat without writing code or making changes\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\chat"))
	} else if lib.CurrentReplState.Mode == lib.ReplModeChat {
		color.New(color.BgMagenta, color.FgHiWhite, color.Bold).Println(" 💬 Chat mode is enabled ")
		color.New(color.FgHiWhite).Printf("%s (\\t) switch to tell mode to start writing code and implementing tasks\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\tell"))
	}
	fmt.Println()
}

func showMultiLineMode() {
	if lib.CurrentReplState.IsMulti {
		color.New(color.BgMagenta, color.FgHiWhite, color.Bold).Println(" 🔢 Multi-line mode is enabled ")
		fmt.Printf("%s to exit multi-line mode\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\multi"))
		fmt.Printf("%s for line breaks\n", color.New(term.ColorHiCyan, color.Bold).Sprint("enter"))
		fmt.Printf("%s to send prompt\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\send"))
	} else {
		color.New(color.BgMagenta, color.FgHiWhite, color.Bold).Println(" 1️⃣  Multi-line mode is disabled ")
		fmt.Printf("%s for multi-line editing mode\n", color.New(term.ColorHiCyan, color.Bold).Sprint("\\multi"))
		fmt.Printf("%s to send prompt\n", color.New(term.ColorHiCyan, color.Bold).Sprint("enter"))
	}
}

func parseCommand(in string) (string, string) {
	in = strings.TrimSpace(in)
	lines := strings.Split(in, "\n")
	lastLine := lines[len(lines)-1]
	lastLine = strings.TrimSpace(lastLine)

	input := strings.TrimSpace(in)
	if input == "" {
		return "", ""
	}

	// Handle plandex/pdx command prefix
	if strings.HasPrefix(lastLine, "plandex ") || strings.HasPrefix(lastLine, "pdx ") {
		return lastLine, lastLine
	}

	// Find the last \ or @ in the last line
	lastBackslashIndex := strings.LastIndex(lastLine, "\\")
	lastAtIndex := strings.LastIndex(lastLine, "@")

	suggestions, _, _ := completer(prompt.Document{Text: in})

	// Handle file references
	if lastAtIndex != -1 && lastAtIndex > lastBackslashIndex {
		paths := strings.Split(lastLine, "@")
		split2 := strings.SplitN(lastLine, "@", 2)
		numPaths := len(paths)

		filteredPaths := []string{}

		for i, path := range paths {
			p := strings.TrimSpace(path)
			if i == 0 {
				// text before the @
				continue
			}

			if (p == "" || !projectPaths.ActivePaths[p]) && len(suggestions) > 0 && i == numPaths-1 {
				p = strings.Replace(suggestions[0].Text, "@", "", 1)
				filteredPaths = append(filteredPaths, p)
			} else if projectPaths.ActivePaths[p] {
				filteredPaths = append(filteredPaths, p)
			}
		}

		if len(filteredPaths) > 0 {
			res := ""
			for _, p := range filteredPaths {
				res += "@" + p + " "
			}
			return res, split2[1]
		}
	}

	// Handle commands
	if lastBackslashIndex != -1 {
		cmdString := strings.TrimSpace(lastLine[lastBackslashIndex+1:])
		if cmdString == "" {
			return "", ""
		}

		// Split into command and args
		parts := strings.Fields(cmdString)
		cmd := parts[0]
		args := parts[1:]

		// Handle built-in REPL commands
		switch cmd {
		case "quit", lib.ReplCmdAliases["quit"]:
			return "\\quit", "\\" + cmdString

		case "help", lib.ReplCmdAliases["help"]:
			return "\\help", "\\" + cmdString

		case "multi", lib.ReplCmdAliases["multi"]:
			return "\\multi", "\\" + cmdString

		case "send", lib.ReplCmdAliases["send"]:
			return "\\send", "\\" + cmdString

		case "tell", lib.ReplCmdAliases["tell"]:
			return "\\tell", "\\" + cmdString

		case "chat", lib.ReplCmdAliases["chat"]:
			return "\\chat", "\\" + cmdString

		case "run", lib.ReplCmdAliases["run"]:
			return "\\run", "\\" + cmdString

		default:
			// Check CLI commands
			var matchedCmd string

			for _, config := range term.CliCommands {

				if (cmd == config.Cmd || (config.Alias != "" && cmd == config.Alias)) && config.Repl {
					matchedCmd = config.Cmd
					break
				}
			}

			if matchedCmd == "" {
				for _, config := range term.CliCommands {
					if strings.HasPrefix(config.Cmd, cmd) && config.Repl {
						matchedCmd = config.Cmd
						break
					}
				}
			}

			if matchedCmd != "" {
				res := matchedCmd
				if len(args) > 0 {
					res += " " + strings.Join(args, " ")
				}
				return res, "\\" + cmdString
			}
		}
	}

	return "", ""
}

func isFileInProjectPaths(filePath string) bool {
	// Convert to absolute path
	absPath, err := filepath.Abs(filePath)
	if err != nil {
		return false
	}

	// Check if file is within any project path
	for path := range projectPaths.ActivePaths {
		projectAbs, err := filepath.Abs(path)
		if err != nil {
			continue
		}
		if strings.HasPrefix(absPath, projectAbs) {
			return true
		}
	}
	return false
}

func handleRunCommand(args []string) error {
	if len(args) != 1 {
		return fmt.Errorf("run command requires exactly one file path argument")
	}

	filePath := args[0]

	// Check if file exists
	if _, err := os.Stat(filePath); os.IsNotExist(err) {
		return fmt.Errorf("file does not exist: %s", filePath)
	}

	// Build command based on current mode
	var cmdArgs []string
	if lib.CurrentReplState.Mode == lib.ReplModeTell {
		cmdArgs = []string{"tell", "-f", filePath}
	} else {
		cmdArgs = []string{"chat", "-f", filePath}
	}

	// Execute the command
	_, err := lib.ExecPlandexCommand(cmdArgs)
	if err != nil {
		return fmt.Errorf("error executing command: %v", err)
	}

	return nil
}

func getPromptOpt(cmd string) string {
	asPrompt := cmd
	if len(asPrompt) > 20 {
		asPrompt = asPrompt[:20] + "..."
	}
	return fmt.Sprintf("Send '%s' as a prompt to the AI model", asPrompt)
}

type suggestCmdsResult struct {
	shouldReturn bool
	matchedCmd   string
}

func suggestCmds(cmds []string, promptOpt string) suggestCmdsResult {
	var matchedCmd string

	fmt.Println()
	opts := []string{}

	for _, match := range cmds {
		opts = append(opts, "\\"+match)
	}
	opts = append(opts, cancelOpt, promptOpt)
	sel, err := term.SelectFromList("🤔 Did you mean to type one of these commands?", opts)
	if err != nil {
		color.New(term.ColorHiRed).Printf("Error selecting from list: %v\n", err)
	}
	if sel == cancelOpt {
		return suggestCmdsResult{shouldReturn: true}
	} else if sel != promptOpt {
		matchedCmd = strings.Replace(sel, "\\", "", 1)
	}

	return suggestCmdsResult{matchedCmd: matchedCmd}
}

type execWithInputParams struct {
	cmdString          string
	in                 string
	lastBackslashIndex int
	preservedBuffer    string
	p                  *prompt.Prompt
	lastLine           string
	condensedInput     string
	trimmedInput       string
	lines              []string
	suggestions        []prompt.Suggest
}

type execWithInputResult struct {
	shouldReturn   bool
	condensedInput string
	trimmedInput   string
}

func execWithInput(params execWithInputParams) execWithInputResult {
	cmdString := params.cmdString
	in := params.in
	lastBackslashIndex := params.lastBackslashIndex
	preservedBuffer := params.preservedBuffer
	lastLine := params.lastLine
	p := params.p
	condensedInput := params.condensedInput
	trimmedInput := params.trimmedInput
	lines := params.lines
	suggestions := params.suggestions

	// Split into command and args
	parts := strings.Fields(cmdString)
	cmd := parts[0]
	args := parts[1:]

	var fuzzyNEQCheckCmds []string
	for replCmd := range lib.ReplCmdAliases {
		if replCmd != cmd {
			fuzzyNEQCheckCmds = append(fuzzyNEQCheckCmds, replCmd)
		}
	}
	for _, config := range term.CliCommands {
		if !config.Repl {
			continue
		}
		if config.Cmd != cmd {
			fuzzyNEQCheckCmds = append(fuzzyNEQCheckCmds, config.Cmd)
		}
	}

	fuzzyNEQMatches := findSimilarCommands(cmd, fuzzyNEQCheckCmds)

	// Handle built-in REPL commands
	switch {
	case cmd == "quit" || cmd == lib.ReplCmdAliases["quit"]:
		lib.WriteHistory(in)
		os.Exit(0)

	case cmd == "help" || cmd == lib.ReplCmdAliases["help"]:
		if lastBackslashIndex > 0 {
			preservedBuffer += lastLine[:lastBackslashIndex]
		}
		replHelp()
		fmt.Println()
		if preservedBuffer != "" {
			p.InsertTextMoveCursor(preservedBuffer, true)
		}
		return execWithInputResult{shouldReturn: true}

	case cmd == "multi" || cmd == lib.ReplCmdAliases["multi"]:
		if lastBackslashIndex > 0 {
			preservedBuffer += lastLine[:lastBackslashIndex]
		}
		fmt.Println()
		lib.CurrentReplState.IsMulti = !lib.CurrentReplState.IsMulti
		showMultiLineMode()
		lib.WriteState()
		fmt.Println()
		if preservedBuffer != "" {
			p.InsertTextMoveCursor(preservedBuffer, true)
		}
		return execWithInputResult{shouldReturn: true}

	case cmd == "send" || cmd == lib.ReplCmdAliases["send"]:
		condensedSplit := strings.Split(condensedInput, "\\s")
		condensedInput = strings.TrimSpace(condensedSplit[0])
		condensedInput = strings.TrimSpace(condensedInput)

		trimmedSplit := strings.Split(trimmedInput, "\\s")
		trimmedInput = strings.TrimSpace(trimmedSplit[0])
		trimmedInput = strings.TrimSpace(trimmedInput)

		if condensedInput == "" {
			fmt.Println()
			fmt.Println("🤷‍♂️ No prompt to send")
			fmt.Println()
			return execWithInputResult{shouldReturn: true}
		}

	case cmd == "tell" || cmd == lib.ReplCmdAliases["tell"]:
		if lastBackslashIndex > 0 {
			preservedBuffer += lastLine[:lastBackslashIndex]
		}
		lib.CurrentReplState.Mode = lib.ReplModeTell
		lib.WriteState()
		showReplMode()
		if preservedBuffer != "" {
			p.InsertTextMoveCursor(preservedBuffer, true)
		}
		return execWithInputResult{shouldReturn: true}

	case cmd == "chat" || cmd == lib.ReplCmdAliases["chat"]:
		if lastBackslashIndex > 0 {
			preservedBuffer += lastLine[:lastBackslashIndex]
		}
		lib.CurrentReplState.Mode = lib.ReplModeChat
		lib.WriteState()
		showReplMode()
		if preservedBuffer != "" {
			p.InsertTextMoveCursor(preservedBuffer, true)
		}
		return execWithInputResult{shouldReturn: true}

	case cmd == "run" || cmd == lib.ReplCmdAliases["run"]:
		if lastBackslashIndex > 0 {
			preservedBuffer += lastLine[:lastBackslashIndex]
		}
		fmt.Println()
		if err := handleRunCommand(args); err != nil {
			color.New(term.ColorHiRed).Printf("Run command failed: %v\n", err)
		}
		fmt.Println()
		if preservedBuffer != "" {
			p.InsertTextMoveCursor(preservedBuffer, true)
		}
		return execWithInputResult{shouldReturn: true}

	default:
		// Check CLI commands
		var matchedCmd string

		for _, config := range term.CliCommands {
			if (cmd == config.Cmd || (config.Alias != "" && cmd == config.Alias)) && config.Repl {
				matchedCmd = config.Cmd
				break
			}
		}

		if matchedCmd == "" && len(suggestions) > 0 {
			matchedCmd = strings.Replace(suggestions[0].Text, "\\", "", 1)
			return execWithInput(execWithInputParams{
				cmdString:          matchedCmd,
				in:                 condensedInput,
				lastBackslashIndex: lastBackslashIndex,
				preservedBuffer:    preservedBuffer,
				p:                  p,
				lastLine:           lastLine,
				condensedInput:     condensedInput,
				trimmedInput:       trimmedInput,
				lines:              lines,
				suggestions:        suggestions,
			})
		}

		if matchedCmd == "" {

			promptOpt := getPromptOpt(cmd)
			if len(fuzzyNEQMatches) > 0 {
				res := suggestCmds(fuzzyNEQMatches, promptOpt)
				if res.shouldReturn {
					return execWithInputResult{shouldReturn: true}
				}
				matchedCmd = res.matchedCmd
				return execWithInput(execWithInputParams{
					cmdString:          matchedCmd,
					in:                 condensedInput,
					lastBackslashIndex: lastBackslashIndex,
					preservedBuffer:    preservedBuffer,
					p:                  p,
					lastLine:           lastLine,
					condensedInput:     condensedInput,
					trimmedInput:       trimmedInput,
					lines:              lines,
					suggestions:        suggestions,
				})
			} else if len(lines) == 1 && strings.HasPrefix(trimmedInput, "\\") {
				showCmdsOpt := "Show available commands"
				opts := []string{cancelOpt, showCmdsOpt, promptOpt}
				sel, err := term.SelectFromList("🤔 Couldn't find a matching command. What do you want to do?", opts)
				if err != nil {
					color.New(term.ColorHiRed).Printf("Error selecting from list: %v\n", err)
				}
				if sel == cancelOpt {
					return execWithInputResult{shouldReturn: true}
				} else if sel == showCmdsOpt {
					replHelp()
					fmt.Println()
					return execWithInputResult{shouldReturn: true}
				}
			}
		}

		if matchedCmd != "" {
			// fmt.Println("> plandex " + config.Cmd)
			if lastBackslashIndex > 0 {
				preservedBuffer += lastLine[:lastBackslashIndex]
			}
			fmt.Println()
			execArgs := []string{matchedCmd}
			if matchedCmd == "continue" && chatOnly {
				execArgs = append(execArgs, "--chat")
			}
			execArgs = append(execArgs, args...)
			_, err := lib.ExecPlandexCommandWithParams(execArgs, lib.ExecPlandexCommandParams{
				SessionId: sessionId,
			})
			if err != nil {
				color.New(term.ColorHiRed).Printf("Error executing command: %v\n", err)
			}
			fmt.Println()
			if preservedBuffer != "" {
				p.InsertTextMoveCursor(preservedBuffer, true)
			}

			if strings.HasPrefix(matchedCmd, "set-auto") || strings.HasPrefix(matchedCmd, "set-config") {
				term.StartSpinner("")
				setReplConfig()
				term.StopSpinner()
			}
			return execWithInputResult{shouldReturn: true}
		}
	}

	return execWithInputResult{
		condensedInput: condensedInput,
		trimmedInput:   trimmedInput,
	}
}

func findSimilarCommands(input string, commands []string) []string {
	input = strings.TrimSpace(input)
	input = strings.ToLower(input)
	input = strings.Trim(input, "/")

	// Get ranked matches
	ranks := fuzzy.RankFind(input, commands)

	// Filter strictly by distance
	var filtered []string
	for _, rank := range ranks {
		// include if either is a substring of the other
		if strings.Contains(rank.Target, input) || strings.Contains(input, rank.Target) {
			filtered = append(filtered, rank.Target)
			continue
		}

		// Normalize threshold based on command length
		maxLen := len(input)
		if len(rank.Target) > maxLen {
			maxLen = len(rank.Target)
		}

		threshold := 4 // Base threshold
		if maxLen < 5 {
			threshold = 1 // Stricter for very short commands
		}

		if rank.Distance <= threshold {
			filtered = append(filtered, rank.Target)
		}
	}

	return filtered
}


================================================
FILE: app/cli/cmd/revoke.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var revokeCmd = &cobra.Command{
	Use:   "revoke [email]",
	Short: "Revoke an invite or remove a user from the org",
	Run:   revoke,
	Args:  cobra.MaximumNArgs(1),
}

func init() {
	RootCmd.AddCommand(revokeCmd)
}

func revoke(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	email := ""
	if len(args) > 0 {
		email = args[0]
	}

	var userResp *shared.ListUsersResponse
	var pendingInvites []*shared.Invite
	errCh := make(chan error)

	term.StartSpinner("")

	go func() {
		var err *shared.ApiError
		userResp, err = api.Client.ListUsers()
		if err != nil {
			errCh <- fmt.Errorf("error fetching users: %s", err.Msg)
			return
		}
		errCh <- nil
	}()

	go func() {
		var err *shared.ApiError
		pendingInvites, err = api.Client.ListPendingInvites()
		if err != nil {
			errCh <- fmt.Errorf("error fetching pending invites: %s", err.Msg)
			return
		}
		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			term.StopSpinner()
			term.OutputErrorAndExit(err.Error())
		}
	}

	term.StopSpinner()

	type userInfo struct {
		Id       string
		IsInvite bool
	}

	emailToUserMap := make(map[string]userInfo)
	labelToEmail := make(map[string]string)

	// Combine users and invites for selection
	combinedList := make([]string, 0, len(userResp.Users)+len(pendingInvites))
	for _, user := range userResp.Users {
		label := fmt.Sprintf("%s <%s>", user.Name, user.Email)
		labelToEmail[label] = user.Email
		combinedList = append(combinedList, label)
		emailToUserMap[user.Email] = userInfo{Id: user.Id, IsInvite: false}
	}
	for _, invite := range pendingInvites {
		label := fmt.Sprintf("%s <%s> (invite pending)", invite.Name, invite.Email)
		labelToEmail[label] = invite.Email
		combinedList = append(combinedList, label)
		emailToUserMap[invite.Email] = userInfo{Id: invite.Id, IsInvite: true}
	}

	if email == "" {
		selected, err := term.SelectFromList("Select a user or invite:", combinedList)
		if err != nil {
			term.OutputErrorAndExit("Error selecting item to revoke: %v", err)
		}

		email = labelToEmail[selected]
	}

	if email == "" {
		term.OutputErrorAndExit("No user or invite selected")
	}

	// Determine if email belongs to a user or an invite and revoke accordingly
	if userInfo, exists := emailToUserMap[email]; exists {
		if userInfo.IsInvite {
			if err := api.Client.DeleteInvite(userInfo.Id); err != nil {
				term.OutputErrorAndExit("Failed to revoke invite: %v", err)
			}
			fmt.Println("✅ Invite revoked")
		} else {
			if err := api.Client.DeleteUser(userInfo.Id); err != nil {
				term.OutputErrorAndExit("Failed to remove user: %v", err)
			}
			fmt.Println("✅ User removed")
		}
	} else {
		term.OutputErrorAndExit("No user or pending invite found for email '%s'", email)
	}
}


================================================
FILE: app/cli/cmd/rewind.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"
	"regexp"
	"strconv"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var rewindCmd = &cobra.Command{
	Use:     "rewind [steps-or-sha]",
	Aliases: []string{"rw"},
	Short:   "Rewind plan state and optionally revert project files",
	Long: `Rewind plan state and optionally revert project files to match.
	
You can pass a "steps" number or a commit sha. If a steps number is passed, 
the plan will be rewound that many steps. If a commit sha is passed, the 
plan will be rewound to that commit. If neither is passed, you will be 
prompted to select a step from the history.

By default, you will be prompted whether to revert project files to match 
the rewound plan state. You can use --revert to automatically revert 
files, or configure this behavior with the 'auto-revert' plan config setting.

If project files have changes, you will always be prompted before updating.`,
	Args: cobra.MaximumNArgs(1),
	Run:  rewind,
}

var revert bool
var skipRevert bool

func init() {
	RootCmd.AddCommand(rewindCmd)
	rewindCmd.Flags().BoolVar(&revert, "revert", false, "Also revert project files to match plan state")
	rewindCmd.Flags().BoolVar(&skipRevert, "skip-revert", false, "Skip reverting project files to match plan state")
	rewindCmd.Flags().BoolVar(&autoCommit, "commit", false, "Commit changes to git when --revert is passed")
	rewindCmd.Flags().BoolVar(&skipCommit, "skip-commit", false, "Skip committing changes to git when --revert is passed")

}

func rewind(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	if skipRevert && revert {
		term.OutputErrorAndExit("Cannot pass both --revert and --skip-revert")
	}

	// Get logs
	term.StartSpinner("")
	logsRes, apiErr := api.Client.ListLogs(lib.CurrentPlanId, lib.CurrentBranch)
	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting logs: %v", apiErr)
	}

	var targetSha string
	var steps int
	var isSha bool

	parseGitLog := func(log string) (string, string) {
		// Parse the log entry
		lines := strings.Split(log, "\n")
		if len(lines) < 2 {
			return "", ""
		}

		// Extract sha and timestamp from first line
		parts := strings.Split(lines[0], "|")
		if len(parts) < 2 {
			return "", ""
		}

		shaLine := strings.TrimSpace(parts[0])
		sha := regexp.MustCompile(`📝 Update (\w+)`).FindStringSubmatch(shaLine)[1]
		msg := strings.TrimSpace(lines[1])

		return sha, msg
	}

	logEntries := strings.Split(logsRes.Body, "\n\n")

	if len(args) == 0 {
		// No arguments - show selection list
		options := make([]string, 0)

		for _, log := range logEntries {
			if log == "" {
				continue
			}

			sha, msg := parseGitLog(log)

			if sha == "" {
				continue
			}

			// Format the two-line option
			option := fmt.Sprintf("%s | %s", sha, formatLogMessage(msg))
			options = append(options, option)
		}

		term.StopSpinner()
		selected, err := term.SelectFromList("Select step to rewind to:", options)
		if err != nil {
			term.OutputErrorAndExit("Error selecting step: %v", err)
		}

		// Parse selected option to get sha
		parts := strings.Split(selected, " | ")
		if len(parts) < 2 {
			term.OutputErrorAndExit("Invalid selection")
		}

		targetSha = parts[0]
		isSha = true

	} else {
		// Arguments provided - use direct rewind logic
		stepsOrSha := args[0]
		steps, err := strconv.Atoi(stepsOrSha)

		if err == nil && steps > 0 && steps < 999 {
			// Rewind by the specified number of steps
			targetSha = logsRes.Shas[steps]
		} else if sha := stepsOrSha; sha != "" {
			// Rewind to the specified Sha
			targetSha = sha
			isSha = true
		} else {
			term.OutputErrorAndExit("Invalid steps or sha. Steps must be a positive integer, and sha must be a valid commit hash.")
		}
	}

	doRewind := func() {
		var updatedModelSettings bool

		term.StartSpinner("")
		_, apiErr := api.Client.RewindPlan(lib.CurrentPlanId, lib.CurrentBranch, shared.RewindPlanRequest{
			Sha: targetSha,
		})

		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Error rewinding plan: %v", apiErr)
		}

		var err error
		updatedModelSettings, err = lib.SaveLatestPlanModelSettingsIfNeeded()
		term.StopSpinner()
		if err != nil {
			term.OutputErrorAndExit("Error saving model settings: %v", err)
		}

		var msg string
		if isSha {
			msg = "✅ Rewound to " + targetSha
		} else {
			postfix := "s"
			if steps == 1 {
				postfix = ""
			}
			msg = fmt.Sprintf("✅ Rewound %d step%s to %s", steps, postfix, targetSha)
		}

		fmt.Println(msg)

		if updatedModelSettings {
			fmt.Println()
			fmt.Println("🧠 Model settings file updated → ", lib.GetPlanModelSettingsPath(lib.CurrentPlanId))
		}
		fmt.Println()
	}

	printNoChanges := func() {
		fmt.Println("🙅‍♂️ No project files were modified")
		fmt.Println()
	}

	printCmds := func() {
		term.PrintCmds("", "log", "continue")
	}

	// get the timestamp of the target sha
	var targetShaTimestamp time.Time
	for _, log := range logEntries {
		if log == "" {
			continue
		}
		sha, _ := parseGitLog(log)
		if sha == targetSha {
			timestamp, err := lib.GetGitLogTimestamp(log)
			if err != nil {
				continue
			}

			targetShaTimestamp = timestamp
			break
		}
	}

	if targetShaTimestamp.IsZero() {
		term.OutputErrorAndExit("Error getting timestamp for target sha: " + targetSha)
	}

	// Get current plan state to check for undone applies
	term.StartSpinner("")
	currentState, apiErr := api.Client.GetCurrentPlanState(lib.CurrentPlanId, lib.CurrentBranch)
	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting plan state: %v", apiErr)
	}

	// Get list of applies that will be undone
	undonePlanApplies := lib.GetUndonePlanApplies(currentState, targetShaTimestamp)

	// If no applies are being undone, skip revert entirely
	if len(undonePlanApplies) == 0 {
		// Just do the rewind, no need for any file operations
		doRewind()
		printNoChanges()
		printCmds()
		return
	}

	// Get the set of affected file paths

	// Determine if we should revert based on flag/config
	var shouldRevert bool
	needsPrompt := true
	var config *shared.PlanConfig

	if cmd.Flags().Changed("revert") || cmd.Flags().Changed("skip-revert") {
		if skipRevert {
			shouldRevert = false
		} else {
			shouldRevert = revert
		}
		needsPrompt = false
	} else {
		config, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
		if apiErr != nil {
			term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
		}
		shouldRevert = config.AutoRevertOnRewind
		needsPrompt = false
	}

	var targetState *shared.CurrentPlanState
	var analysis *lib.RewindAnalysis

	if shouldRevert || needsPrompt {
		// First preview the rewind to check for conflicts
		targetState, apiErr = api.Client.GetCurrentPlanStateAtSha(lib.CurrentPlanId, targetSha)
		if apiErr != nil {
			term.OutputErrorAndExit("Error previewing rewind: %v", apiErr)
		}

		if targetState == nil {
			term.OutputErrorAndExit("Error previewing rewind - no state found at sha: " + targetSha)
		}

		var err error
		analysis, err = lib.AnalyzeRewind(targetState, currentState)
		if err != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Error analyzing rewind: %v", err)
		}

		if len(analysis.RequiredChanges) == 0 {
			// No file changes - proceed with rewind
			doRewind()
			printNoChanges()
			printCmds()
			return
		}

		// Show file differences
		term.StopSpinner()

		// Group changes by type for display
		toAdd := make([]string, 0)
		toRemove := make([]string, 0)
		toModify := make([]string, 0)

		for path, content := range analysis.RequiredChanges {
			if content == "" {
				toRemove = append(toRemove, path)
			} else if currentState.ContextsByPath[path] == nil {
				toAdd = append(toAdd, path)
			} else {
				toModify = append(toModify, path)
			}
		}

		if needsPrompt || len(analysis.Conflicts) > 0 {
			s := "files"
			if len(analysis.RequiredChanges) == 1 {
				s = "file"
			}

			fmt.Printf("⏪ %d local project %s differ from target plan state\n", len(analysis.RequiredChanges), s)
			fmt.Println()
			fmt.Printf("Reverting the %s will make these changes locally 👇\n", s)
			fmt.Println()

			if len(toAdd) > 0 {
				fmt.Println("To add:")
				for _, path := range toAdd {
					fmt.Printf(" • %s\n", path)
				}
				fmt.Println()
			}

			if len(toRemove) > 0 {
				fmt.Println("To remove:")
				for _, path := range toRemove {
					fmt.Printf(" • %s\n", path)
				}
				fmt.Println()
			}

			if len(toModify) > 0 {
				fmt.Println("To update:")
				for _, path := range toModify {
					fmt.Printf(" • %s\n", path)
				}
				fmt.Println()
			}

			if len(analysis.Conflicts) > 0 {
				// Always prompt if there are conflicts
				s := " These project files have"
				if len(analysis.Conflicts) == 1 {
					s = " A project file has"
				}
				fmt.Printf("⚠️  %s been updated outside of Plandex since the latest apply:\n", s)
				for path := range analysis.Conflicts {
					fmt.Printf(" • %s\n", path)
				}
				fmt.Println()

				fmt.Println("If you revert, you will lose those changes.")
				fmt.Println()

				s = "files"
				if len(analysis.RequiredChanges) == 1 {
					s = "file"
				}

				options := []string{
					fmt.Sprintf("Revert project %s to match rewound plan state (overwrite changes)", s),
					fmt.Sprintf("Rewind plan, but skip reverting project %s", s),
					"Cancel rewind",
				}

				selected, err := term.SelectFromList("What do you want to do?", options)
				if err != nil {
					term.OutputErrorAndExit("Error getting user input: %v", err)
				}

				switch selected {
				case options[0]:
					shouldRevert = true
				case options[1]:
					shouldRevert = false
				case options[2]:
					os.Exit(0)
				}

				needsPrompt = false
			}
		}
	}

	// Now that we've handled the file state decision, perform the actual rewind
	doRewind()

	didRevert := false

	if shouldRevert || needsPrompt {
		if needsPrompt {
			term.StopSpinner()
			s := "files"
			if len(analysis.RequiredChanges) == 1 {
				s = "file"
			}
			confirmed, err := term.ConfirmYesNo(fmt.Sprintf("Revert project %s to match rewound plan state?", s))
			if err != nil {
				term.OutputErrorAndExit("Error getting user confirmation: %v", err)
			}

			shouldRevert = confirmed
		}

		if shouldRevert && len(analysis.RequiredChanges) > 0 {
			term.StartSpinner("")
			err := lib.ApplyRewindChanges(analysis.RequiredChanges)
			term.StopSpinner()
			if err != nil {
				term.OutputErrorAndExit("Error restoring file state: %v", err)
			}

			didRevert = true

			s := "files were"
			if len(analysis.RequiredChanges) == 1 {
				s = "file was"
			}

			fmt.Printf("⏪ %d project %s reverted\n", len(analysis.RequiredChanges), s)
			for path := range analysis.RequiredChanges {
				fmt.Printf(" • %s\n", path)
			}
			fmt.Println()
		}
	}

	if didRevert {
		shouldCommit := false
		needsPrompt := true

		if !fs.ProjectRootIsGitRepo() {
			shouldCommit = false
			needsPrompt = false
		} else {
			if cmd.Flags().Changed("commit") || cmd.Flags().Changed("skip-commit") {
				if skipCommit {
					shouldCommit = false
				} else {
					shouldCommit = autoCommit
				}
				needsPrompt = false
			} else {
				if config == nil {
					config, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
					if apiErr != nil {
						term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
					}
				}
				shouldCommit = config.AutoCommit
				needsPrompt = false
			}
		}

		if needsPrompt {
			term.StopSpinner()
			confirmed, err := term.ConfirmYesNo("Commit changes to git?")
			if err != nil {
				term.OutputErrorAndExit("Error getting user confirmation: %v", err)
			}
			shouldCommit = confirmed
		}

		if shouldCommit {
			msg := "🤖 Plandex → rewound plan state and reverted these changes:"
			for _, apply := range undonePlanApplies {
				msg += fmt.Sprintf("\n   • %s", apply.CommitMsg)
			}

			paths := []string{}
			for path := range analysis.RequiredChanges {
				paths = append(paths, path)
			}

			err := lib.GitAddAndCommitPaths(fs.ProjectRoot, msg, paths, true)
			if err != nil {
				term.OutputErrorAndExit("Error committing changes: %v", err)
			}
		}

	} else {
		printNoChanges()
	}

	printCmds()
}

func formatLogMessage(msg string) string {
	var res string

	// Check for message type patterns
	switch {
	case strings.Contains(msg, "User prompt"):
		res = "💬 " + msg
	case strings.Contains(msg, "Plandex reply"):
		if coins := regexp.MustCompile(`(\d+) 🪙`).FindStringSubmatch(msg); len(coins) >= 2 {
			res = "🤖 AI Response | " + coins[1] + " 🪙"
		}
		res = "🤖 " + msg
	case strings.Contains(msg, "Build pending"):
		res = "🏗️  Building changes"
	case strings.Contains(msg, "Loaded"):
		res = "📚 " + msg
	default:
		res = msg
	}

	return res
}


================================================
FILE: app/cli/cmd/rm.go
================================================
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var contextRmCmd = &cobra.Command{
	Use:     "rm",
	Aliases: []string{"remove", "unload"},
	Short:   "Remove context",
	Long: `Remove context by index, range, name, or glob.
	
	plandex rm 1 # Remove by index in the 'plandex ls' list
	plandex rm 1-3
	plandex rm some-file.ts
	plandex rm app/*.py
	`,
	Args: cobra.MinimumNArgs(1),
	Run:  contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}
	indices := parseIndices(args)

	for i, context := range contexts {
		if indices[i+1] {
			deleteIds[context.Id] = true
			continue
		}
		for _, id := range args {
			if context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}

func init() {
	RootCmd.AddCommand(contextRmCmd)
}

func parseIndices(args []string) map[int]bool {
	indices := map[int]bool{}
	for _, arg := range args {
		if strings.Contains(arg, "-") {
			parts := strings.Split(arg, "-")
			start, err1 := strconv.Atoi(parts[0])
			end, err2 := strconv.Atoi(parts[1])
			if err1 == nil && err2 == nil && start <= end {
				for i := start; i <= end; i++ {
					indices[i] = true
				}
			}
		} else {
			index, err := strconv.Atoi(arg)
			if err == nil {
				indices[index] = true
			}
		}
	}
	return indices
}


================================================
FILE: app/cli/cmd/root.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/term"
	"strings"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var helpShowAll bool

// RootCmd represents the base command when called without any subcommands
var RootCmd = &cobra.Command{
	Use: `plandex [command] [flags]`,
	// Short: "Plandex: iterative development with AI",
	SilenceErrors: true,
	SilenceUsage:  true,
	Run: func(cmd *cobra.Command, args []string) {
		run(cmd, args)
	},
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
	// if no arguments were passed, start the repl
	if len(os.Args) == 1 ||
		(len(os.Args) == 2 && strings.HasPrefix(os.Args[1], "--") && os.Args[1] != "--help") ||
		(len(os.Args) == 3 && strings.HasPrefix(os.Args[1], "--") && os.Args[1] != "--help" && strings.HasPrefix(os.Args[2], "--") && os.Args[2] != "--help") {

		// Instead of directly calling replCmd.Run, parse the flags first
		replCmd.ParseFlags(os.Args[1:])
		replCmd.Run(replCmd, []string{})
		return
	}

	if err := RootCmd.Execute(); err != nil {
		// term.OutputErrorAndExit("Error executing root command: %v", err)
		// log.Fatalf("Error executing root command: %v", err)

		// output the error message to stderr
		term.OutputSimpleError("Error: %v", err)

		fmt.Println()

		color.New(color.Bold, color.BgGreen, color.FgHiWhite).Println(" Usage ")
		color.New(color.Bold).Println("  plandex [command] [flags]")
		color.New(color.Bold).Println("  pdx [command] [flags]")
		fmt.Println()

		color.New(color.Bold, color.BgGreen, color.FgHiWhite).Println(" Help ")
		color.New(color.Bold).Println("  plandex help # show basic usage")
		color.New(color.Bold).Println("  plandex help --all # show all commands")
		color.New(color.Bold).Println("  plandex [command] --help")
		fmt.Println()

		color.New(color.Bold, color.BgGreen, color.FgHiWhite).Println(" Common Commands ")
		color.New(color.Bold).Println("  plandex new # create a new plan")
		color.New(color.Bold).Println("  plandex tell # tell the plan what to do")
		color.New(color.Bold).Println("  plandex continue # continue the current plan")
		color.New(color.Bold).Println("  plandex settings # show plan settings")
		color.New(color.Bold).Println("  plandex set # update plan settings")
		fmt.Println()

		os.Exit(1)
	}
}

func run(cmd *cobra.Command, args []string) {

}

func init() {
	var helpCmd = &cobra.Command{
		Use:     "help",
		Aliases: []string{"h"},
		Short:   "Display help for Plandex",
		Long:    `Display help for Plandex.`,
		Run: func(cmd *cobra.Command, args []string) {
			term.PrintCustomHelp(helpShowAll)
		},
	}

	RootCmd.AddCommand(helpCmd)
	RootCmd.AddCommand(connectClaudeCmd)
	RootCmd.AddCommand(disconnectClaudeCmd)

	// add an --all/-a flag
	helpCmd.Flags().BoolVarP(&helpShowAll, "all", "a", false, "Show all commands")
}


================================================
FILE: app/cli/cmd/set_config.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"slices"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

func init() {
	RootCmd.AddCommand(setConfigCmd)
	setConfigCmd.AddCommand(defaultSetConfigCmd)
	RootCmd.AddCommand(setAutoCmd)
	setAutoCmd.AddCommand(setAutoDefaultCmd)
}

var setConfigCmd = &cobra.Command{
	Use:   "set-config [setting] [value]",
	Short: "Update current plan config",
	Run:   setConfig,
	Args:  cobra.MaximumNArgs(2),
}

var defaultSetConfigCmd = &cobra.Command{
	Use:   "default [setting] [value]",
	Short: "Update default plan config",
	Run:   defaultSetConfig,
	Args:  cobra.MaximumNArgs(2),
}

var setAutoCmd = &cobra.Command{
	Use:   "set-auto [value]",
	Short: "Update config auto-mode",
	Run:   setAuto,
	Args:  cobra.MaximumNArgs(1),
}

var setAutoDefaultCmd = &cobra.Command{
	Use:   "default [value]",
	Short: "Update default config auto-mode",
	Run:   setAutoDefault,
	Args:  cobra.MaximumNArgs(1),
}

func setAuto(cmd *cobra.Command, args []string) {
	setConfig(cmd, append([]string{"auto-mode"}, args...))
}

func setAutoDefault(cmd *cobra.Command, args []string) {
	defaultSetConfig(cmd, append([]string{"auto-mode"}, args...))
}

func setConfig(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	term.StartSpinner("")
	config, apiErr := api.Client.GetPlanConfig(lib.CurrentPlanId)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting current config: %v", apiErr)
		return
	}

	if config == nil {
		config = &shared.PlanConfig{}
	}

	key, updatedConfig := updateConfig(args, config)
	if updatedConfig == nil {
		return
	}

	term.StartSpinner("")
	apiErr = api.Client.UpdatePlanConfig(lib.CurrentPlanId, shared.UpdatePlanConfigRequest{
		Config: updatedConfig,
	})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error updating config: %v", apiErr)
		return
	}

	fmt.Println("✅ Config updated")
	lib.ShowPlanConfig(updatedConfig, key)
	fmt.Println()

	loadMapIfNeeded(config, updatedConfig)
	removeMapIfNeeded(config, updatedConfig)

	if !(config.AutoApply && config.AutoExec) && updatedConfig.AutoApply && updatedConfig.AutoExec {
		color.New(term.ColorHiYellow, color.Bold).Println("⚠️  You enabled automatic apply and execution.")

		fmt.Println()
	} else if !config.AutoApply && updatedConfig.AutoApply {
		color.New(term.ColorHiYellow, color.Bold).Println("⚠️  You enabled automatic apply.")
		fmt.Println()
	} else if !config.AutoExec && updatedConfig.AutoExec {
		color.New(term.ColorHiYellow, color.Bold).Println("⚠️  You enabled automatic execution.")
		fmt.Println()
	}

	term.StopSpinner()

	term.PrintCmds("", "config", "config default", "set-config default")
}

func defaultSetConfig(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")
	config, apiErr := api.Client.GetDefaultPlanConfig()
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting current config: %v", apiErr)
		return
	}

	if config == nil {
		config = &shared.PlanConfig{}
	}

	key, updatedConfig := updateConfig(args, config)
	if updatedConfig == nil {
		return
	}

	term.StartSpinner("")
	apiErr = api.Client.UpdateDefaultPlanConfig(shared.UpdateDefaultPlanConfigRequest{
		Config: updatedConfig,
	})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error updating config: %v", apiErr)
		return
	}

	fmt.Println("✅ Default config updated")
	lib.ShowPlanConfig(updatedConfig, key)
	fmt.Println()
	term.PrintCmds("", "config default", "config", "set-config")
}

type sortableSetting struct {
	sortKey string
	cfg     shared.ConfigSetting
}

func updateConfig(args []string, originalConfig *shared.PlanConfig) (string, *shared.PlanConfig) {
	var setting, value string

	if len(args) > 0 {
		setting = strings.ToLower(strings.ReplaceAll(args[0], "-", ""))
	}

	if len(args) > 1 {
		value = args[1]
	}

	if setting == "" {
		var sorted []sortableSetting

		for key, cfg := range shared.ConfigSettingsByKey {
			var sortKey string
			if cfg.SortKey != "" {
				sortKey = cfg.SortKey
			} else {
				sortKey = key
			}
			sorted = append(sorted, sortableSetting{sortKey, cfg})
		}

		slices.SortFunc(sorted, func(a, b sortableSetting) int {
			return strings.Compare(a.sortKey, b.sortKey)
		})

		var opts []string
		for _, opt := range sorted {
			opts = append(opts, fmt.Sprintf("%s → %s", opt.cfg.Name, opt.cfg.Desc))
		}

		selection, err := term.SelectFromList("Choose a setting to update:", opts)
		if err != nil {
			if err.Error() == "interrupt" {
				return "", nil
			}
			term.OutputErrorAndExit("Error selecting setting: %v", err)
			return "", nil
		}

		setting = strings.Split(selection, " →")[0]
		setting = strings.ToLower(strings.ReplaceAll(setting, "-", ""))
	}

	config := *originalConfig
	cfgSetting, exists := shared.ConfigSettingsByKey[setting]
	if !exists {
		term.OutputErrorAndExit("Unknown setting: %s\n", setting)
		return "", nil
	}

	if value == "" {
		if cfgSetting.BoolSetter != nil {
			options := []string{"Enabled", "Disabled"}
			selection, err := term.SelectFromList(fmt.Sprintf("Set %s:", cfgSetting.Name), options)
			if err != nil {
				if err.Error() == "interrupt" {
					return "", nil
				}
				term.OutputErrorAndExit("Error selecting value: %v", err)
				return "", nil
			}
			cfgSetting.BoolSetter(&config, selection == "Enabled")
		} else if cfgSetting.IntSetter != nil {
			value, err := term.GetRequiredUserStringInput(fmt.Sprintf("Set %s (number)", cfgSetting.Name))
			if err != nil {
				if err.Error() == "interrupt" {
					return "", nil
				}
				term.OutputErrorAndExit("Error getting value: %v", err)
				return "", nil
			}
			n, err := strconv.Atoi(value)
			if err != nil {
				term.OutputErrorAndExit("Invalid number value for %s (%s)", cfgSetting.Name, value)
				return "", nil
			}
			cfgSetting.IntSetter(&config, n)
		} else if cfgSetting.StringSetter != nil {
			var selection string
			var err error
			choices := *cfgSetting.Choices
			if len(choices) > 0 {
				if cfgSetting.HasCustomChoice {
					choices = append(choices, "Other")
				}
				selection, err = term.SelectFromList(fmt.Sprintf("Set %s:", cfgSetting.Name), choices)
				if err != nil {
					if err.Error() == "interrupt" {
						return "", nil
					}
					term.OutputErrorAndExit("Error selecting value: %v", err)
					return "", nil
				}
				if selection == "Other" {
					selection, err = term.GetRequiredUserStringInput(fmt.Sprintf("Enter value for %s", cfgSetting.Name))
					if err != nil {
						if err.Error() == "interrupt" {
							return "", nil
						}
						term.OutputErrorAndExit("Error getting value: %v", err)
						return "", nil
					}
				} else if cfgSetting.ChoiceToKey != nil {
					selection = cfgSetting.ChoiceToKey(selection)
				}
			} else {
				selection, err = term.GetRequiredUserStringInput(fmt.Sprintf("Set %s", cfgSetting.Name))
				if err != nil {
					if err.Error() == "interrupt" {
						return "", nil
					}
					term.OutputErrorAndExit("Error getting value: %v", err)
					return "", nil
				}
			}
			cfgSetting.StringSetter(&config, selection)
		} else if cfgSetting.EditorSetter != nil {
			editor := lib.SelectEditor(false)
			cfgSetting.EditorSetter(&config, editor.Name, editor.Cmd, editor.Args)
		}
	} else {
		if cfgSetting.BoolSetter != nil {
			b, err := parseBooleanArg(value)
			if err != nil {
				term.OutputErrorAndExit("Invalid value for %s (%s)", cfgSetting.Name, value)
				return "", nil
			}
			cfgSetting.BoolSetter(&config, b)
		} else if cfgSetting.IntSetter != nil {
			n, err := strconv.Atoi(value)
			if err != nil {
				term.OutputErrorAndExit("Invalid number value for %s (%s)", cfgSetting.Name, value)
				return "", nil
			}
			cfgSetting.IntSetter(&config, n)
		} else if cfgSetting.StringSetter != nil {
			cfgSetting.StringSetter(&config, value)
		} else if cfgSetting.EditorSetter != nil {
			fields := strings.Fields(value)
			cmd := fields[0]
			var cmdArgs []string
			if len(fields) > 1 {
				cmdArgs = fields[1:]
			}
			cfgSetting.EditorSetter(&config, value, cmd, cmdArgs)
		}
	}

	return setting, &config
}

func parseBooleanArg(value string) (bool, error) {
	switch value {
	case "enabled", "true", "t", "yes", "y", "1":
		return true, nil
	case "disabled", "false", "f", "no", "n", "0":
		return false, nil
	default:
		return false, fmt.Errorf("invalid value: %s", value)
	}

}

func loadMapIfNeeded(originalConfig, updatedConfig *shared.PlanConfig) {
	if updatedConfig.AutoLoadContext && !originalConfig.AutoLoadContext {
		hasMap := false

		term.StartSpinner("")
		context, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

		if err == nil {
			for _, c := range context {
				if c.ContextType == shared.ContextMapType {
					hasMap = true
					break
				}
			}

			if !hasMap {
				lib.MustLoadAutoContextMap()
				fmt.Println()
			}
		}
	}
}

func removeMapIfNeeded(originalConfig, updatedConfig *shared.PlanConfig) {
	if originalConfig.AutoLoadContext && !updatedConfig.AutoLoadContext {
		term.StartSpinner("")
		context, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

		if err == nil {
			for _, c := range context {
				if c.ContextType == shared.ContextMapType && (c.AutoLoaded || c.FilePath == ".") {
					res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
						Ids: map[string]bool{c.Id: true},
					})
					term.StopSpinner()
					if err != nil {
						term.OutputErrorAndExit("Error deleting context: %v", err)
						return
					}
					fmt.Println("✅ " + res.Msg)
					break
				}
			}
		}

	}
}


================================================
FILE: app/cli/cmd/set_model.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var setModelUseJsonFile bool
var setModelJsonFilePath string
var setModelSave bool

func init() {
	RootCmd.AddCommand(modelsSetCmd)

	modelsSetCmd.AddCommand(defaultModelSetCmd)

	modelsSetCmd.Flags().BoolVar(&setModelUseJsonFile, "json", false, "Use a JSON file to set model settings")
	modelsSetCmd.Flags().StringVarP(&setModelJsonFilePath, "file", "f", "", "Path to model settings JSON file")
	modelsSetCmd.Flags().BoolVar(&setModelSave, "save", false, "Save model settings from JSON file")

	defaultModelSetCmd.Flags().BoolVar(&setModelUseJsonFile, "json", false, "Use a JSON file to set model settings")
	defaultModelSetCmd.Flags().StringVarP(&setModelJsonFilePath, "file", "f", "", "Path to model settings JSON file")
	defaultModelSetCmd.Flags().BoolVar(&setModelSave, "save", false, "Save model settings from JSON file")
}

var modelsSetCmd = &cobra.Command{
	Use:     "set-model [model-pack-name]",
	Aliases: []string{"set-models"},
	Short:   "Update current plan model settings",
	Run:     modelsSet,
	Args:    cobra.MaximumNArgs(1),
}

var defaultModelSetCmd = &cobra.Command{
	Use:   "default [model-pack-name]",
	Short: "Update org-wide default model settings",
	Run:   defaultModelsSet,
	Args:  cobra.MaximumNArgs(1),
}

func modelsSet(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	term.StartSpinner("")
	originalSettings, apiErr := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting current settings: %v", apiErr)
		return
	}

	defaultPath := lib.GetPlanModelSettingsPath(lib.CurrentPlanId)

	settings := updateModelSettings(args, originalSettings, defaultPath)

	if settings == nil {
		return
	}

	res, apiErr := api.Client.UpdateSettings(
		lib.CurrentPlanId,
		lib.CurrentBranch,
		shared.UpdateSettingsRequest{
			ModelPackName: settings.ModelPackName,
			ModelPack:     settings.ModelPack,
		})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error updating settings: %v", apiErr)
		return
	}

	if res == nil {
		return
	}

	fmt.Println(res.Msg)
	fmt.Println()
	term.PrintCmds("", "models", "set-model default", "log")
}

func defaultModelsSet(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")
	originalSettings, apiErr := api.Client.GetOrgDefaultSettings()
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting current settings: %v", apiErr)
		return
	}

	defaultPath := lib.DefaultModelSettingsPath

	settings := updateModelSettings(args, originalSettings, defaultPath)

	if settings == nil {
		return
	}

	term.StartSpinner("")
	res, apiErr := api.Client.UpdateOrgDefaultSettings(
		shared.UpdateSettingsRequest{
			ModelPackName: settings.ModelPackName,
			ModelPack:     settings.ModelPack,
		})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error updating settings: %v", apiErr)
		return
	}

	if res == nil {
		return
	}

	fmt.Println(res.Msg)
	fmt.Println()
	term.PrintCmds("", "models", "set-model default", "log")
}

func updateModelSettings(args []string, originalSettings *shared.PlanSettings, defaultPath string) *shared.PlanSettings {
	settings, err := originalSettings.DeepCopy()
	if err != nil {
		term.OutputErrorAndExit("Error copying settings: %v", err)
		return nil
	}

	builtInModelPacks := shared.BuiltInModelPacks
	if auth.Current.IsCloud {
		filtered := []*shared.ModelPack{}
		for _, ms := range builtInModelPacks {
			if ms.LocalProvider == "" {
				filtered = append(filtered, ms)
			}
		}
		builtInModelPacks = filtered
	}

	var customModelPacks []*shared.ModelPack
	var defaultConfig *shared.PlanConfig
	var planConfig *shared.PlanConfig

	errCh := make(chan error, 3)

	go func() {
		var apiErr *shared.ApiError
		customModelPacks, apiErr = api.Client.ListModelPacks()
		if apiErr != nil {
			errCh <- fmt.Errorf("error getting custom model packs: %v", apiErr.Msg)
			return
		}
		errCh <- nil
	}()

	go func() {
		var apiErr *shared.ApiError
		defaultConfig, apiErr = api.Client.GetDefaultPlanConfig()
		if apiErr != nil {
			errCh <- fmt.Errorf("error getting default config: %v", apiErr.Msg)
			return
		}

		errCh <- nil
	}()

	go func() {
		if lib.CurrentPlanId != "" {
			var apiErr *shared.ApiError
			planConfig, apiErr = api.Client.GetPlanConfig(lib.CurrentPlanId)
			if apiErr != nil {
				errCh <- fmt.Errorf("error getting plan config: %v", apiErr.Msg)
				return
			}
		}
		errCh <- nil
	}()

	for i := 0; i < 3; i++ {
		err := <-errCh
		if err != nil {
			term.OutputErrorAndExit(err.Error())
			return nil
		}
	}

	useJsonFile := setModelUseJsonFile || setModelSave

	var nameArg string
	if len(args) > 0 {
		nameArg = args[0]
	}

	if !useJsonFile {
		if nameArg == "" {
			term.StopSpinner()
			const modelPackOpt = "Select a model pack"
			const jsonOpt = "Edit model settings JSON"

			selection, err := term.SelectFromList("Select a model pack or edit settings?", []string{modelPackOpt, jsonOpt})
			if err != nil {
				if err.Error() == "interrupt" {
					return nil
				}
			}

			if selection == modelPackOpt {
				useJsonFile = false
			} else {
				useJsonFile = true
				term.StartSpinner("")
			}
		}
	}

	if useJsonFile {
		usingDefaultPath := false
		if setModelJsonFilePath == "" {
			usingDefaultPath = true
			setModelJsonFilePath = defaultPath
		}

		exists, err := fs.FileExists(setModelJsonFilePath)
		if err != nil {
			term.OutputErrorAndExit("Error checking model settings file: %v", err)
			return nil
		}

		if setModelSave {
			if !exists {
				term.OutputErrorAndExit("File not found: %s", customModelsPath)
			}
		} else {
			if usingDefaultPath && exists {
				modelSettingsCheckLocalChangesResult, err := lib.ModelSettingsCheckLocalChanges(setModelJsonFilePath)
				if err != nil {
					term.OutputErrorAndExit("Error checking model settings file: %v", err)
					return nil
				}

				if modelSettingsCheckLocalChangesResult.HasLocalChanges {
					term.StopSpinner()

					res, err := warnModelsFileLocalChanges(setModelJsonFilePath, "set-model")
					if err != nil {
						term.OutputErrorAndExit("Error confirming: %v", err)
						return nil
					}
					if !res {
						return nil
					}

					fmt.Println()
					term.StartSpinner("")
				}
			}

			err = lib.WriteModelSettingsFile(setModelJsonFilePath, originalSettings)
			if err != nil {
				term.OutputErrorAndExit("Error writing model settings file: %v", err)
				return nil
			}

			term.StopSpinner()
			fmt.Printf("🧠 %s → %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Models file"), setModelJsonFilePath)
			fmt.Println("👨‍💻 Edit it, then come back here to save")
			fmt.Println()

			pathArg := ""
			if !usingDefaultPath {
				pathArg = fmt.Sprintf(" --file %s", setModelJsonFilePath)
			}

			res := maybePromptAndOpenModelsFile(setModelJsonFilePath, pathArg, "set-model", defaultConfig, planConfig)
			if res.shouldReturn {
				return nil
			}
		}

		term.StartSpinner("")

		settings, err = lib.ApplyModelSettings(setModelJsonFilePath, originalSettings)

		if err != nil {
			term.OutputErrorAndExit("Error applying model settings: %v", err)
			return nil
		}

	} else {
		if nameArg == "" {
			var names []string
			var opts []string
			for _, ms := range builtInModelPacks {
				names = append(names, ms.Name)
				opts = append(opts, "Built-in | "+ms.Name)
			}
			for _, ms := range customModelPacks {
				names = append(names, ms.Name)
				opts = append(opts, "Custom | "+ms.Name)
			}

			term.StopSpinner()
			selection, err := term.SelectFromList("Select a model pack:", opts)
			if err != nil {
				if err.Error() == "interrupt" {
					return nil
				}
			}

			for i, opt := range opts {
				if opt == selection {
					nameArg = names[i]
					break
				}
			}
		}

		var modelPackName string
		compare := strings.ToLower(strings.TrimSpace(nameArg))
		if compare == "daily" {
			compare = "daily-driver"
		}
		if compare == "opus-4-planner" {
			compare = "opus-planner"
		}

		for _, ms := range builtInModelPacks {
			if strings.EqualFold(ms.Name, compare) {
				modelPackName = ms.Name
				break
			}
		}
		for _, ms := range customModelPacks {
			if strings.EqualFold(ms.Name, compare) {
				modelPackName = ms.Name
				break
			}
		}

		if modelPackName == "" {
			term.StopSpinner()
			term.OutputSimpleError("No model pack found with name '%s'", nameArg)
			fmt.Println()
			term.PrintCmds("", "model-packs")
			os.Exit(1)
			return nil
		}

		settings.SetModelPackByName(modelPackName)

		// clear the default settings file and hash file if they exist, ignoring errors
		os.Remove(defaultPath)
		os.Remove(defaultPath + ".hash")
	}

	term.StopSpinner()

	if originalSettings.Equals(settings) {
		fmt.Println("🤷‍♂️ No model settings were updated")
		return nil
	} else {
		return settings
	}
}


================================================
FILE: app/cli/cmd/sign_in.go
================================================
package cmd

import (
	"plandex-cli/auth"
	"plandex-cli/term"

	"github.com/spf13/cobra"
)

var pin string

var signInCmd = &cobra.Command{
	Use:   "sign-in",
	Short: "Sign in to a Plandex account",
	Args:  cobra.NoArgs,
	Run:   signIn,
}

func init() {
	RootCmd.AddCommand(signInCmd)

	signInCmd.Flags().StringVar(&pin, "pin", "", "Sign in with a pin from the Plandex Cloud web UI")
}

func signIn(cmd *cobra.Command, args []string) {
	if pin != "" {
		err := auth.SignInWithCode(pin, "")

		if err != nil {
			term.OutputErrorAndExit("Error signing in: %v", err)
		}

		return
	}

	err := auth.SelectOrSignInOrCreate()

	if err != nil {
		term.OutputErrorAndExit("Error signing in: %v", err)
	}
}


================================================
FILE: app/cli/cmd/stop.go
================================================
package cmd

import (
	"context"
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/spf13/cobra"
)

var stopCmd = &cobra.Command{
	Use:   "stop [stream-id-or-plan] [branch]",
	Short: "Connect to an active stream",
	// Long:  ``,
	Args: cobra.MaximumNArgs(2),
	Run:  stop,
}

func init() {
	RootCmd.AddCommand(stopCmd)
}

func stop(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		term.OutputNoCurrentPlanErrorAndExit()
	}

	planId, branch, shouldContinue := lib.SelectActiveStream(args)

	if !shouldContinue {
		return
	}

	term.StartSpinner("")
	apiErr := api.Client.StopPlan(context.Background(), planId, branch)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error stopping stream: %v", apiErr.Msg)
	}

	fmt.Println("✅ Plan stream stopped")

	fmt.Println()
	term.PrintCmds("", "convo", "log")

}


================================================
FILE: app/cli/cmd/summary.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/spf13/cobra"
)

var summaryPlain bool

var statusCmd = &cobra.Command{
	Use:   "summary",
	Short: "Show the latest summary of the current plan",
	Run:   status,
}

func init() {
	RootCmd.AddCommand(statusCmd)

	statusCmd.Flags().BoolVarP(&summaryPlain, "plain", "p", false, "Output summary in plain text with no ANSI codes")
}

func status(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	term.StartSpinner("")
	status, apiErr := api.Client.GetPlanStatus(lib.CurrentPlanId, lib.CurrentBranch)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error loading conversation: %v", apiErr.Msg)
	}

	if status == "" {
		fmt.Println("🤷‍♂️ No summary available")
	}

	if summaryPlain {
		fmt.Println(status)
		return
	}

	md, err := term.GetMarkdown(status)

	if err != nil {
		term.OutputErrorAndExit("Error formatting markdown: %v", err)
	}

	fmt.Println(md)
}


================================================
FILE: app/cli/cmd/tell.go
================================================
package cmd

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"os/exec"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/term"
	"plandex-cli/types"
	"strings"

	shared "plandex-shared"

	"github.com/spf13/cobra"
)

var isImplementationOfChat bool

// tellCmd represents the prompt command
var tellCmd = &cobra.Command{
	Use:     "tell [prompt]",
	Aliases: []string{"t"},
	Short:   "Send a prompt for the current plan",
	// Long:  ``,
	Args: cobra.RangeArgs(0, 1),
	Run:  doTell,
}

func init() {
	RootCmd.AddCommand(tellCmd)

	initExecFlags(tellCmd, initExecFlagsParams{})

	tellCmd.Flags().BoolVar(&isImplementationOfChat, "from-chat", false, "Begin implementation based on conversation so far")
}

func doTell(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()
	mustSetPlanExecFlags(cmd, false)

	if isImplementationOfChat && len(args) > 0 {
		term.OutputErrorAndExit("Error: --from-chat cannot be used with a prompt")
	}

	var prompt string
	if !isImplementationOfChat {
		prompt = getTellPrompt(args)

		if prompt == "" {
			fmt.Println("🤷‍♂️ No prompt to send")
			return
		}
	}

	tellFlags := types.TellFlags{
		TellBg:                 tellBg,
		TellStop:               tellStop,
		TellNoBuild:            tellNoBuild,
		AutoContext:            tellAutoContext,
		SmartContext:           tellSmartContext,
		ExecEnabled:            !noExec,
		AutoApply:              tellAutoApply,
		IsImplementationOfChat: isImplementationOfChat,
		SkipChangesMenu:        tellSkipMenu,
	}

	plan_exec.TellPlan(plan_exec.ExecParams{
		CurrentPlanId: lib.CurrentPlanId,
		CurrentBranch: lib.CurrentBranch,
		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
			auto := autoConfirm || tellAutoApply || tellAutoContext
			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
		},
	}, prompt, tellFlags)

	if tellAutoApply {
		applyFlags := types.ApplyFlags{
			AutoConfirm: true,
			AutoCommit:  autoCommit,
			NoCommit:    !autoCommit,
			NoExec:      noExec,
			AutoExec:    autoExec || autoDebug > 0,
			AutoDebug:   autoDebug,
		}

		lib.MustApplyPlan(lib.ApplyPlanParams{
			PlanId:     lib.CurrentPlanId,
			Branch:     lib.CurrentBranch,
			ApplyFlags: applyFlags,
			TellFlags:  tellFlags,
			OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
		})
	}
}

func getTellPrompt(args []string) string {
	var prompt string
	var pipedData string

	if len(args) > 0 {
		prompt = args[0]
	} else if tellPromptFile != "" {
		bytes, err := os.ReadFile(tellPromptFile)
		if err != nil {
			term.OutputErrorAndExit("Error reading prompt file: %v", err)
		}
		prompt = string(bytes)
	}

	// Check if there's piped input
	fileInfo, err := os.Stdin.Stat()
	if err != nil {
		term.OutputErrorAndExit("Failed to stat stdin: %v", err)
	}

	if fileInfo.Mode()&os.ModeNamedPipe != 0 {
		reader := bufio.NewReader(os.Stdin)
		pipedDataBytes, err := io.ReadAll(reader)
		if err != nil {
			term.OutputErrorAndExit("Failed to read piped data: %v", err)
		}
		pipedData = string(pipedDataBytes)
	}

	if prompt == "" && pipedData == "" {
		prompt = getEditorPrompt()
	} else if pipedData != "" {
		if prompt != "" {
			prompt = fmt.Sprintf("%s\n\n---\n\n%s", prompt, pipedData)
		} else {
			prompt = pipedData
		}
	}

	return prompt
}

func prepareEditorCommand(editor string, filename string) *exec.Cmd {
	switch editor {
	case "vim":
		return exec.Command(editor, "+normal G$", "+startinsert!", filename)
	case "nano":
		return exec.Command(editor, "+99999999", filename)
	default:
		return exec.Command(editor, filename)
	}
}

func getEditorInstructions() string {
	if editor == EditorTypeVim {
		return "👉  Write your prompt below, then save and exit to send it to Plandex.\n• To save and exit, press ESC, then type :wq! and press ENTER.\n• To exit without saving, press ESC, then type :q! and press ENTER.\n\n\n"
	}

	if editor == EditorTypeNano {
		return "👉  Write your prompt below, then save and exit to send it to Plandex.\n• To save and exit, press Ctrl+X, then Y, then ENTER.\n• To exit without saving, press Ctrl+X, then N.\n\n\n"
	}

	return "👉  Write your prompt below, then save and exit to send it to Plandex.\n\n\n"
}

func getEditorPrompt() string {
	tempFile, err := os.CreateTemp(os.TempDir(), "plandex_prompt_*")
	if err != nil {
		term.OutputErrorAndExit("Failed to create temporary file: %v", err)
	}

	instructions := getEditorInstructions()
	filename := tempFile.Name()
	err = os.WriteFile(filename, []byte(instructions), 0644)
	if err != nil {
		term.OutputErrorAndExit("Failed to write instructions to temporary file: %v", err)
	}

	editorCmd := prepareEditorCommand(editor, filename)
	editorCmd.Stdin = os.Stdin
	editorCmd.Stdout = os.Stdout
	editorCmd.Stderr = os.Stderr
	err = editorCmd.Run()
	if err != nil {
		term.OutputErrorAndExit("Error opening editor: %v", err)
	}

	bytes, err := os.ReadFile(tempFile.Name())
	if err != nil {
		term.OutputErrorAndExit("Error reading temporary file: %v", err)
	}

	prompt := string(bytes)

	err = os.Remove(tempFile.Name())
	if err != nil {
		term.OutputErrorAndExit("Error removing temporary file: %v", err)
	}

	prompt = strings.TrimPrefix(prompt, strings.TrimSpace(instructions))
	prompt = strings.TrimSpace(prompt)

	return prompt

}

// func maybeShowDiffs() {
// 	diffs, err := api.Client.GetPlanDiffs(lib.CurrentPlanId, lib.CurrentBranch, plainTextOutput || showDiffUi)
// 	if err != nil {
// 		term.OutputErrorAndExit("Error getting plan diffs: %v", err)
// 		return
// 	}

// 	if len(diffs) > 0 {
// 		cmd := exec.Command(os.Args[0], "diffs", "--ui")

// 		// Create a context that's cancelled when the program exits
// 		ctx, cancel := context.WithCancel(context.Background())

// 		// Ensure cleanup on program exit
// 		go func() {
// 			// Wait for program exit signal
// 			c := make(chan os.Signal, 1)
// 			signal.Notify(c, os.Interrupt, syscall.SIGTERM)
// 			<-c

// 			// Cancel context and kill the process
// 			cancel()
// 			if cmd.Process != nil {
// 				cmd.Process.Kill()
// 			}
// 		}()

// 		go func() {
// 			if err := cmd.Start(); err != nil {
// 				fmt.Fprintf(os.Stderr, "Error starting diffs command: %v\n", err)
// 				return
// 			}

// 			// Wait in a separate goroutine
// 			go cmd.Wait()

// 			// Wait for either context cancellation or process completion
// 			<-ctx.Done()
// 			if cmd.Process != nil {
// 				cmd.Process.Kill()
// 			}
// 		}()

// 		// Give the UI a moment to start
// 		time.Sleep(100 * time.Millisecond)
// 	}
// }


================================================
FILE: app/cli/cmd/unarchive.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/spf13/cobra"
)

var unarchiveCmd = &cobra.Command{
	Use:     "unarchive [name-or-index]",
	Aliases: []string{"unarc"},
	Short:   "Unarchive a plan",
	Args:    cobra.MaximumNArgs(1),
	Run:     unarchive,
}

func init() {
	RootCmd.AddCommand(unarchiveCmd)
}

func unarchive(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	var nameOrIdx string
	if len(args) > 0 {
		nameOrIdx = strings.TrimSpace(args[0])
	}

	var plan *shared.Plan

	term.StartSpinner("")
	plans, apiErr := api.Client.ListArchivedPlans([]string{lib.CurrentProjectId})
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting archived plans: %v", apiErr)
	}

	if len(plans) == 0 {
		fmt.Println("🤷‍♂️ No archived plans")
		return
	}

	if nameOrIdx == "" {
		opts := make([]string, len(plans))
		for i, p := range plans {
			opts[i] = p.Name
		}

		selected, err := term.SelectFromList("Select a plan:", opts)
		if err != nil {
			term.OutputErrorAndExit("Error selecting plan: %v", err)
		}

		for _, p := range plans {
			if p.Name == selected {
				plan = p
				break
			}
		}
	} else {
		idx, err := strconv.Atoi(nameOrIdx)
		if err == nil && idx > 0 && idx <= len(plans) {
			plan = plans[idx-1]
		} else {
			for _, p := range plans {
				if p.Name == nameOrIdx {
					plan = p
					break
				}
			}
		}
	}

	if plan == nil {
		term.OutputErrorAndExit("Plan not found")
	}

	err := api.Client.UnarchivePlan(plan.Id)
	if err != nil {
		term.OutputErrorAndExit("Error unarchiving plan: %v", err)
	}

	fmt.Printf("✅ Plan %s unarchived\n", color.New(color.Bold, term.ColorHiGreen).Sprint(plan.Name))

	fmt.Println()
	term.PrintCmds("", "plans", "current")
}


================================================
FILE: app/cli/cmd/update.go
================================================
package cmd

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/term"

	"github.com/spf13/cobra"
)

var updateCmd = &cobra.Command{
	Use:     "update ",
	Aliases: []string{"u"},
	Short:   "Update outdated context",
	Args:    cobra.MaximumNArgs(1),
	Run:     update,
}

func init() {
	RootCmd.AddCommand(updateCmd)

}

func update(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	term.StartSpinner("")

	contexts, apiErr := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("failed to list context: %s", apiErr)
	}

	paths, err := fs.GetProjectPaths(fs.ProjectRoot)

	if err != nil {
		term.OutputErrorAndExit("error getting project paths: %v", err)
	}

	outdated, err := lib.CheckOutdatedContext(contexts, paths)

	if err != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("failed to check outdated context: %s", err)
	}

	if len(outdated.UpdatedContexts) == 0 {
		term.StopSpinner()
		fmt.Println("✅ Context is up to date")
		return
	}

	lib.UpdateContextWithOutput(lib.UpdateContextParams{
		Contexts:    contexts,
		OutdatedRes: *outdated,
		ReqFn:       outdated.ReqFn,
	})
}


================================================
FILE: app/cli/cmd/usage.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	shared "plandex-shared"
	"sort"
	"strconv"
	"strings"
	"time"
	"unicode"

	"github.com/eiannone/keyboard"
	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
	"github.com/shopspring/decimal"
	"github.com/spf13/cobra"
)

const MaxCreditsLogPageSize = 500

var logCreditsPageSize int
var logCreditsPage int

var logCreditsDebitsOnly bool
var logCreditsCreditsOnly bool

var showUsageLog bool

var creditsSession bool
var creditsToday bool
var creditsMonth bool
var creditsCurrentPlan bool

var usageCmd = &cobra.Command{
	Use:   "usage",
	Short: "Display credits balance and usage report",
	Run:   usage,
}

func init() {
	RootCmd.AddCommand(usageCmd)

	usageCmd.Flags().BoolVar(&showUsageLog, "log", false, "Show usage log")
	usageCmd.Flags().IntVarP(&logCreditsPageSize, "page-size", "s", 100, "Number of transactions to display per page")
	usageCmd.Flags().IntVarP(&logCreditsPage, "page", "p", 1, "Page number to display")
	usageCmd.Flags().BoolVar(&logCreditsDebitsOnly, "debits", false, "Show only debits in the log")
	usageCmd.Flags().BoolVar(&logCreditsCreditsOnly, "purchases", false, "Show only purchases in the log")

	usageCmd.Flags().BoolVar(&creditsToday, "today", false, "Show usage for today")
	usageCmd.Flags().BoolVar(&creditsMonth, "month", false, "Show usage for current billing month")
	usageCmd.Flags().BoolVar(&creditsCurrentPlan, "plan", false, "Show usage for the current plan")
}

func usage(cmd *cobra.Command, args []string) {
	if showUsageLog {
		showLog(cmd, args)
	} else {
		showUsage()
	}
}

func showUsage() {
	auth.MustResolveAuthWithOrg()

	term.StartSpinner("")

	if !(creditsSession || creditsToday || creditsMonth || creditsCurrentPlan) {
		if os.Getenv("PLANDEX_REPL_SESSION_ID") != "" {
			creditsSession = true
		} else {
			creditsToday = true
		}
	}

	var sessionId string
	if creditsSession {
		sessionId = os.Getenv("PLANDEX_REPL_SESSION_ID")
		if sessionId == "" {
			term.OutputErrorAndExit("Session ID is not set. The --session flag should be used in the Plandex REPL.")
		}
	}

	var dayStart *time.Time
	if creditsToday {
		now := time.Now()
		midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		dayStart = &midnight
	}

	var planId string
	var currentPlanName string
	if creditsCurrentPlan {
		lib.MustResolveProject()
		planId = lib.CurrentPlanId
		plan, apiErr := api.Client.GetPlan(planId)
		if apiErr != nil {
			term.OutputErrorAndExit("Error getting plan: %v", apiErr)
		}
		currentPlanName = plan.Name
	}

	req := shared.CreditsLogRequest{
		SessionId: sessionId,
		DayStart:  dayStart,
		Month:     creditsMonth,
		PlanId:    planId,
	}

	res, apiErr := api.Client.GetCreditsSummary(req)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting credits summary: %v", apiErr)
	}

	builder := strings.Builder{}

	balance := res.Balance
	balanceStr := formatSpend(balance)

	spendLbl := "💸 Spent"
	if creditsSession {
		spendLbl += " This Session"
	} else if creditsToday {
		spendLbl += " Today"
	} else if creditsMonth {
		spendLbl += " This Billing Month"
		spendLbl += fmt.Sprintf(" (since %s)", res.MonthStart.Format("Jan 2"))
	} else if creditsCurrentPlan {
		spendLbl += fmt.Sprintf(" On Plan 📋 %s", currentPlanName)
	}

	var spendStr string
	if res.TotalSpend.IsZero() {
		spendStr = "$0.00"
	} else {
		spendStr = formatSpend(res.TotalSpend)
	}

	table := tablewriter.NewWriter(&builder)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{"💰 Current Balance", spendLbl})
	table.Append([]string{balanceStr, spendStr})
	table.Render()
	fmt.Fprintln(&builder)

	if !res.CacheSavings.IsZero() {
		table := tablewriter.NewWriter(&builder)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"🎯 Cache Savings"})
		table.Append([]string{formatSpend(res.CacheSavings)})
		table.Render()
		fmt.Fprintln(&builder)
	}

	amountByStr := map[string]float64{}
	if len(res.ByPlanId) > 0 {
		if !creditsCurrentPlan {
			table := tablewriter.NewWriter(&builder)
			table.SetAutoWrapText(false)
			table.SetHeader([]string{"📋 Plan", "💸 Spent"})

			rows := [][]string{}

			for id, spend := range res.ByPlanId {
				name := res.PlanNamesById[id]
				spendStr := formatSpend(spend)
				rows = append(rows, []string{name, spendStr})
				amountByStr[spendStr] = spend.InexactFloat64()
			}
			sort.Slice(rows, func(i, j int) bool {
				return amountByStr[rows[i][1]] > amountByStr[rows[j][1]]
			})
			for _, row := range rows {
				table.Append(row)
			}

			table.Render()
			fmt.Fprintln(&builder)
		}
	}

	if len(res.ByPurpose) > 0 {
		table = tablewriter.NewWriter(&builder)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"⚡️ Purpose", "💸 Spent"})

		rows := [][]string{}
		for name, spend := range res.ByPurpose {
			spendStr := formatSpend(spend)
			rows = append(rows, []string{name, spendStr})
			amountByStr[spendStr] = spend.InexactFloat64()
		}
		sort.Slice(rows, func(i, j int) bool {
			return amountByStr[rows[i][1]] > amountByStr[rows[j][1]]
		})
		for _, row := range rows {
			table.Append(row)
		}

		table.Render()
		fmt.Fprintln(&builder)
	}

	if len(res.ByModelName) > 0 {
		table = tablewriter.NewWriter(&builder)
		table.SetAutoWrapText(false)
		table.SetHeader([]string{"🤖 Model", "💸 Spent"})

		rows := [][]string{}
		for name, spend := range res.ByModelName {
			spendStr := formatSpend(spend)
			rows = append(rows, []string{name, spendStr})
			amountByStr[spendStr] = spend.InexactFloat64()
		}
		sort.Slice(rows, func(i, j int) bool {
			return amountByStr[rows[i][1]] > amountByStr[rows[j][1]]
		})
		for _, row := range rows {
			table.Append(row)
		}
		table.Render()
		fmt.Fprintln(&builder)
	}

	term.PageOutput(builder.String())

	term.PrintCmds("", "usage", "billing")
}

func showLog(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	if !(creditsSession || creditsToday || creditsMonth || creditsCurrentPlan) {
		if os.Getenv("PLANDEX_REPL_SESSION_ID") != "" {
			creditsSession = true
		} else {
			creditsToday = true
		}
	}

	term.StartSpinner("")

	var transactionType shared.CreditsTransactionType

	if logCreditsDebitsOnly {
		transactionType = shared.CreditsTransactionTypeDebit
	} else if logCreditsCreditsOnly {
		transactionType = shared.CreditsTransactionTypeCredit
	}

	var sessionId string
	if creditsSession {
		sessionId = os.Getenv("PLANDEX_REPL_SESSION_ID")
		if sessionId == "" {
			term.OutputErrorAndExit("Session ID is not set. The --session flag should be used in the Plandex REPL.")
		}
	}

	var dayStart *time.Time
	if creditsToday {
		now := time.Now()
		midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		dayStart = &midnight
	}

	var planId string
	var planName string
	if creditsCurrentPlan {
		lib.MustResolveProject()
		planId = lib.CurrentPlanId

		plan, err := api.Client.GetPlan(planId)
		if err != nil {
			term.OutputErrorAndExit("Error getting plan: %v", err)
			return
		}
		planName = plan.Name
	}

	req := shared.CreditsLogRequest{
		TransactionType: transactionType,
		SessionId:       sessionId,
		DayStart:        dayStart,
		Month:           creditsMonth,
		PlanId:          planId,
	}

	res, apiErr := api.Client.GetCreditsTransactions(logCreditsPageSize, logCreditsPage, req)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting credits transactions: %v", apiErr)
		return
	}

	transactions := res.Transactions

	if len(transactions) == 0 {
		lbl := "🤷‍♂️ No usage"
		if sessionId != "" {
			lbl = "🤷‍♂️ No usage so far this session"
		} else if creditsToday {
			tz, _ := time.Now().Zone()
			lbl = fmt.Sprintf("🤷‍♂️ No usage so far today (since midnight %s)", tz)
		} else if creditsMonth {
			lbl = fmt.Sprintf("🤷‍♂️ No usage so far this billing month (since %s)", res.MonthStart.Format("Jan 2"))
		} else if creditsCurrentPlan {
			lbl = "🤷‍♂️ No usage so far for current plan 👉 " + planName
		}
		fmt.Println(lbl)
		return
	}

	tableString := &strings.Builder{}
	table := tablewriter.NewWriter(tableString)
	table.SetAutoWrapText(false)
	table.SetHeader([]string{"Amount", "Balance", "Transaction"})

	for _, transaction := range transactions {
		var sign string
		var c color.Attribute

		desc := transaction.CreatedAt.Local().Format("2006-01-02 15:04:05.000 EST") + "\n"

		if transaction.TransactionType == "debit" {
			sign = "-"
			c = term.ColorHiRed

			if transaction.DebitPlanId != nil {
				planName := res.PlanNamesById[*transaction.DebitPlanId]
				desc += fmt.Sprintf("Plan → %s\n", planName)
			}

			surchargePct := transaction.DebitSurcharge.Div(*transaction.DebitBaseAmount)

			inputPrice := transaction.DebitModelInputPricePerToken.Mul(decimal.NewFromInt(1000000)).Mul(surchargePct.Add(decimal.NewFromInt(1))).StringFixed(4)
			outputPrice := transaction.DebitModelOutputPricePerToken.Mul(decimal.NewFromInt(1000000)).Mul(surchargePct.Add(decimal.NewFromInt(1))).StringFixed(4)

			var cacheDiscountStr string
			var cacheDiscountPct float64
			if transaction.DebitCacheDiscount != nil {
				cacheDiscountStr = transaction.DebitCacheDiscount.StringFixed(4)
				totalAmount := transaction.DebitBaseAmount.Add(*transaction.DebitCacheDiscount)
				cacheDiscountPct = transaction.DebitCacheDiscount.Div(totalAmount).Mul(decimal.NewFromInt(100)).InexactFloat64()
			}

			for i := 0; i < 2; i++ {
				inputPrice = strings.TrimSuffix(inputPrice, "0")
				outputPrice = strings.TrimSuffix(outputPrice, "0")
				cacheDiscountStr = strings.TrimSuffix(cacheDiscountStr, "0")
			}

			desc += fmt.Sprintf("⚡️ %s\n", *transaction.DebitPurpose)
			desc += fmt.Sprintf("🧠 %s\n", transaction.ModelString())
			desc += fmt.Sprintf("💳 Price → $%s input / $%s output per 1M\n", inputPrice, outputPrice)
			desc += fmt.Sprintf("🪙 Used → %d input / %d output\n", *transaction.DebitInputTokens, *transaction.DebitOutputTokens)

			if cacheDiscountStr != "" {
				desc += fmt.Sprintf("🎯 Cache discount → $%s (%d%%)\n", cacheDiscountStr, int(cacheDiscountPct))
			}

		} else {
			sign = "+"
			c = term.ColorHiGreen

			switch *transaction.CreditType {
			case shared.CreditTypeGrant:
				desc += "Monthly subscription payment"
			case shared.CreditTypeTrial:
				desc += "Started trial"
			case shared.CreditTypePurchase:
				desc += "Purchased credits"
			case shared.CreditTypeSwitch:
				desc += "Switched to Integrated Models mode"
			}

			desc += "\n"
		}

		amountStr := transaction.Amount.StringFixed(6)
		for i := 0; i < 4; i++ {
			amountStr = strings.TrimSuffix(amountStr, "0")
		}

		balanceStr := transaction.EndBalance.StringFixed(4)
		for i := 0; i < 2; i++ {
			balanceStr = strings.TrimSuffix(balanceStr, "0")
		}

		table.Append([]string{
			color.New(c).Sprint(sign + "$" + amountStr),
			"$" + balanceStr,

			desc,
		})
	}

	table.Render()

	var output string
	var pageLine string

	if res.NumPages > 1 {
		pageLine = fmt.Sprintf("Page size %d. Showing page %d of %d", logCreditsPageSize, logCreditsPage, res.NumPages)
		if res.NumPagesMax {
			pageLine = "+"
		}
		output = pageLine + "\n\n" + tableString.String()
	} else {
		output = tableString.String()
	}

	term.PageOutput(output)

	var inputFn func()
	inputFn = func() {
		fmt.Println("\n" + pageLine)

		prompts := []string{}

		if res.NumPages > 1 && logCreditsPage < res.NumPages {
			prompts = append(prompts, "Press 'n' for next page")
		}

		if logCreditsPage > 1 {
			prompts = append(prompts, "Press 'p' for previous page")
		}

		prompts = append(prompts, "Type any number and press enter to jump to a page")

		prompts = append(prompts, "Press 'q' to quit")

		color.New(term.ColorHiMagenta, color.Bold).Println(strings.Join(prompts, "\n"))
		color.New(term.ColorHiMagenta, color.Bold).Print("> ")

		char, _, err := term.GetUserKeyInput()

		if err != nil {
			term.OutputErrorAndExit("Failed to get user input: %v", err)
		}

		// Check if the input is a digit
		if unicode.IsDigit(char) {
			var numberInput strings.Builder
			numberInput.WriteRune(char)

			fmt.Print(string(char)) // Show the initial digit

			for {
				char, key, err := term.GetUserKeyInput()
				if err != nil {
					term.OutputErrorAndExit("Failed to get user input: %v", err)
				}

				// If Enter is pressed, commit the input
				if key == keyboard.KeyEnter {
					pageNumber, err := strconv.Atoi(numberInput.String())
					if err != nil {
						fmt.Println("Invalid page number.")
						return
					}

					// Check if the page number is valid
					if pageNumber >= 1 && (pageNumber <= res.NumPages || res.NumPagesMax) {
						logCreditsPage = pageNumber
						showLog(cmd, args) // Re-run the log command with the new page
					} else {
						fmt.Println()
						fmt.Println("Invalid page number.")
						inputFn()
					}
					return
				}

				// If another digit is pressed, add it to the input
				if unicode.IsDigit(char) {
					numberInput.WriteRune(char)
					fmt.Print(string(char)) // Show the digit
				} else if key == keyboard.KeyBackspace || key == keyboard.KeyBackspace2 {
					// Handle backspace
					if numberInput.Len() > 0 {
						// Remove the last rune
						input := numberInput.String()
						numberInput.Reset()
						numberInput.WriteString(input[:len(input)-1])
						fmt.Print("\b \b") // Erase the digit
					}

				} else {
					// Handle invalid input while typing a number
					fmt.Println()
					fmt.Println("\nInvalid input. Please enter a valid page number.")
					inputFn()
					return
				}
			}
		}

		// Handle non-digit hotkeys
		fmt.Print(string(char))
		switch char {
		case 'n':
			if logCreditsPage < res.NumPages || res.NumPagesMax {
				logCreditsPage++
				showLog(cmd, args)
			} else {
				fmt.Println()
				fmt.Println("Already on last page.")
				inputFn()
			}
		case 'p':
			if logCreditsPage > 1 {
				logCreditsPage--
				showLog(cmd, args)
			} else {
				fmt.Println()
				fmt.Println("Already on first page.")
				inputFn()
			}
		case 'q':
			fmt.Println()
			return
		default:
			fmt.Println()
			fmt.Println("Invalid input.")
			inputFn()
		}

	}

	if res.NumPages > 1 {
		inputFn()
	}
}

func formatSpend(spend decimal.Decimal) string {
	if spend.IsZero() {
		return "$0.00"
	}

	spendStr := fmt.Sprintf("$%s", spend.StringFixed(4))
	for i := 0; i < 2; i++ {
		if strings.HasSuffix(spendStr, "0") {
			spendStr = spendStr[:len(spendStr)-1]
		}
	}
	if spendStr == "$0.00" {
		return "<$0.0001"
	}
	return spendStr
}


================================================
FILE: app/cli/cmd/users.go
================================================
package cmd

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/term"

	shared "plandex-shared"

	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var usersCmd = &cobra.Command{
	Use:   "users",
	Short: "List all users and pending invites and the current org",
	Run:   listUsersAndInvites,
}

func init() {
	RootCmd.AddCommand(usersCmd)
}

func listUsersAndInvites(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()

	var userResp *shared.ListUsersResponse
	var pendingInvites []*shared.Invite
	var orgRoles []*shared.OrgRole

	errCh := make(chan error)

	term.StartSpinner("")

	go func() {
		var err *shared.ApiError
		userResp, err = api.Client.ListUsers()
		if err != nil {
			errCh <- fmt.Errorf("error fetching users: %s", err.Msg)
			return
		}
		errCh <- nil
	}()

	go func() {
		var err *shared.ApiError
		pendingInvites, err = api.Client.ListPendingInvites()
		if err != nil {
			errCh <- fmt.Errorf("error fetching pending invites: %s", err.Msg)
			return
		}
		errCh <- nil
	}()

	go func() {
		var err *shared.ApiError
		orgRoles, err = api.Client.ListOrgRoles()
		if err != nil {
			errCh <- fmt.Errorf("error fetching org roles: %s", err.Msg)
			return
		}
		errCh <- nil

	}()

	for i := 0; i < 3; i++ {
		err := <-errCh
		if err != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("%v", err)
		}
	}

	term.StopSpinner()

	orgRolesById := make(map[string]*shared.OrgRole)
	for _, role := range orgRoles {
		orgRolesById[role.Id] = role
	}

	// Display users and pending invites in a table
	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"Email", "Name", "Role", "Status"})

	for _, user := range userResp.Users {
		table.Append([]string{user.Email, user.Name, orgRolesById[userResp.OrgUsersByUserId[user.Id].OrgRoleId].Label, "Active"})
	}

	for _, invite := range pendingInvites {
		table.Append([]string{invite.Email, invite.Name, orgRolesById[invite.OrgRoleId].Label, "Pending"})
	}

	table.Render()
}


================================================
FILE: app/cli/cmd/version.go
================================================
package cmd

import (
	"fmt"

	"plandex-cli/version"

	"github.com/spf13/cobra"
)

var versionCmd = &cobra.Command{
	Use:   "version",
	Short: "Print the version number of Plandex",
	Long:  `All software has versions. This is Plandex's`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println(version.Version)
	},
}

func init() {
	RootCmd.AddCommand(versionCmd)
}


================================================
FILE: app/cli/dev.sh
================================================
#!/usr/bin/env bash

OUT="${PLANDEX_DEV_CLI_OUT_DIR:-/usr/local/bin}"
NAME="${PLANDEX_DEV_CLI_NAME:-plandex-dev}"
ALIAS="${PLANDEX_DEV_CLI_ALIAS:-pdxd}"

# Double quote to prevent globbing and word splitting.
go build -o "$NAME" &&
    rm -f "$OUT"/"$NAME" &&
    cp "$NAME" "$OUT"/"$NAME" &&
    ln -sf "$OUT"/"$NAME" "$OUT"/"$ALIAS" &&
    echo built "$NAME" cli and added "$ALIAS" alias to "$OUT"


================================================
FILE: app/cli/format/file.go
================================================
package format

import (
	"path/filepath"
	"strings"
)

func GetFileNameWithoutExt(path string) string {
	name := path[:len(path)-len(filepath.Ext(path))]

	name = strings.ToLower(name)
	name = strings.ReplaceAll(name, "_", "-")
	name = strings.ReplaceAll(name, " ", "-")
	name = strings.ReplaceAll(name, ".", "-")
	name = strings.ReplaceAll(name, "/", "-")
	name = strings.ReplaceAll(name, "\\", "-")
	name = strings.ReplaceAll(name, "'", "")
	name = strings.ReplaceAll(name, "`", "")
	name = strings.ReplaceAll(name, "\"", "")

	return name
}


================================================
FILE: app/cli/format/time.go
================================================
// Adapted from https://raw.githubusercontent.com/dustin/go-humanize/master/times.go

package format

import (
	"fmt"
	"sort"
	"time"
)

// Seconds-based time units
const (
	Day      = 24 * time.Hour
	Week     = 7 * Day
	Month    = 30 * Day
	Year     = 12 * Month
	LongTime = 37 * Year
)

// Time formats a time into a relative string.
//
// Time(someT) -> "3 weeks ago"
func Time(then time.Time) string {
	return relTime(then.UTC(), time.Now().UTC(), "ago", "from now")
}

// A relTimeMagnitude struct contains a relative time point at which
// the relative format of time will switch to a new format string.  A
// slice of these in ascending order by their "D" field is passed to
// CustomRelTime to format durations.
//
// The Format field is a string that may contain a "%s" which will be
// replaced with the appropriate signed label (e.g. "ago" or "from
// now") and a "%d" that will be replaced by the quantity.
//
// The DivBy field is the amount of time the time difference must be
// divided by in order to display correctly.
//
// e.g. if D is 2*time.Minute and you want to display "%d minutes %s"
// DivBy should be time.Minute so whatever the duration is will be
// expressed in minutes.
type relTimeMagnitude struct {
	D     time.Duration
	Fn    func(diff time.Duration, lbl string) string
	DivBy time.Duration
}

var defaultMagnitudes = []relTimeMagnitude{
	{time.Second, func(diff time.Duration, lbl string) string { return "just now" }, time.Second},
	{2 * time.Second, func(diff time.Duration, lbl string) string { return fmt.Sprintf("1s %s", lbl) }, 1},
	{time.Minute, func(diff time.Duration, lbl string) string { return fmt.Sprintf("%ds %s", diff, lbl) }, time.Second},
	{2 * time.Minute, func(diff time.Duration, lbl string) string { return fmt.Sprintf("1m %s", lbl) }, 1},
	{time.Hour, func(diff time.Duration, lbl string) string { return fmt.Sprintf("%dm %s", diff, lbl) }, time.Minute},
	{2 * time.Hour, func(diff time.Duration, lbl string) string { return fmt.Sprintf("1h %s", lbl) }, 1},
	{Day, func(diff time.Duration, lbl string) string { return fmt.Sprintf("%dh %s", diff, lbl) }, time.Hour},
	{2 * Day, func(diff time.Duration, lbl string) string { return fmt.Sprintf("1d %s", lbl) }, 1},
	{Week, func(diff time.Duration, lbl string) string { return fmt.Sprintf("%dd %s", diff, lbl) }, Day},
	{2 * Week, func(diff time.Duration, lbl string) string { return fmt.Sprintf("1w %s", lbl) }, 1},
	{Month, func(diff time.Duration, lbl string) string { return fmt.Sprintf("%dw %s", diff, lbl) }, Week},
}

// RelTime(timeInPast, timeInFuture, "earlier", "later") -> "3 weeks earlier"
func relTime(a, b time.Time, albl, blbl string) string {
	return customRelTime(a, b, albl, blbl, defaultMagnitudes)
}

func customRelTime(a, b time.Time, albl, blbl string, magnitudes []relTimeMagnitude) string {
	lbl := albl
	diff := b.Sub(a)

	if a.After(b) {
		lbl = blbl
		diff = a.Sub(b)
	}

	// Find the largest magnitude
	largestMagnitude := magnitudes[len(magnitudes)-1].D

	// If the difference is greater than the largest magnitude, format the date in local time
	if diff >= largestMagnitude {
		return a.Local().Format("Jan 2 2006")
	}

	n := sort.Search(len(magnitudes), func(i int) bool {
		return magnitudes[i].D > diff
	})

	// If no magnitude is large enough, use the largest magnitude available
	if n >= len(magnitudes) {
		n = len(magnitudes) - 1
	}
	mag := magnitudes[n]

	if mag.DivBy == 1 {
		return mag.Fn(diff, lbl)
	}

	return mag.Fn(diff/mag.DivBy, lbl)
}


================================================
FILE: app/cli/fs/fs.go
================================================
package fs

import (
	"os"
	"os/exec"
	"path/filepath"
	"plandex-cli/term"
)

var Cwd string
var PlandexDir string
var ProjectRoot string
var HomePlandexDir string
var CacheDir string

var HomeDir string
var HomeAuthPath string
var HomeAccountsPath string

func init() {
	var err error
	Cwd, err = os.Getwd()
	if err != nil {
		term.OutputErrorAndExit("Error getting current working directory: %v", err)
	}

	home, err := os.UserHomeDir()
	if err != nil {
		term.OutputErrorAndExit("Couldn't find home dir: %v", err.Error())
	}
	HomeDir = home

	if os.Getenv("PLANDEX_ENV") == "development" {
		HomePlandexDir = filepath.Join(home, ".plandex-home-dev-v2")
	} else {
		HomePlandexDir = filepath.Join(home, ".plandex-home-v2")
	}

	// Create the home plandex directory if it doesn't exist
	err = os.MkdirAll(HomePlandexDir, os.ModePerm)
	if err != nil {
		term.OutputErrorAndExit(err.Error())
	}

	CacheDir = filepath.Join(HomePlandexDir, "cache")
	HomeAuthPath = filepath.Join(HomePlandexDir, "auth.json")
	HomeAccountsPath = filepath.Join(HomePlandexDir, "accounts.json")

	err = os.MkdirAll(filepath.Join(CacheDir, "tiktoken"), os.ModePerm)
	if err != nil {
		term.OutputErrorAndExit(err.Error())
	}
	err = os.Setenv("TIKTOKEN_CACHE_DIR", CacheDir)
	if err != nil {
		term.OutputErrorAndExit(err.Error())
	}

	FindPlandexDir()
	if PlandexDir != "" {
		ProjectRoot = Cwd
	}
}

func FindOrCreatePlandex() (string, bool, error) {
	FindPlandexDir()
	if PlandexDir != "" {
		ProjectRoot = Cwd
		return PlandexDir, false, nil
	}

	// Determine the directory path
	var dir string
	if os.Getenv("PLANDEX_ENV") == "development" {
		dir = filepath.Join(Cwd, ".plandex-dev-v2")
	} else {
		dir = filepath.Join(Cwd, ".plandex-v2")
	}

	err := os.Mkdir(dir, os.ModePerm)
	if err != nil {
		return "", false, err
	}
	PlandexDir = dir
	ProjectRoot = Cwd

	return dir, true, nil
}

func ProjectRootIsGitRepo() bool {
	if ProjectRoot == "" {
		return false
	}

	return IsGitRepo(ProjectRoot)
}

func IsGitRepo(dir string) bool {
	isGitRepo := false

	if isCommandAvailable("git") {
		// check whether we're in a git repo
		cmd := exec.Command("git", "rev-parse", "--is-inside-work-tree")

		cmd.Dir = dir

		err := cmd.Run()

		if err == nil {
			isGitRepo = true
		}
	}

	return isGitRepo
}

func FindPlandexDir() {
	PlandexDir = findPlandex(Cwd)
}

func findPlandex(baseDir string) string {
	var dir string
	if os.Getenv("PLANDEX_ENV") == "development" {
		dir = filepath.Join(baseDir, ".plandex-dev-v2")
	} else {
		dir = filepath.Join(baseDir, ".plandex-v2")
	}
	if _, err := os.Stat(dir); !os.IsNotExist(err) {
		return dir
	}

	return ""
}

func isCommandAvailable(name string) bool {
	cmd := exec.Command(name, "--version")
	if err := cmd.Run(); err != nil {
		return false
	}
	return true
}


================================================
FILE: app/cli/fs/paths.go
================================================
package fs

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"plandex-cli/types"
	"strings"
	"sync"

	shared "plandex-shared"

	ignore "github.com/sabhiram/go-gitignore"
)

func GetProjectPaths(baseDir string) (*types.ProjectPaths, error) {
	if ProjectRoot == "" {
		return nil, fmt.Errorf("no project root found")
	}

	return GetPaths(baseDir, ProjectRoot)
}

func GetPaths(baseDir, currentDir string) (*types.ProjectPaths, error) {
	ignored, err := GetPlandexIgnore(currentDir)

	if err != nil {
		return nil, err
	}

	allPaths := map[string]bool{}
	activePaths := map[string]bool{}

	allDirs := map[string]bool{}
	activeDirs := map[string]bool{}
	gitIgnoredDirs := map[string]bool{}

	isGitRepo := IsGitRepo(baseDir)

	errCh := make(chan error)
	var mu sync.Mutex
	numRoutines := 0

	deletedFiles := map[string]bool{}

	if isGitRepo {

		// Use git status to find deleted files
		numRoutines++
		go func() {
			cmd := exec.Command("git", "rev-parse", "--show-toplevel")
			output, err := cmd.Output()
			if err != nil {
				errCh <- fmt.Errorf("error getting git root: %s", err)
				return
			}
			repoRoot := strings.TrimSpace(string(output))

			cmd = exec.Command("git", "status", "--porcelain")
			cmd.Dir = baseDir
			out, err := cmd.Output()
			if err != nil {
				errCh <- fmt.Errorf("error getting git status: %s", err)
			}

			lines := strings.Split(string(out), "\n")

			for _, line := range lines {
				line = strings.TrimSpace(line)
				if strings.HasPrefix(line, "D ") {
					path := strings.TrimSpace(line[2:])
					absPath := filepath.Join(repoRoot, path)
					relPath, err := filepath.Rel(currentDir, absPath)
					if err != nil {
						errCh <- fmt.Errorf("error getting relative path: %s", err)
						return
					}
					deletedFiles[relPath] = true
				}
			}

			errCh <- nil
		}()

		// combine `git ls-files` and `git ls-files --others --exclude-standard`
		// to get all files in the repo

		numRoutines++
		go func() {
			// get all tracked files in the repo
			cmd := exec.Command("git", "ls-files")
			cmd.Dir = baseDir
			out, err := cmd.Output()

			if err != nil {
				errCh <- fmt.Errorf("error getting files in git repo: %s", err)
				return
			}

			files := strings.Split(string(out), "\n")

			mu.Lock()
			defer mu.Unlock()
			for _, file := range files {
				absFile := filepath.Join(baseDir, file)
				relFile, err := filepath.Rel(currentDir, absFile)

				if err != nil {
					errCh <- fmt.Errorf("error getting relative path: %s", err)
					return
				}

				if ignored != nil && ignored.MatchesPath(relFile) {
					continue
				}

				activePaths[relFile] = true

				parentDir := relFile
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					parentDir = filepath.Dir(parentDir)
					activeDirs[parentDir] = true
				}
			}

			errCh <- nil
		}()

		// get all untracked non-ignored files in the repo
		numRoutines++
		go func() {
			cmd := exec.Command("git", "ls-files", "--others", "--exclude-standard")
			cmd.Dir = baseDir
			out, err := cmd.Output()

			if err != nil {
				errCh <- fmt.Errorf("error getting untracked files in git repo: %s", err)
				return
			}

			files := strings.Split(string(out), "\n")

			mu.Lock()
			defer mu.Unlock()
			for _, file := range files {
				absFile := filepath.Join(baseDir, file)
				relFile, err := filepath.Rel(currentDir, absFile)

				if err != nil {
					errCh <- fmt.Errorf("error getting relative path: %s", err)
					return
				}

				if ignored != nil && ignored.MatchesPath(relFile) {
					continue
				}

				activePaths[relFile] = true

				parentDir := relFile
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					parentDir = filepath.Dir(parentDir)
					activeDirs[parentDir] = true
				}
			}

			errCh <- nil
		}()

		// get all ignored paths/dirs in the repo
		// in some cases when entire directories are ignored, git will just list the directory and not the files within it
		numRoutines++
		go func() {
			cmd := exec.Command("git", "ls-files", "--others", "--ignored", "--exclude-standard")
			cmd.Dir = baseDir
			out, err := cmd.Output()

			if err != nil {
				errCh <- fmt.Errorf("error getting untracked files in git repo: %s", err)
				return
			}

			paths := strings.Split(string(out), "\n")

			mu.Lock()
			defer mu.Unlock()

			for _, file := range paths {
				absFile := filepath.Join(baseDir, file)
				relFile, err := filepath.Rel(currentDir, absFile)

				if err != nil {
					errCh <- fmt.Errorf("error getting relative path: %s", err)
					return
				}

				// check if git is ignoring the entire directory, meaning it won't list the files within it
				if strings.HasSuffix(file, "/") {
					allDirs[relFile] = true
					allPaths[relFile] = true
					gitIgnoredDirs[relFile+"/"] = true
				} else {
					allPaths[relFile] = true
				}

			}

			errCh <- nil
		}()

	} else {

		// get all paths in the directory
		numRoutines++
		go func() {
			err = filepath.Walk(baseDir, func(path string, info os.FileInfo, err error) error {
				if err != nil {
					return err
				}

				if info.IsDir() {
					if ShouldSkipDir(info.Name()) {
						return filepath.SkipDir
					}

					relPath, err := filepath.Rel(currentDir, path)
					if err != nil {
						return err
					}

					allDirs[relPath] = true

					if ignored != nil && ignored.MatchesPath(relPath) {
						return filepath.SkipDir
					}
				} else {
					relPath, err := filepath.Rel(currentDir, path)
					if err != nil {
						return err
					}

					allPaths[relPath] = true

					if ignored != nil && ignored.MatchesPath(relPath) {
						return nil
					}

					if !isGitRepo {
						mu.Lock()
						defer mu.Unlock()
						activePaths[relPath] = true

						parentDir := relPath
						for parentDir != "." && parentDir != "/" && parentDir != "" {
							parentDir = filepath.Dir(parentDir)
							activeDirs[parentDir] = true
						}
					}
				}

				return nil
			})

			if err != nil {
				errCh <- fmt.Errorf("error walking directory: %s", err)
				return
			}

			errCh <- nil
		}()
	}

	for i := 0; i < numRoutines; i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	for dir := range activeDirs {
		allDirs[dir] = true
	}

	for dir := range allDirs {
		allPaths[dir] = true
	}

	for dir := range activeDirs {
		activePaths[dir] = true
	}

	removeDirs := map[string]bool{}
	for dir := range allDirs {
		if ShouldSkipDir(dir) {
			removeDirs[dir] = true
		}
	}

	for dir := range removeDirs {
		delete(allDirs, dir)
		delete(activeDirs, dir)
		delete(allPaths, dir)
		delete(activePaths, dir)
	}

	// remove deleted files from active paths
	for path := range deletedFiles {
		delete(activePaths, path)
	}

	for path := range activePaths {
		allPaths[path] = true
	}

	removePaths := map[string]bool{}
	for path := range allPaths {
		if IsInSkippedDir(path) {
			removePaths[path] = true
		}
	}

	for path := range removePaths {
		delete(allPaths, path)
		delete(activePaths, path)
		delete(activeDirs, path)
		delete(allDirs, path)
	}

	ignoredPaths := map[string]string{}
	for path := range allPaths {
		if _, ok := activePaths[path]; !ok {
			if ignored != nil && ignored.MatchesPath(path) {
				ignoredPaths[path] = "plandex"
			} else {
				ignoredPaths[path] = "git"
			}
		}
	}

	return &types.ProjectPaths{
		ActivePaths:    activePaths,
		AllPaths:       allPaths,
		ActiveDirs:     activeDirs,
		AllDirs:        allDirs,
		PlandexIgnored: ignored,
		IgnoredPaths:   ignoredPaths,
		GitIgnoredDirs: gitIgnoredDirs,
	}, nil
}

func GetPlandexIgnore(dir string) (*ignore.GitIgnore, error) {
	ignorePath := filepath.Join(dir, ".plandexignore")

	if _, err := os.Stat(ignorePath); err == nil {
		ignored, err := ignore.CompileIgnoreFile(ignorePath)

		if err != nil {
			return nil, fmt.Errorf("error reading .plandexignore file: %s", err)
		}

		return ignored, nil
	} else if !os.IsNotExist(err) {
		return nil, fmt.Errorf("error checking for .plandexignore file: %s", err)
	}

	return nil, nil
}

func GetBaseDirForContexts(contexts []*shared.Context) string {
	var paths []string

	for _, context := range contexts {
		if context.FilePath != "" {
			paths = append(paths, context.FilePath)
		}
	}

	return GetBaseDirForFilePaths(paths)
}

func GetBaseDirForFilePaths(paths []string) string {
	baseDir := ProjectRoot
	dirsUp := 0

	for _, path := range paths {
		currentDir := ProjectRoot

		pathSplit := strings.Split(path, string(os.PathSeparator))

		n := 0
		for _, p := range pathSplit {
			if p == ".." {
				n++
				currentDir = filepath.Dir(currentDir)
			} else {
				break
			}
		}

		if n > dirsUp {
			dirsUp = n
			baseDir = currentDir
		}
	}

	return baseDir
}

// isSubpathOf checks if 'child' is within 'parent' (same path or deeper).
// Both 'parent' and 'child' can be absolute or relative to 'baseDir';
// we’ll convert them to absolute paths based on 'baseDir' and then compare.
func IsSubpathOf(parent, child, baseDir string) (bool, error) {
	// Convert 'parent' -> absolute
	absParent := parent
	if !filepath.IsAbs(parent) {
		absParent = filepath.Join(baseDir, parent)
	}
	absParent = filepath.Clean(absParent)

	// Convert 'child' -> absolute
	absChild := child
	if !filepath.IsAbs(child) {
		absChild = filepath.Join(baseDir, child)
	}
	absChild = filepath.Clean(absChild)

	// filepath.Rel(absParent, absChild) will be something like:
	//   - ".",  "foo",  "foo/bar", or ".." references
	rel, err := filepath.Rel(absParent, absChild)
	if err != nil {
		// If there's some I/O error or invalid path, just fail safe
		return false, fmt.Errorf("error getting relative path: %s", err)
	}

	// If rel starts with "..", then absChild is outside of absParent
	// or at a higher level (e.g. absParent/../sibling).
	if strings.HasPrefix(rel, "..") {
		return false, nil
	}

	// If we want "absChild == absParent" to count as inside,
	// then !HasPrefix(rel, "..") is enough.
	// This means child == parent or child is deeper within parent.
	return true, nil
}

func IsIgnored(paths *types.ProjectPaths, path, baseDir string) (bool, string, error) {
	if !paths.AllPaths[path] {
		// if the path isn't in AllPaths, it either:
		// 1. doesn't exist (in which case we shouldn't be calling this function)
		// 2. is a subpath of a git ignored dir

		for dir := range paths.GitIgnoredDirs {
			subpath, err := IsSubpathOf(dir, path, baseDir)
			if err != nil {
				return false, "", fmt.Errorf("error checking if %s is a subpath of %s: %s", path, dir, err)
			}
			if subpath {
				return true, "git", nil
			}
		}
		return false, "", fmt.Errorf("path %s is not in the project", path)
	}

	if paths.ActivePaths[path] {
		return false, "", nil
	}

	if paths.PlandexIgnored != nil && paths.PlandexIgnored.MatchesPath(path) {
		return true, "plandex", nil
	}

	return true, "git", nil
}

var skipDirs = map[string]bool{
	".git":              true,
	"node_modules":      true,
	"venv":              true,
	".cache":            true,
	"__pycache__":       true,
	"cue.mod":           true,
	"_build":            true,
	".build":            true,
	"DerivedData":       true,
	".gradle":           true,
	".terraform":        true,
	".terragrunt-cache": true,
	".next":             true,
	".nuxt":             true,
	".bundle":           true,
	".rvm":              true,
	".rbenv":            true,
	".pyenv":            true,
	".nodenv":           true,
	".plenv":            true,
	".nvm":              true,
	"vendor":            true,
	".plandex":          true,
	".plandex-dev":      true,
	".plandex-v2":       true,
	".plandex-dev-v2":   true,
}

func ShouldSkipDir(path string) bool {
	if skipDirs[path] {
		return true
	}

	for k := range skipDirs {
		splitPath := strings.Split(path, string(os.PathSeparator))
		for _, p := range splitPath {
			if p == k {
				return true
			}
		}
	}

	return false
}

func IsInSkippedDir(path string) bool {
	// Check the direct parent directory
	dirName := filepath.Dir(path)
	if skipDirs[dirName] {
		return true
	}

	// Handle cases where the directory might include path separators
	pathComponents := strings.Split(dirName, string(os.PathSeparator))
	for _, component := range pathComponents {
		if skipDirs[component] {
			return true
		}
	}

	return false
}


================================================
FILE: app/cli/fs/projects.go
================================================
package fs

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/term"
	"plandex-cli/types"
	"strings"
)

func GetParentProjectIdsWithPaths(currentUserId string) ([][2]string, error) {
	var parentProjectIds [][2]string
	currentDir := filepath.Dir(Cwd)

	for currentDir != "/" {
		plandexDir := findPlandex(currentDir)
		projectSettingsPath := filepath.Join(plandexDir, "projects-v2.json")
		if _, err := os.Stat(projectSettingsPath); err == nil {
			bytes, err := os.ReadFile(projectSettingsPath)
			if err != nil {
				return nil, fmt.Errorf("error reading projectId file: %s", err)
			}

			var settingsByAccount types.CurrentProjectSettingsByAccount
			err = json.Unmarshal(bytes, &settingsByAccount)

			if err != nil {
				term.OutputErrorAndExit("error unmarshalling projects-v2.json: %v", err)
			}

			settings := settingsByAccount[currentUserId]

			if settings == nil {
				return parentProjectIds, nil
			}

			projectId := string(settings.Id)
			parentProjectIds = append(parentProjectIds, [2]string{currentDir, projectId})
		}
		currentDir = filepath.Dir(currentDir)
	}

	return parentProjectIds, nil
}

func GetChildProjectIdsWithPaths(ctx context.Context, currentUserId string) ([][2]string, error) {
	var childProjectIds [][2]string

	err := filepath.Walk(Cwd, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			// if permission denied, skip the path
			if os.IsPermission(err) {
				if info.IsDir() {
					return filepath.SkipDir
				} else {
					return nil
				}
			}

			return err
		}

		if strings.HasPrefix(info.Name(), ".") {
			if info.IsDir() {
				return filepath.SkipDir
			}
			return nil
		}

		select {
		case <-ctx.Done():
			return fmt.Errorf("context timeout")
		default:
		}

		if info.IsDir() && path != Cwd {
			plandexDir := findPlandex(path)
			projectSettingsPath := filepath.Join(plandexDir, "projects-v2.json")
			if _, err := os.Stat(projectSettingsPath); err == nil {
				bytes, err := os.ReadFile(projectSettingsPath)
				if err != nil {
					return fmt.Errorf("error reading projectId file: %s", err)
				}
				var settingsByAccount types.CurrentProjectSettingsByAccount
				err = json.Unmarshal(bytes, &settingsByAccount)

				if err != nil {
					term.OutputErrorAndExit("error unmarshalling projects-v2.json: %v", err)
				}

				settings := settingsByAccount[currentUserId]

				if settings == nil {
					return nil
				}

				projectId := string(settings.Id)
				childProjectIds = append(childProjectIds, [2]string{path, projectId})
			}
		}
		return nil
	})

	if err != nil {
		if err.Error() == "context timeout" {
			return childProjectIds, nil
		}

		return nil, fmt.Errorf("error walking the path %s: %s", Cwd, err)
	}

	return childProjectIds, nil
}


================================================
FILE: app/cli/fs/utils.go
================================================
package fs

import (
	"fmt"
	"os"
)

func FileExists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	} else if os.IsNotExist(err) {
		return false, nil
	} else {
		return false, fmt.Errorf("error checking if file exists: %v", err)
	}
}


================================================
FILE: app/cli/go.mod
================================================
module plandex-cli

go 1.23.3

require (
	github.com/aws/aws-sdk-go-v2/config v1.29.14
	github.com/charmbracelet/lipgloss v1.0.0
	github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8
	github.com/chromedp/chromedp v0.13.3
	github.com/coreos/go-systemd/v22 v22.5.0
	github.com/davecgh/go-spew v1.1.1
	github.com/fatih/color v1.18.0
	github.com/godbus/dbus/v5 v5.1.0
	github.com/google/uuid v1.6.0
	github.com/lithammer/fuzzysearch v1.1.8
	github.com/muesli/reflow v0.3.0
	github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a
	github.com/olekukonko/tablewriter v0.0.5
	github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c
	github.com/plandex-ai/survey/v2 v2.3.7
	github.com/sashabaranov/go-openai v1.38.1
	github.com/shopspring/decimal v1.4.0
	github.com/spf13/cobra v1.8.0
	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415
	github.com/xeipuuv/gojsonschema v1.2.0
	golang.org/x/term v0.19.0
	gopkg.in/natefinch/lumberjack.v2 v2.2.1
)

require (
	github.com/alecthomas/chroma v0.10.0 // indirect
	github.com/andybalholm/cascadia v1.3.2 // indirect
	github.com/atotto/clipboard v0.1.4 // indirect
	github.com/aws/aws-sdk-go-v2 v1.36.3 // indirect
	github.com/aws/aws-sdk-go-v2/credentials v1.17.67 // indirect
	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 // indirect
	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 // indirect
	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 // indirect
	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect
	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 // indirect
	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 // indirect
	github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 // indirect
	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 // indirect
	github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 // indirect
	github.com/aws/smithy-go v1.22.2 // indirect
	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
	github.com/aymerick/douceur v0.2.0 // indirect
	github.com/charmbracelet/x/ansi v0.8.0 // indirect
	github.com/charmbracelet/x/term v0.2.1 // indirect
	github.com/chromedp/sysutil v1.1.0 // indirect
	github.com/cqroot/multichoose v0.1.1 // indirect
	github.com/dlclark/regexp2 v1.11.5 // indirect
	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
	github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535 // indirect
	github.com/gobwas/httphead v0.1.0 // indirect
	github.com/gobwas/pool v0.2.1 // indirect
	github.com/gobwas/ws v1.4.0 // indirect
	github.com/google/go-cmp v0.7.0 // indirect
	github.com/gorilla/css v1.0.1 // indirect
	github.com/jinzhu/copier v0.4.0 // indirect
	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
	github.com/mattn/go-colorable v0.1.13 // indirect
	github.com/mattn/go-isatty v0.0.20 // indirect
	github.com/mattn/go-localereader v0.0.1 // indirect
	github.com/mattn/go-tty v0.0.3 // indirect
	github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b // indirect
	github.com/microcosm-cc/bluemonday v1.0.26 // indirect
	github.com/mitchellh/go-homedir v1.1.0 // indirect
	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
	github.com/muesli/cancelreader v0.2.2 // indirect
	github.com/pkg/term v1.2.0-beta.2 // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
	github.com/yuin/goldmark v1.6.0 // indirect
	github.com/yuin/goldmark-emoji v1.0.2 // indirect
	golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f // indirect
	golang.org/x/net v0.18.0 // indirect
	golang.org/x/sync v0.12.0 // indirect
	golang.org/x/sys v0.30.0 // indirect
)

require (
	github.com/Masterminds/semver v1.5.0
	github.com/PuerkitoBio/goquery v1.8.1
	github.com/briandowns/spinner v1.23.0
	github.com/charmbracelet/bubbles v0.20.0
	github.com/charmbracelet/bubbletea v1.3.0
	github.com/charmbracelet/glamour v0.6.0
	github.com/charmbracelet/glow v1.5.1
	github.com/cqroot/prompt v0.9.4
	github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203
	github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/mattn/go-runewidth v0.0.16 // indirect
	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
	github.com/pkoukk/tiktoken-go v0.1.7 // indirect
	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
	github.com/spf13/pflag v1.0.5 // indirect
	github.com/xlab/treeprint v1.2.0
	golang.org/x/image v0.25.0 // indirect
	golang.org/x/text v0.23.0 // indirect
	plandex-shared v0.0.0-00010101000000-000000000000
)

replace plandex-shared => ../shared


================================================
FILE: app/cli/go.sum
================================================
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY=
cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM=
cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY=
cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A=
cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc=
cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU=
cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA=
cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw=
cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY=
cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI=
cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4=
cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4=
cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0=
cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ=
cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk=
cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o=
cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s=
cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0=
cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY=
cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw=
cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI=
cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0=
cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8=
cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA=
cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY=
cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s=
cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM=
cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI=
cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY=
cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI=
cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow=
cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM=
cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M=
cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s=
cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU=
cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U=
cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU=
cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU=
cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU=
cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU=
cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM=
cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I=
cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4=
cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0=
cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs=
cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc=
cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM=
cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ=
cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo=
cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE=
cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I=
cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ=
cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo=
cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA=
cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo=
cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ=
cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4=
cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0=
cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8=
cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU=
cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU=
cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y=
cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg=
cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk=
cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w=
cloud.google.com/go/firestore v1.8.0/go.mod h1:r3KB8cAdRIe8znzoPWLw8S6gpDVd9treohhn8b09424=
cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk=
cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg=
cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM=
cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA=
cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o=
cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A=
cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0=
cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0=
cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc=
cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY=
cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic=
cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI=
cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8=
cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08=
cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4=
cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w=
cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE=
cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM=
cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY=
cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s=
cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA=
cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o=
cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ=
cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU=
cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY=
cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34=
cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs=
cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg=
cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E=
cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU=
cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0=
cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA=
cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0=
cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI=
cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4=
cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o=
cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk=
cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo=
cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg=
cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4=
cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg=
cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c=
cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y=
cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A=
cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4=
cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY=
cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s=
cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI=
cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA=
cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4=
cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0=
cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU=
cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU=
cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc=
cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs=
cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg=
cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM=
cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ=
cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc=
cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw=
cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g=
cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU=
cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4=
cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0=
cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo=
cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo=
cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE=
cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg=
cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0=
cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
github.com/alecthomas/chroma v0.10.0 h1:7XDcGkCQopCNKjZHfYrNLraA+M7e0fMiJ/Mfikbfjek=
github.com/alecthomas/chroma v0.10.0/go.mod h1:jtJATyUxlIORhUOFNA9NZDWGAQ8wpxQQqNSB4rjA/1s=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc=
github.com/armon/go-metrics v0.4.0/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4=
github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/atotto/clipboard v0.1.2/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM=
github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
github.com/aws/aws-sdk-go-v2/config v1.29.14 h1:f+eEi/2cKCg9pqKBoAIwRGzVb70MRKqWX4dg1BDcSJM=
github.com/aws/aws-sdk-go-v2/config v1.29.14/go.mod h1:wVPHWcIFv3WO89w0rE10gzf17ZYy+UVS1Geq8Iei34g=
github.com/aws/aws-sdk-go-v2/credentials v1.17.67 h1:9KxtdcIA/5xPNQyZRgUSpYOE6j9Bc4+D7nZua0KGYOM=
github.com/aws/aws-sdk-go-v2/credentials v1.17.67/go.mod h1:p3C44m+cfnbv763s52gCqrjaqyPikj9Sg47kUVaNZQQ=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 h1:x793wxmUWVDhshP8WW2mlnXuFrO4cOd3HLBroh1paFw=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30/go.mod h1:Jpne2tDnYiFascUEs2AWHJL9Yp7A5ZVy3TNyxaAjD6M=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 h1:ZK5jHhnrioRkUNOc+hOgQKlUL5JeC3S6JgLxtQ+Rm0Q=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34/go.mod h1:p4VfIceZokChbA9FzMbRGz5OV+lekcVtHlPKEO0gSZY=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 h1:SZwFm17ZUNNg5Np0ioo/gq8Mn6u9w19Mri8DnJ15Jf0=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34/go.mod h1:dFZsC0BLo346mvKQLWmoJxT+Sjp+qcVR1tRVHQGOH9Q=
github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo=
github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 h1:eAh2A4b5IzM/lum78bZ590jy36+d/aFLgKF/4Vd1xPE=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3/go.mod h1:0yKJC/kb8sAnmlYa6Zs3QVYqaC8ug2AbnNChv5Ox3uA=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 h1:dM9/92u2F1JbDaGooxTq18wmmFzbJRfXfVfy96/1CXM=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15/go.mod h1:SwFBy2vjtA0vZbjjaFtfN045boopadnoVPhu4Fv66vY=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 h1:1Gw+9ajCV1jogloEv1RRnvfRFia2cL6c9cuKV2Ps+G8=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.3/go.mod h1:qs4a9T5EMLl/Cajiw2TcbNt2UNo/Hqlyp+GiuG4CFDI=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 h1:hXmVKytPfTy5axZ+fYbR5d0cFmC3JvwLm5kM83luako=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1/go.mod h1:MlYRNmYu/fGPoxBQVvBYr9nyr948aY/WLUvwBMBJubs=
github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 h1:1XuUZ8mYJw9B6lzAkXhqHlJd/XvaX32evhproijJEZY=
github.com/aws/aws-sdk-go-v2/service/sts v1.33.19/go.mod h1:cQnB8CUnxbMU82JvlqjKR2HBOm3fe9pWorWBza6MBJ4=
github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
github.com/aymanbagabas/go-osc52 v1.0.3/go.mod h1:zT8H+Rk4VSabYN90pWyugflM3ZhpTZNC7cASDfUCdT4=
github.com/aymanbagabas/go-osc52 v1.2.1/go.mod h1:zT8H+Rk4VSabYN90pWyugflM3ZhpTZNC7cASDfUCdT4=
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/briandowns/spinner v1.23.0 h1:alDF2guRWqa/FOZZYWjlMIx2L6H0wyewPxo/CH4Pt2A=
github.com/briandowns/spinner v1.23.0/go.mod h1:rPG4gmXeN3wQV/TsAY4w8lPdIM6RX3yqeBQJSrbXjuE=
github.com/calmh/randomart v1.1.0/go.mod h1:DQUbPVyP+7PAs21w/AnfMKG5NioxS3TbZ2F9MSK/jFM=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/charmbracelet/bubbles v0.7.5/go.mod h1:IRTORFvhEI6OUH7WhN2Ks8Z8miNGimk1BE6cmHijOkM=
github.com/charmbracelet/bubbles v0.15.0/go.mod h1:Y7gSFbBzlMpUDR/XM9MhZI374Q+1p1kluf1uLl8iK74=
github.com/charmbracelet/bubbles v0.20.0 h1:jSZu6qD8cRQ6k9OMfR1WlM+ruM8fkPWkHvQWD9LIutE=
github.com/charmbracelet/bubbles v0.20.0/go.mod h1:39slydyswPy+uVOHZ5x/GjwVAFkCsV8IIVy+4MhzwwU=
github.com/charmbracelet/bubbletea v0.12.2/go.mod h1:3gZkYELUOiEUOp0bTInkxguucy/xRbGSOcbMs1geLxg=
github.com/charmbracelet/bubbletea v0.23.1/go.mod h1:JAfGK/3/pPKHTnAS8JIE2u9f61BjWTQY57RbT25aMXU=
github.com/charmbracelet/bubbletea v0.23.2/go.mod h1:FaP3WUivcTM0xOKNmhciz60M6I+weYLF76mr1JyI7sM=
github.com/charmbracelet/bubbletea v1.3.0 h1:fPMyirm0u3Fou+flch7hlJN9krlnVURrkUVDwqXjoAc=
github.com/charmbracelet/bubbletea v1.3.0/go.mod h1:eTaHfqbIwvBhFQM/nlT1NsGc4kp8jhF8LfUK67XiTDM=
github.com/charmbracelet/charm v0.8.7/go.mod h1:ApJYwJljEjODkOYJgFDzbUqztLrCWQct9zyPD+xcVr4=
github.com/charmbracelet/glamour v0.6.0 h1:wi8fse3Y7nfcabbbDuwolqTqMQPMnVPeZhDM273bISc=
github.com/charmbracelet/glamour v0.6.0/go.mod h1:taqWV4swIMMbWALc0m7AfE9JkPSU8om2538k9ITBxOc=
github.com/charmbracelet/glow v1.5.1 h1:o1mwT4xXXpkfUhJG6euQayNxLZf9yKctOCNHLztrwdE=
github.com/charmbracelet/glow v1.5.1/go.mod h1:rGgop0a2/4gXWiAxUW1iEQseoE+9Ctpb7M4sM9cY9CU=
github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
github.com/charmbracelet/lipgloss v0.6.0/go.mod h1:tHh2wr34xcHjC2HCXIlGSG1jaDF0S0atAUvBMP6Ppuk=
github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8 h1:AqW2bDQf67Zbq6Tpop/+yJSIknxhiQecO2B8jNYTAPs=
github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8/go.mod h1:NItd7aLkcfOA/dcMXvl8p1u+lQqioRMq/SqDp71Pb/k=
github.com/chromedp/chromedp v0.13.3 h1:c6nTn97XQBykzcXiGYL5LLebw3h3CEyrCihm4HquYh0=
github.com/chromedp/chromedp v0.13.3/go.mod h1:khsDP9OP20GrowpJfZ7N05iGCwcAYxk7qf9AZBzR3Qw=
github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw=
github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U=
github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cqroot/multichoose v0.1.1 h1:diGuKYKea9ePOTwUyUDor9zKRqKFWXGkYGqUa9+firU=
github.com/cqroot/multichoose v0.1.1/go.mod h1:BJzIGqbQZNADPDuA3IzhmTMpRc2F3fZKysMRYP+Ydw8=
github.com/cqroot/prompt v0.9.4 h1:uFRlhXuOP3CSD+Pii0Z8VJhgXpavSloFf7/KAERwjz8=
github.com/cqroot/prompt v0.9.4/go.mod h1:6BVZiEv7XkW1K64y1k2wdzToDwspL3n/RkUIyPjQ808=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203 h1:XBBHcIb256gUJtLmY22n99HaZTz+r2Z51xUPi01m3wg=
github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203/go.mod h1:E1jcSv8FaEny+OP/5k9UxZVw9YFWGj7eI4KR/iOBqCg=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
github.com/frankban/quicktest v1.14.3/go.mod h1:mgiwOwqx65TmIk1wJ6Q7wvnVMocbUorkibMOrVTHZps=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535 h1:yE7argOs92u+sSCRgqqe6eF+cDaVhSPlioy1UkA0p/w=
github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535/go.mod h1:BWmvoE1Xia34f3l/ibJweyhrT+aROb/FQ6d+37F0e2s=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f/go.mod h1:nOFQdrUlIlx6M6ODdSpBj1NVA+VgLC6kmw60mkw34H4=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg=
github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM=
github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM=
github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c=
github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo=
github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY=
github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4=
github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
github.com/hashicorp/consul/api v1.15.3/go.mod h1:/g/qgcoBcEXALCNZgRRisyTW0nY86++L0KbeAMXYCeY=
github.com/hashicorp/consul/sdk v0.11.0/go.mod h1:yPkX5Q6CsxTFMjQQDJwzeNmUUF5NUGGbrDsv9wTb8cw=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-hclog v0.14.1/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-msgpack v0.5.5/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8=
github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A=
github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc=
github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
github.com/hashicorp/memberlist v0.3.1/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
github.com/hashicorp/serf v0.9.7/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4=
github.com/hashicorp/serf v0.9.8/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf h1:WfD7VjIE6z8dIvMsI4/s+1qr5EL+zoIGev1BQj1eoJ8=
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf/go.mod h1:hyb9oH7vZsitZCiBt0ZvifOrB+qc8PS5IiilCIb87rg=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-tty v0.0.3 h1:5OfyWorkyO7xP52Mq7tB36ajHDG5OHrmBGIS/DtakQI=
github.com/mattn/go-tty v0.0.3/go.mod h1:ihxohKRERHTVzN+aSVRwACLCeqIoZAWpoICkkvrWyR0=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/meowgorithm/babyenv v1.3.0/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
github.com/meowgorithm/babyenv v1.3.1/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/microcosm-cc/bluemonday v1.0.21/go.mod h1:ytNkv4RrDrLJ2pqlsSI46O6IVXmZOBBD4SaJyDwwTkM=
github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a/go.mod h1:v8eSC2SMp9/7FTKUncp7fH9IwPfw+ysMObcEz5FWheQ=
github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
github.com/muesli/gitcha v0.2.0/go.mod h1:Ri8m9TZS4+ORG4JVmVKUQcWZuxDvUW3UKxMdQfzG2zI=
github.com/muesli/go-app-paths v0.2.1/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
github.com/muesli/go-app-paths v0.2.2/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
github.com/muesli/reflow v0.2.1-0.20210115123740-9e1d0d53df68/go.mod h1:Xk+z4oIWdQqJzsxyjgl3P22oYZnHdZ8FFTHAQQt5BMQ=
github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a/go.mod h1:+XG0ne5zXWBTSbbe7Z3/RWxaT8PZY6zaZ1dX6KjprYY=
github.com/muesli/termenv v0.7.2/go.mod h1:ct2L5N2lmix82RaY3bMWwVu/jUFc9Ule0KGDCiKYPh8=
github.com/muesli/termenv v0.7.4/go.mod h1:pZ7qY9l3F7e5xsAOS0zCew2tME+p7bWeBkotCEcIIcc=
github.com/muesli/termenv v0.11.1-0.20220204035834-5ac8409525e0/go.mod h1:Bd5NYQ7pd+SrtBSrSNoBBmXlcY8+Xj4BMJgh8qcZrvs=
github.com/muesli/termenv v0.13.0/go.mod h1:sP1+uffeLaEYpyOTb8pLCUctGcGLnoFjSn4YJK5e2bc=
github.com/muesli/termenv v0.14.0/go.mod h1:kG/pF1E7fh949Xhe156crRUrHNyK221IuGO7Ez60Uc8=
github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ=
github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a h1:2MaM6YC3mGu54x+RKAA6JiFFHlHDY1UbkxqppT7wYOg=
github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a/go.mod h1:hxSnBBYLK21Vtq/PHd0S2FYCxBXzBua8ov5s1RobyRQ=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
github.com/pelletier/go-toml/v2 v2.0.5/go.mod h1:OMHamSCAODeSsVrwwvcJOaoN0LIUIaFVNZzmWyNfXas=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
github.com/pkg/term v1.2.0-beta.2 h1:L3y/h2jkuBVFdWiJvNfYfKmzcCnILw7mJWm2JQuMppw=
github.com/pkg/term v1.2.0-beta.2/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw=
github.com/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c h1:bki/wkg5iFBOv3jCPUDNuH5yLngUPUdEJCSuvc2tiQ0=
github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c/go.mod h1:SqEsJfsIr0GYUyLatvezDOBe6XsCw64E7v33QzeH5PM=
github.com/plandex-ai/survey/v2 v2.3.7 h1:u1o6bflbaBpW8i8krm+91Z2cOcvZcMVS+AjV+rgR8Rk=
github.com/plandex-ai/survey/v2 v2.3.7/go.mod h1:RiBOKRDB5fOQrOzsiAPAN57hYqFKPkCxgSK7twcDOys=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94/go.mod h1:b18R55ulyQ/h3RaWyloPyER7fWQVZvimKKhnI5OfrJQ=
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI=
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs=
github.com/sagikazarmark/crypt v0.8.0/go.mod h1:TmKwZAo97S4Fy4sfMH/HX/cQP5D+ijra2NyLpNNmttY=
github.com/sahilm/fuzzy v0.1.0/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
github.com/sashabaranov/go-openai v1.38.1 h1:TtZabbFQZa1nEni/IhVtDF/WQjVqDgd+cWR5OeddzF8=
github.com/sashabaranov/go-openai v1.38.1/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
github.com/segmentio/ksuid v1.0.4/go.mod h1:/XUiZBD3kVx5SmUOl55voK5yeAbBNNIed+2O73XgrPE=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU=
github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY=
github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
github.com/spf13/viper v1.14.0/go.mod h1:WT//axPky3FdvXHzGw33dNdXXXfFQqmEalje+egj8As=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ=
github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.3.7/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.5.2/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.6.0 h1:boZcn2GTjpsynOsC0iJHnBWa4Bi0qzfJjthwauItG68=
github.com/yuin/goldmark v1.6.0/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark-emoji v1.0.1/go.mod h1:2w1E6FEWLcDQkoTE+7HU6QF1F6SLlNGjRIBbIZQFqkQ=
github.com/yuin/goldmark-emoji v1.0.2 h1:c/RgTShNgHTtc6xdz2KKI74jJr6rWi7FPgnP9GAsO5s=
github.com/yuin/goldmark-emoji v1.0.2/go.mod h1:RhP/RWpexdp+KHs7ghKnifRoIs/Bq4nDS7tRbCkOwKY=
go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
go.etcd.io/etcd/api/v3 v3.5.5/go.mod h1:KFtNaxGDw4Yx/BA4iPPwevUTAuqcsPxzyX8PHydchN8=
go.etcd.io/etcd/client/pkg/v3 v3.5.5/go.mod h1:ggrwbk069qxpKPq8/FKkQ3Xq9y39kbFR4LnKszpRXeQ=
go.etcd.io/etcd/client/v2 v2.305.5/go.mod h1:zQjKllfqfBVyVStbt4FaosoX2iYd8fV/GRy/PbowgP4=
go.etcd.io/etcd/client/v3 v3.5.5/go.mod h1:aApjR4WGlSumpnJ2kloS75h6aHUmAyaPLjHMxpc7E7c=
go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo=
go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f h1:XdNn9LlyWAhLVp6P/i8QYBW+hlyhrhei9uErw2B5GJo=
golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f/go.mod h1:D5SMRVC3C2/4+F/DB1wZsLRnSNimn2Sp/NPsCrsv8ak=
golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
golang.org/x/net v0.18.0 h1:mIYleuAkSbHh0tCv7RvjL3F6ZVbLjq4+R7zbOn3Kokg=
golang.org/x/net v0.18.0/go.mod h1:/czyP5RqHAH4odGYxBJ1qz0+CE5WZ+2j1YgoEo8F2jQ=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200916030750-2334cc1a136f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201020230747-6e5568b54d1a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220204135822-1c1b9b1eba6a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20220609170525-579cf78fd858/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU=
google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94=
google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo=
google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4=
google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw=
google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU=
google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k=
google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo=
google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g=
google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA=
google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8=
google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs=
google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw=
google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg=
google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o=
google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g=
google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI=
google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70=
google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w=
google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE=
google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc=
google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw=
google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U=
google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=


================================================
FILE: app/cli/install.sh
================================================
#!/usr/bin/env bash

set -e

SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

PLATFORM=
ARCH=
VERSION=
RELEASES_URL="https://github.com/plandex-ai/plandex/releases/download"

 # Ensure cleanup happens on exit and on specific signals
trap cleanup EXIT
trap cleanup INT TERM

cleanup () {
  cd "${SCRIPT_DIR}"
  rm -rf plandex_install_tmp
}

# Set platform
case "$(uname -s)" in
 Darwin)
   PLATFORM='darwin'
   ;;

 Linux)
   PLATFORM='linux'
   ;;

 FreeBSD)
   PLATFORM='freebsd'
   ;;

 CYGWIN*|MINGW*|MSYS*)
   PLATFORM='windows'
   ;;

 *)
   echo "Platform may or may not be supported. Will attempt to install."
   PLATFORM='linux'
   ;;
esac

if [[ "$PLATFORM" == "windows" ]]; then
  echo "🚨 Windows is only supported via WSL. It doesn't work in the Windows CMD prompt or PowerShell."
  echo "How to install WSL 👉 https://learn.microsoft.com/en-us/windows/wsl/about"
  exit 1
fi

# Set arch
if [[ "$(uname -m)" == 'x86_64' ]]; then
  ARCH="amd64"
elif [[ "$(uname -m)" == 'arm64' || "$(uname -m)" == 'aarch64' ]]; then
  ARCH="arm64"
fi

if [[ "$(cat /proc/1/cgroup 2> /dev/null | grep docker | wc -l)" > 0 ]] || [ -f /.dockerenv ]; then
  IS_DOCKER=true
else
  IS_DOCKER=false
fi

# Set Version
if [[ -z "${PLANDEX_VERSION}" ]]; then
  VERSION=$(curl -sL https://plandex.ai/v2/cli-version.txt)
else
  VERSION=$PLANDEX_VERSION
  echo "Using custom version $VERSION"
fi


welcome_plandex () {
  echo ""
  echo "$(printf '%*s' "$(tput cols)" '' | tr ' ' -)"
  echo ""
  echo "🚀 Plandex v$VERSION • Quick Install"
  echo ""
  echo "$(printf '%*s' "$(tput cols)" '' | tr ' ' -)"
  echo ""
}

download_plandex () {
  ENCODED_TAG="cli%2Fv${VERSION}"

  url="${RELEASES_URL}/${ENCODED_TAG}/plandex_${VERSION}_${PLATFORM}_${ARCH}.tar.gz"

  mkdir -p plandex_install_tmp
  cd plandex_install_tmp

  echo "📥 Downloading Plandex tarball"
  echo ""
  echo "👉 $url"
  echo ""
  curl -s -L -o plandex.tar.gz "${url}"

  tar zxf plandex.tar.gz 1> /dev/null

  should_sudo=false

  if [ "$PLATFORM" == "darwin" ] || $IS_DOCKER ; then
    if [[ -d /usr/local/bin ]]; then
      if ! mv plandex /usr/local/bin/ 2>/dev/null; then
        echo "Permission denied when attempting to move Plandex to /usr/local/bin."
        if hash sudo 2>/dev/null; then
          should_sudo=true
          echo "Attempting to use sudo to complete installation."
          sudo mv plandex /usr/local/bin/
          if [[ $? -eq 0 ]]; then
            echo "✅ Plandex is installed in /usr/local/bin"
            echo ""
          else
            echo "Failed to install Plandex using sudo. Please manually move Plandex to a directory in your PATH."
            exit 1
          fi
        else
          echo "sudo not found. Please manually move Plandex to a directory in your PATH."
          exit 1
        fi
      else
        echo "✅ Plandex is installed in /usr/local/bin"
      fi
    else
      echo >&2 'Error: /usr/local/bin does not exist. Create this directory with appropriate permissions, then re-install.'
      exit 1
    fi
  else
    if [ $UID -eq 0 ]
    then
      # we are root
      mv plandex /usr/local/bin/
    elif hash sudo 2>/dev/null;
    then
      # not root, but can sudo
      sudo mv plandex /usr/local/bin/
      should_sudo=true
    else
      echo "ERROR: This script must be run as root or be able to sudo to complete the installation."
      exit 1
    fi

    echo "✅ Plandex is installed in /usr/local/bin"
  fi

  # create 'pdx' alias, but don't overwrite existing pdx command
  if [ ! -x "$(command -v pdx)" ]; then
    echo "🎭 Creating pdx alias..."
    LOC=$(which plandex)
    BIN_DIR=$(dirname "$LOC")

    if [ "$should_sudo" = true ]; then
      sudo ln -s "$LOC" "$BIN_DIR/pdx" && \
        echo "✅ Successfully created 'pdx' alias with sudo." || \
        echo "⚠️ Failed to create 'pdx' alias even with sudo. Please create it manually."
    else
      ln -s "$LOC" "$BIN_DIR/pdx" && \
        echo "✅ Successfully created 'pdx' alias." || \
        echo "⚠️ Failed to create 'pdx' alias. Please create it manually."
    fi
  fi
}

check_existing_installation () {
  if command -v plandex >/dev/null 2>&1; then
    existing_version=$(plandex version 2>/dev/null || echo "unknown")
    # Check if version starts with 1.x.x
    if [[ "$existing_version" =~ ^1\. ]]; then
      echo "Found existing Plandex v1.x installation ($existing_version). Renaming to 'plandex1' before installing v2..."
      
      # Get the location of existing binary
      existing_binary=$(which plandex)
      binary_dir=$(dirname "$existing_binary")
      
      # Rename plandex to plandex1
      if ! mv "$existing_binary" "${binary_dir}/plandex1" 2>/dev/null; then
        sudo mv "$existing_binary" "${binary_dir}/plandex1"
      fi
      
      # Rename pdx to pdx1 if it exists
      if [ -L "${binary_dir}/pdx" ]; then
        if ! mv "${binary_dir}/pdx" "${binary_dir}/pdx1" 2>/dev/null; then
          sudo mv "${binary_dir}/pdx" "${binary_dir}/pdx1"
        fi
        echo "Renamed 'pdx' alias to 'pdx1'"
      fi
      
      echo "Your v1.x installation is now accessible as 'plandex1' and 'pdx1'"
    fi
  fi
}

welcome_plandex
check_existing_installation
download_plandex

echo ""
echo "🎉 Installation complete"
echo ""
echo "$(printf '%*s' "$(tput cols)" '' | tr ' ' -)"
echo ""
echo "⚡️ Run 'plandex' or 'pdx' in any project directory and start building!"
echo ""
echo "$(printf '%*s' "$(tput cols)" '' | tr ' ' -)"
echo ""
echo "📚 Need help? 👉 https://docs.plandex.ai"
echo ""
echo "👋 Join a community of AI builders 👉 https://discord.gg/plandex-ai"
echo ""
echo "$(printf '%*s' "$(tput cols)" '' | tr ' ' -)"
echo ""



================================================
FILE: app/cli/lib/active_stream.go
================================================
package lib

import (
	"fmt"
	"plandex-cli/api"
	"plandex-cli/term"

	shared "plandex-shared"
)

func SelectActiveStream(args []string) (string, string, bool) {
	term.StartSpinner("")
	res, apiErr := api.Client.ListPlansRunning([]string{CurrentProjectId}, false)
	term.StopSpinner()

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting running plans: %v", apiErr)
		return "", "", false
	}

	if len(res.Branches) == 0 {
		fmt.Println("🤷‍♂️ No active plan stream")
		fmt.Println()
		term.PrintCmds("", "ps")
		return "", "", false
	}

	var planId string
	var branch string
	var streamIdOrPlan string

	if len(args) > 0 {
		streamIdOrPlan = args[0]
	}

	if streamIdOrPlan != "" {
		for _, b := range res.Branches {
			id := res.StreamIdByBranchId[b.Id]
			plan := res.PlansById[b.PlanId]
			if id == streamIdOrPlan || plan.Name == streamIdOrPlan {
				planId = b.PlanId
				branch = b.Name
				break
			}
		}
	}

	if planId == "" {
		if len(res.PlansById) == 1 {
			for _, p := range res.PlansById {
				if p.Id == CurrentPlanId {
					planId = p.Id
					break
				}
			}
		}

		if planId == "" {
			var opts []string
			addedPlans := make(map[string]bool)

			for _, plan := range res.PlansById {
				if addedPlans[plan.Id] {
					continue
				}
				opts = append(opts, plan.Name)
				addedPlans[plan.Id] = true
			}

			selected, err := term.SelectFromList("Select an active plan", opts)

			if err != nil {
				term.OutputErrorAndExit("Error selecting plan: %v", err)
			}

			for _, p := range res.PlansById {
				if p.Name == selected {
					planId = p.Id
					break
				}
			}
		}

	}

	if planId == "" {
		fmt.Println("🤷‍♂️ No active plan stream")
		fmt.Println()
		term.PrintCmds("", "ps")

		return "", "", false
	}

	var planBranches []*shared.Branch
	for _, b := range res.Branches {
		if b.PlanId == planId {
			planBranches = append(planBranches, b)
		}
	}

	if len(planBranches) == 0 {
		fmt.Println("🤷‍♂️ No active plan stream")
		fmt.Println()
		term.PrintCmds("", "ps")

		return "", "", false
	}

	if len(args) > 1 {
		maybeBranch := args[1]
		for _, b := range planBranches {
			if b.Name == maybeBranch {
				branch = maybeBranch
				break
			}
		}
	}

	if branch == "" {
		if len(planBranches) == 1 {
			name := planBranches[0].Name
			if name == CurrentBranch {
				branch = name
			}
		}

		if branch == "" {
			opts := make([]string, len(planBranches))

			for i, b := range planBranches {
				opts[i] = b.Name
			}

			selected, err := term.SelectFromList("Select a branch", opts)

			if err != nil {
				term.OutputErrorAndExit("Error selecting branch: %v", err)
			}

			branch = selected
		}
	}

	if branch == "" {
		fmt.Println("🤷‍♂️ No active plan stream")
		fmt.Println()
		term.PrintCmds("", "ps")

		return "", "", false
	}

	return planId, branch, true
}


================================================
FILE: app/cli/lib/apply.go
================================================
package lib

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
	"strings"
	"sync"
	"sync/atomic"
	"syscall"
	"time"

	shared "plandex-shared"

	"github.com/fatih/color"
)

type ApplyPlanParams struct {
	PlanId      string
	Branch      string
	ApplyFlags  types.ApplyFlags
	TellFlags   types.TellFlags
	OnExecFail  types.OnApplyExecFailFn
	ExecCommand string
}

func MustApplyPlan(
	params ApplyPlanParams,
) {
	MustApplyPlanAttempt(params, 0)
}

func MustApplyPlanAttempt(
	params ApplyPlanParams,
	attempt int,
) {
	log.Println("Applying plan")

	applyFlags := params.ApplyFlags
	planId := params.PlanId
	branch := params.Branch
	onExecFail := params.OnExecFail

	autoConfirm := applyFlags.AutoConfirm
	autoCommit := applyFlags.AutoCommit
	noCommit := applyFlags.NoCommit
	noExec := applyFlags.NoExec

	term.StartSpinner("")

	err := PromptSyncModelsIfNeeded()
	if err != nil {
		term.OutputErrorAndExit("Error syncing models: %v", err)
	}

	term.StartSpinner("")

	currentPlanState, apiErr := api.Client.GetCurrentPlanState(planId, branch)

	if apiErr != nil {
		term.StopSpinner()
		term.OutputErrorAndExit("Error getting current plan state: %v", apiErr)
	}

	if currentPlanState.HasPendingBuilds() {
		plansRunningRes, apiErr := api.Client.ListPlansRunning([]string{CurrentProjectId}, false)

		if apiErr != nil {
			term.StopSpinner()
			term.OutputErrorAndExit("Error getting running plans: %v", apiErr)
		}

		for _, b := range plansRunningRes.Branches {
			if b.PlanId == planId && b.Name == branch {
				fmt.Println("This plan is currently active. Please wait for it to finish before applying.")
				fmt.Println()
				term.PrintCmds("", "ps", "connect")
				return
			}
		}

		term.StopSpinner()

		fmt.Println("This plan has changes that need to be built before applying")
		fmt.Println()

		shouldBuild, err := term.ConfirmYesNo("Build changes now?")

		if err != nil {
			term.OutputErrorAndExit("failed to get confirmation user input: %s", err)
		}

		if !shouldBuild {
			fmt.Println("Apply plan canceled")
			os.Exit(0)
		}

		_, err = buildPlanInlineFn(autoConfirm, nil)

		if err != nil {
			term.OutputErrorAndExit("failed to build plan: %v", err)
		}
	}

	paths, err := fs.GetProjectPaths(fs.ProjectRoot)

	if err != nil {
		term.OutputErrorAndExit("error getting project paths: %v", err)
	}

	anyOutdated, didUpdate, err := CheckOutdatedContextWithOutput(true, autoConfirm, nil, paths)

	if err != nil {
		term.OutputErrorAndExit("error checking outdated context: %v", err)
	}

	if anyOutdated && !didUpdate {
		term.StopSpinner()
		fmt.Println("Apply plan canceled")
		os.Exit(0)
	}

	term.ResumeSpinner()

	currentPlanFiles := currentPlanState.CurrentPlanFiles
	isRepo := fs.ProjectRootIsGitRepo()

	toApply := currentPlanFiles.Files
	toRemove := currentPlanFiles.Removed
	hasExec := currentPlanFiles.Files["_apply.sh"] != ""

	log.Printf("Files to apply: %d, Has exec script: %v", len(toApply), hasExec)

	if len(toApply) == 0 && !hasExec {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No changes to apply")
		return
	}

	hasFileChanges := !hasExec || len(toApply) > 1

	var toRollback *types.ApplyRollbackPlan
	var updatedFiles []string

	onErr := func(errMsg string, errArgs ...interface{}) {
		term.StopSpinner()
		// if toRollback != nil && toRollback.HasChanges() {
		// 	Rollback(toRollback, true)
		// }
		term.OutputErrorAndExit(errMsg, errArgs...)
	}

	onGitErr := func(errMsg, unformattedErrMsg string) {
		term.StopSpinner()
		fmt.Println()
		term.OutputSimpleError(errMsg, unformattedErrMsg)
	}

	log.Println("Has file changes:", hasFileChanges)

	if hasFileChanges {
		if !autoConfirm {
			log.Println("Asking user to confirm applying changes")

			term.StopSpinner()
			numToApply := len(toApply)
			suffix := ""
			if numToApply > 1 {
				suffix = "s"
			}
			shouldContinue, err := term.ConfirmYesNo("Apply changes to %d file%s?", numToApply, suffix)

			if err != nil {
				term.OutputErrorAndExit("failed to get confirmation user input: %s", err)
			}

			if !shouldContinue {
				os.Exit(0)
			}
			term.ResumeSpinner()
		}

		log.Println("Applying plan files")

		if hasExec {
			term.StopSpinner()
			fmt.Println("🔄 Tentatively applying changes")
			term.ResumeSpinner()
		}

		updatedFiles, toRollback, err = ApplyFiles(toApply, toRemove, paths)

		if err != nil {
			onErr("failed to apply files: %s", err)
		}

		log.Println("Applying plan files complete")
	}

	onExecSuccess := func() {
		term.StartSpinner("")
		commitSummary, err := apiApplyPlan(planId, branch)

		if err != nil {
			onErr("apply plan server error: %s", err)
		}

		if len(updatedFiles) == 0 {
			term.StopSpinner()
			fmt.Println("✅ Applied changes, but no files were updated")
		} else {
			appliedMsgFn := func() {
				suffix := ""
				if len(updatedFiles) > 1 {
					suffix = "s"
				}
				fmt.Printf("✅ Applied changes, %d file%s updated\n", len(updatedFiles), suffix)
				for _, file := range updatedFiles {
					fmt.Println(" • 📄 " + file)
				}
			}

			if isRepo && !noCommit {
				term.StopSpinner()
				gitErr := commitApplied(autoCommit, commitSummary, updatedFiles, currentPlanState)
				appliedMsgFn()
				if gitErr != nil {
					onGitErr("Failed to commit changes:", gitErr.Error())
				}
			} else {
				term.StopSpinner()
				appliedMsgFn()
			}
		}
	}

	if _, ok := toApply["_apply.sh"]; ok && !noExec {
		handleApplyScript(params, toApply, onErr, toRollback, onExecFail, attempt, onExecSuccess)
	} else {
		onExecSuccess()
	}
}

func handleApplyScript(
	params ApplyPlanParams,
	toApply map[string]string,
	onErr types.OnErrFn,
	toRollback *types.ApplyRollbackPlan,
	onExecFail types.OnApplyExecFailFn,
	attempt int,
	onSuccess func(),
) {
	log.Println("Handling apply script")

	term.StopSpinner()

	color.New(term.ColorHiCyan, color.Bold).Println("🚀 Commands to execute 👇")

	var content string
	if params.ExecCommand != "" {
		content = params.ExecCommand
	} else {
		content = toApply["_apply.sh"]
	}

	md, err := term.GetMarkdown("```bash\n" + content + "\n```")

	if err != nil {
		onErr("failed to get markdown representation: %s", err)
	}

	fmt.Println(strings.TrimSpace(md))

	log.Println("Asking user to confirm executing apply script")

	var confirmed bool
	if params.ApplyFlags.AutoExec {
		confirmed = true
	} else {
		confirmed, err = term.ConfirmYesNo("Execute now?")
		if err != nil {
			onErr("failed to get confirmation user input: %s", err)
		}
	}

	if confirmed {
		log.Println("Executing apply script")
		execApplyScript(params, toApply, onErr, toRollback, onExecFail, attempt, onSuccess)
	} else {
		if toRollback != nil && toRollback.HasChanges() {
			res, err := term.SelectFromList("Skipping execution. Apply file changes or roll back?", []string{string(types.ApplyRollbackOptionKeep), string(types.ApplyRollbackOptionRollback)})

			if err != nil {
				onErr("failed to get rollback confirmation user input: %s", err)
			}

			if res == string(types.ApplyRollbackOptionRollback) {
				Rollback(toRollback, true)
				os.Exit(0)
			} else {
				onSuccess()
			}
		} else {
			fmt.Println("🙅‍♂️ Skipped execution")
			fmt.Println("🤷‍♂️ No changes to apply")
		}
	}
}

var shellShebangs = map[string]string{
	"/bin/bash": `#!/bin/bash
`,
	"/bin/zsh": `#!/bin/zsh
`,
}

var applyScriptErrorHandling = map[string]string{
	"/bin/bash": `set -euo pipefail`,
	"/bin/zsh":  `set -euo pipefail`,
}

func execApplyScript(
	params ApplyPlanParams,
	toApply map[string]string,
	onErr types.OnErrFn,
	toRollback *types.ApplyRollbackPlan,
	onExecFail types.OnApplyExecFailFn,
	attempt int,
	onSuccess func(),
) {
	log.Println("Executing apply script")

	color.New(term.ColorHiYellow, color.Bold).Println("👉 For long-running commands, use ctrl+c to exit")
	color.New(term.ColorHiCyan, color.Bold).Println("🚀 Executing... output below 👇")

	fmt.Println()

	var content string

	if params.ExecCommand != "" {
		content = params.ExecCommand
	} else {
		content = toApply["_apply.sh"]
	}

	scriptPath := filepath.Join(fs.ProjectRoot, "_apply.sh")
	lines := strings.Split(content, "\n")
	filteredLines := []string{}

	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, "#!/") {
			continue
		}
		if strings.HasPrefix(trimmed, "set -") || strings.HasSuffix(trimmed, "pipefail") {
			continue
		}
		if strings.HasPrefix(trimmed, "trap") {
			continue
		}
		filteredLines = append(filteredLines, line)
	}

	// Detect shell
	shell := os.Getenv("SHELL")
	if shell == "" {
		shell = "/bin/bash" // fallback
	}

	// Get appropriate header
	shebang := shellShebangs[shell]
	if shebang == "" {
		shebang = shellShebangs["/bin/bash"] // fallback if shell not supported
	}
	errorHandling := applyScriptErrorHandling[shell]

	if errorHandling == "" {
		errorHandling = applyScriptErrorHandling["/bin/bash"] // fallback if shell not supported
	}

	header := shebang + "\n" + errorHandling
	content = header + "\n" + strings.Join(filteredLines, "\n")
	err := os.WriteFile(scriptPath, []byte(content), 0755)

	if err != nil {
		onErr("failed to write _apply.sh: %s", err)
	}

	execCmd := exec.Command(shell, "-c", scriptPath)
	execCmd.Dir = fs.ProjectRoot
	execCmd.Env = os.Environ()
	execCmd.Stdin = os.Stdin

	// Create a pipe for both stdout and stderr
	pipe, err := execCmd.StdoutPipe()
	if err != nil {
		// best effort cleanup
		os.Remove(scriptPath)
		onErr("failed to create stdout pipe: %s", err)
	}
	execCmd.Stderr = execCmd.Stdout

	// Set platform-specific process attributes
	SetPlatformSpecificAttrs(execCmd)

	if err := execCmd.Start(); err != nil {
		// best effort cleanup
		os.Remove(scriptPath)
		onErr("failed to start command: %s", err)
	}

	maybeDeleteCgroup := MaybeIsolateCgroup(execCmd)

	pgid, err := syscall.Getpgid(execCmd.Process.Pid)
	if err != nil {
		log.Printf("Getpgid error: %v", err)
	} else {
		log.Printf("Child PID=%d PGID=%d", execCmd.Process.Pid, pgid)
	}

	// Create a context that we can cancel
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// Use atomic variable to prevent data races
	var interrupted atomic.Bool

	// Handle SIGINT and SIGTERM
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT)

	var interruptHandled atomic.Bool
	var interruptWG sync.WaitGroup

	// Start the interrupt handler goroutine
	interruptWG.Add(1)
	go func() {
		defer interruptWG.Done()

		for {
			select {
			case sig := <-sigChan:
				if interruptHandled.CompareAndSwap(false, true) {
					fmt.Println()
					color.New(term.ColorHiYellow, color.Bold).Println("👉 Caught interrupt. Exiting gracefully...")
					interrupted.Store(true)

					var sysSig syscall.Signal

					switch sig {
					case os.Interrupt:
						// user pressed Ctrl+C
						sysSig = syscall.SIGINT
					case syscall.SIGTERM:
						// a polite "kill" request
						sysSig = syscall.SIGTERM
					case syscall.SIGHUP:
						sysSig = syscall.SIGHUP
					case syscall.SIGQUIT:
						sysSig = syscall.SIGQUIT
					default:
						sysSig = syscall.SIGINT
					}

					if err := KillProcessGroup(execCmd, sysSig); err != nil {
						log.Printf("Failed to send signal %s to process group: %v", sysSig, err)
					}

					select {
					case <-time.After(2 * time.Second):
						color.New(term.ColorHiYellow, color.Bold).Println("👉 Commands didn't exit after 2 seconds. Sending SIGKILL.")
						if err := KillProcessGroup(execCmd, syscall.SIGKILL); err != nil {
							log.Printf("Failed to terminate process group: %v", err)
						}
						pipe.Close()
						if maybeDeleteCgroup != nil {
							maybeDeleteCgroup()
						}
					case <-ctx.Done():
						if maybeDeleteCgroup != nil {
							maybeDeleteCgroup()
						}
						return
					}
				}

			case <-ctx.Done():
				// If no interrupts occurred, this will be the normal exit path
				if maybeDeleteCgroup != nil {
					maybeDeleteCgroup()
				}
				return
			}
		}
	}()

	// Read and display output in real-time
	scanner := bufio.NewScanner(pipe)
	var outputBuilder strings.Builder
	for scanner.Scan() {
		line := scanner.Text()
		fmt.Println(line)
		outputBuilder.WriteString(line + "\n")
	}

	// Check for scanner errors
	if scanErr := scanner.Err(); scanErr != nil {
		log.Printf("⚠️ Scanner error reading subprocess output: %v", scanErr)
	}

	err = execCmd.Wait()

	// Ensure interrupt handler fully completes before proceeding
	cancel()           // cancel the context, if not already
	interruptWG.Wait() // wait until the interrupt handler goroutine finishes
	signal.Stop(sigChan)
	close(sigChan)

	success := err == nil

	if interrupted.Load() {
		os.Remove(scriptPath)

		color.New(term.ColorHiYellow, color.Bold).Println("👉 Execution interrupted")

		didSucceed, canceled, err := term.ConfirmYesNoCancel("Did the commands succeed?")

		if err != nil {
			onErr("failed to get confirmation user input: %s", err)
		}

		success = didSucceed

		if canceled {
			// rollback and exit
			Rollback(toRollback, true)
			os.Exit(0)
		}
	}

	// remove _apply.sh without overwriting err val
	{
		err := os.Remove(scriptPath)
		if err != nil && !os.IsNotExist(err) {
			onErr("failed to remove _apply.sh: %s", err)
		}
	}

	if !success {
		fmt.Println()
		color.New(term.ColorHiRed, color.Bold).Println("🚨 Commands failed")

		exitErr, ok := err.(*exec.ExitError)
		status := -1
		if ok {
			status = exitErr.ExitCode()
		}
		onExecFail(status, outputBuilder.String(), attempt, toRollback, onErr, onSuccess)
	} else {
		fmt.Println()
		fmt.Println("✅ Commands succeeded")
		onSuccess()
	}
}

func apiApplyPlan(planId, branch string) (string, error) {
	authVars := MustVerifyAuthVarsSilent(auth.Current.IntegratedModelsMode)

	var commitSummary string

	log.Println("Applying plan with API call")

	commitSummary, apiErr := api.Client.ApplyPlan(planId, branch, shared.ApplyPlanRequest{
		AuthVars: authVars,
	})

	if apiErr != nil {
		return "", fmt.Errorf("failed to set pending results applied: %s", apiErr.Msg)
	}

	return commitSummary, nil
}

func commitApplied(autoCommit bool, commitSummary string, updatedFiles []string, currentPlanState *shared.CurrentPlanState) (err error) {
	confirmed := autoCommit
	if !autoCommit {
		fmt.Println("✏️  Plandex can commit these updates with an automatically generated message.")
		fmt.Println()
		// fmt.Println("ℹ️  Only the files that Plandex is updating will be included the commit. Any other changes, staged or unstaged, will remain exactly as they are.")
		// fmt.Println()
		confirmed, err = term.ConfirmYesNo("Commit Plandex updates now?")
		if err != nil {
			return fmt.Errorf("failed to get confirmation user input: %s", err)
		}
	}

	if confirmed {
		// Commit the changes
		msg := currentPlanState.PendingChangesSummaryForApply(commitSummary)
		// log.Println("Committing changes with message:")
		// log.Println(msg)
		// spew.Dump(currentPlanState)
		err = GitAddAndCommitPaths(fs.ProjectRoot, msg, updatedFiles, true)
		if err != nil {
			return fmt.Errorf("failed to commit changes: %s", err.Error())
		}
	}

	return nil
}

func ApplyFiles(toApply map[string]string, toRemove map[string]bool, projectPaths *types.ProjectPaths) ([]string, *types.ApplyRollbackPlan, error) {
	var updatedFiles []string
	toRevert := map[string]types.ApplyReversion{}
	var toRemoveOnRollback []string

	var mu sync.Mutex
	totalOps := len(toApply) + len(toRemove)
	errCh := make(chan error, totalOps)

	for path, content := range toApply {
		if path == "_apply.sh" {
			errCh <- nil
			continue
		}
		go func(path, content string) {
			// Compute destination path
			dstPath := filepath.Join(fs.ProjectRoot, path)
			content = strings.ReplaceAll(content, "\\`\\`\\`", "```")
			// Check if the file exists
			var exists bool
			var mode os.FileMode
			info, err := os.Stat(dstPath)
			if err == nil {
				exists = true
				mode = info.Mode()
			} else {
				if os.IsNotExist(err) {
					exists = false
				} else {
					errCh <- fmt.Errorf("failed to check if %s exists: %s", dstPath, err.Error())
					return
				}
			}

			if exists {
				// read file content
				bytes, err := os.ReadFile(dstPath)
				if err != nil {
					errCh <- fmt.Errorf("failed to read %s: %s", dstPath, err.Error())
					return
				}
				// Check if the file has changed
				if string(bytes) == content {
					// log.Println("File is unchanged, skipping")
					errCh <- nil
					return
				} else {
					mu.Lock()
					updatedFiles = append(updatedFiles, path)
					toRevert[dstPath] = types.ApplyReversion{Content: string(bytes), Mode: mode}
					mu.Unlock()
				}
			} else {
				mu.Lock()
				updatedFiles = append(updatedFiles, path)
				toRemoveOnRollback = append(toRemoveOnRollback, dstPath)
				mu.Unlock()
				// Create the directory if it doesn't exist
				err := os.MkdirAll(filepath.Dir(dstPath), 0755)
				if err != nil {
					errCh <- fmt.Errorf("failed to create directory %s: %s", filepath.Dir(dstPath), err.Error())
					return
				}
			}
			// Write the file
			err = os.WriteFile(dstPath, []byte(content), 0644)
			if err != nil {
				errCh <- fmt.Errorf("failed to write %s: %s", dstPath, err.Error())
				return
			}
			errCh <- nil
		}(path, content)
	}

	for path, remove := range toRemove {
		go func(path string, remove bool) {
			if !remove {
				errCh <- nil
				return
			}
			// Compute destination path
			dstPath := filepath.Join(fs.ProjectRoot, path)
			// Check if the file exists
			var exists bool
			var mode os.FileMode
			info, err := os.Stat(dstPath)
			if err == nil {
				exists = true
				mode = info.Mode()
			} else {
				if os.IsNotExist(err) {
					exists = false
				} else {
					errCh <- fmt.Errorf("failed to check if %s exists: %s", dstPath, err.Error())
					return
				}
			}
			if exists {
				content, err := os.ReadFile(dstPath)
				if err != nil {
					errCh <- fmt.Errorf("failed to read %s: %s", dstPath, err.Error())
					return
				}
				err = os.Remove(dstPath)
				if err != nil && !os.IsNotExist(err) {
					errCh <- fmt.Errorf("failed to remove %s: %s", dstPath, err.Error())
					return
				}
				mu.Lock()
				toRevert[dstPath] = types.ApplyReversion{Content: string(content), Mode: mode}
				mu.Unlock()
			}
			errCh <- nil
		}(path, remove)
	}

	for i := 0; i < totalOps; i++ {
		err := <-errCh
		if err != nil {
			return nil, nil, err
		}
	}

	return updatedFiles, &types.ApplyRollbackPlan{
		PreviousProjectPaths: projectPaths,
		ToRevert:             toRevert,
		ToRemove:             toRemoveOnRollback,
	}, nil
}

func Rollback(rollbackPlan *types.ApplyRollbackPlan, msg bool) error {
	numRoutines := len(rollbackPlan.ToRevert) + len(rollbackPlan.ToRemove) + 1
	errCh := make(chan error, numRoutines)
	for path, revert := range rollbackPlan.ToRevert {
		go func(path string, revert types.ApplyReversion) {
			err := os.WriteFile(path, []byte(revert.Content), revert.Mode)
			if err != nil {
				errCh <- fmt.Errorf("failed to write %s: %s", path, err.Error())
				return
			}
			errCh <- nil
		}(path, revert)
	}

	for _, path := range rollbackPlan.ToRemove {
		go func(path string) {
			err := os.Remove(path)
			if err != nil {
				errCh <- fmt.Errorf("failed to remove %s: %s", path, err.Error())
				return
			}
			errCh <- nil
		}(path)
	}

	go func() {
		var err error
		updatedProjectPaths, err := fs.GetProjectPaths(fs.ProjectRoot)
		if err != nil {
			errCh <- fmt.Errorf("failed to get project paths: %v", err)
		}
		var toRemove []string
		for path := range updatedProjectPaths.AllPaths {
			if _, ok := rollbackPlan.PreviousProjectPaths.AllPaths[path]; !ok {
				toRemove = append(toRemove, path)
			}
		}
		pathsErrCh := make(chan error, len(toRemove))
		for _, path := range toRemove {
			go func(path string) {
				err := os.Remove(path)
				pathsErrCh <- err
			}(path)
		}
		for range toRemove {
			err := <-pathsErrCh
			if err != nil {
				errCh <- fmt.Errorf("failed to remove %s: %s", toRemove, err.Error())
				return
			}
		}
		errCh <- nil
	}()

	errs := []error{}
	for i := 0; i < numRoutines; i++ {
		err := <-errCh
		if err != nil {
			errs = append(errs, err)
		}
	}
	if len(errs) > 0 {
		return fmt.Errorf("failed to rollback: %s", errs)
	}
	if msg {
		fmt.Println("🚫 Rolled back all changes")
	}
	return nil
}


================================================
FILE: app/cli/lib/apply_cgroup_linux.go
================================================
//go:build linux
// +build linux

package lib

import (
	"context"
	"fmt"
	"log"
	"os/exec"
	"time"

	systemdDbus "github.com/coreos/go-systemd/v22/dbus"
	"github.com/godbus/dbus/v5"
	"github.com/google/uuid"
)

const cgroupCallTimeout = 1 * time.Second

func MaybeIsolateCgroup(cmd *exec.Cmd) (deleteFn func()) {
	noop := func() {}
	pid := cmd.Process.Pid

	// 1. Connect to the user manager (no prompt on typical distros).
	ctx, _ := context.WithTimeout(context.Background(), cgroupCallTimeout)

	conn, err := systemdDbus.NewUserConnectionContext(ctx)
	if err != nil {
		log.Printf("⚠️  Could not connect to user systemd manager. No cgroup isolation for PID %d. Error: %v", pid, err)
		return noop
	}
	// We'll keep 'conn' open while scope is active. The scope isn't strictly tied
	// to the connection's lifetime, but it's nice to keep it in case we want to stop the unit.

	scopeName := fmt.Sprintf("plandex-%s.scope", uuid.New().String())

	props := []systemdDbus.Property{
		systemdDbus.PropDescription("Plandex user-scope isolation"),
		// Under system manager, user.slice means “treat it as a user process.”
		// If this is truly in the user manager, it may ignore the slice or map it differently.
		systemdDbus.PropSlice("user.slice"),

		// KillMode=control-group: stopping the scope kills all processes in cgroup.
		systemdDbus.Property{Name: "KillMode", Value: dbus.MakeVariant("control-group")},

		// Attach the existing process by PID
		systemdDbus.PropPids(uint32(pid)),

		// Optional: auto-remove the scope once no processes remain.
		systemdDbus.Property{Name: "CollectMode", Value: dbus.MakeVariant("inactive-or-failed")},
	}

	_, err = conn.StartTransientUnitContext(ctx, scopeName, "replace", props, nil)
	if err != nil {
		// Fallback, no isolation
		log.Printf("⚠️  Failed to start transient scope for PID %d: %v", pid, err)
		return noop
	}

	return func() {
		// Close the connection to the user manager.
		defer conn.Close()

		ctx, cancel := context.WithTimeout(context.Background(), cgroupCallTimeout)
		defer cancel()

		// Attempt to stop the scope (killing all processes if any remain).
		_, stopErr := conn.StopUnitContext(ctx, scopeName, "replace", nil)
		if stopErr != nil {
			log.Printf("⚠️  Failed to stop scope %s: %v", scopeName, stopErr)
		}
	}
}


================================================
FILE: app/cli/lib/apply_cgroup_other.go
================================================
//go:build !linux
// +build !linux

package lib

import "os/exec"

func MaybeIsolateCgroup(cmd *exec.Cmd) (deleteFn func()) {
	return func() {}
}


================================================
FILE: app/cli/lib/apply_proc.go
================================================
package lib

import (
	"os/exec"
	"syscall"
)

func SetPlatformSpecificAttrs(cmd *exec.Cmd) {
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Setpgid: true,
	}
}

func KillProcessGroup(cmd *exec.Cmd, signal syscall.Signal) error {
	return syscall.Kill(-cmd.Process.Pid, signal)
}


================================================
FILE: app/cli/lib/build.go
================================================
package lib

import shared "plandex-shared"

var buildPlanInlineFn func(autoConfirm bool, maybeContexts []*shared.Context) (bool, error)

func SetBuildPlanInlineFn(fn func(autoConfirm bool, maybeContexts []*shared.Context) (bool, error)) {
	buildPlanInlineFn = fn
}


================================================
FILE: app/cli/lib/claude_max.go
================================================
package lib

import (
	"bytes"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/ui"
	shared "plandex-shared"
	"strings"
	"time"

	"github.com/fatih/color"
)

const claudeMaxClientId = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
const claudeMaxScopes = "org:create_api_key user:profile user:inference"
const claudeMaxRedirect = "https://console.anthropic.com/oauth/code/callback"
const claudeMaxTokenUrl = "https://console.anthropic.com/v1/oauth/token"

func hasAnthropicModels(opts shared.ModelProviderOptions) bool {
	for _, opt := range opts {
		if opt.Config.Provider == shared.ModelProviderAnthropic {
			return true
		}
	}
	return false
}

func promptClaudeMaxIfNeeded() bool {
	orgUserConfig := MustGetOrgUserConfig()
	if orgUserConfig.PromptedClaudeMax {
		return false
	}

	term.StopSpinner()
	fmt.Println("ℹ️  The current model pack uses Anthropic models.\n\nIf you have a " + color.New(color.FgHiGreen, color.Bold).Sprint("Claude Pro or Max Subscription") + ", you can connect to it.\n\nPlandex will then use your Claude subscription for Anthropic model calls up to your limit.\n")

	res, err := term.ConfirmYesNo("Connect your Claude subscription?")
	if err != nil {
		term.OutputErrorAndExit("Error confirming claude connection: %v", err)
	}

	// update org user config to avoid prompting again
	orgUserConfig.PromptedClaudeMax = true
	MustUpdateOrgUserConfig(*orgUserConfig)

	if !res {
		fmt.Println()
		fmt.Println("To connect a Claude subscription later, run:\n" + term.ShowCmd("connect-claude"))
		fmt.Println()
		return false
	}

	ConnectClaudeMax()

	return true
}

func connectClaudeMaxIfNeeded() bool {
	accountCreds, err := GetAccountCredentials()
	if err != nil {
		term.OutputErrorAndExit("Error getting account credentials: %v", err)
	}

	if accountCreds == nil || accountCreds.ClaudeMax == nil {

		term.StopSpinner()
		fmt.Println("ℹ️  You connected a " + color.New(color.FgHiGreen, color.Bold).Sprint("Claude Pro or Max subscription,") + "\nbut credentials weren't found on this device.\n")

		res, err := term.ConfirmYesNo("Connect your Claude subscription?")
		if err != nil {
			term.OutputErrorAndExit("Error confirming claude connection: %v", err)
		}

		if res {
			ConnectClaudeMax()
			return true
		}
	}

	return false
}

func refreshClaudeMaxCredsIfNeeded() {
	accountCreds, err := GetAccountCredentials()
	if err != nil {
		term.OutputErrorAndExit("Error getting account credentials: %v", err)
	}
	if accountCreds == nil || accountCreds.ClaudeMax == nil {
		return
	}
	if !needsRefresh(accountCreds.ClaudeMax) || accountCreds.ClaudeMax.RefreshToken == "" {
		return
	}

	_, status, err := refreshCreds(accountCreds)
	if err != nil {
		if status == http.StatusUnauthorized {
			term.StopSpinner()
			color.New(color.FgHiYellow, color.Bold).Println("⚠️ Your Claude subscription's connection has been lost")
			fmt.Println()
			res, err := term.ConfirmYesNo("Reconnect your Claude subscription?")
			if err != nil {
				term.OutputErrorAndExit("Error confirming claude connection: %v", err)
			}
			if !res {
				accountCreds.ClaudeMax = nil
				if err := SetAccountCredentials(accountCreds); err != nil {
					term.OutputErrorAndExit("Error clearing Claude credentials: %v", err)
				}
				return
			}
			ConnectClaudeMax()
			return
		}
		term.OutputErrorAndExit("Error refreshing Claude credentials: %v", err)
	}
}

func ConnectClaudeMax() {
	connectClaudeMaxOauth()

	term.StartSpinner("")
	orgUserConfig := MustGetOrgUserConfig()
	orgUserConfig.UseClaudeSubscription = true
	MustUpdateOrgUserConfig(*orgUserConfig)

	term.StopSpinner()
	fmt.Println()
	fmt.Println("✅ Your Claude subscription is now connected")
	fmt.Println()

	fmt.Println("To disconnect, run:\n" + term.ShowCmd("disconnect-claude"))
	fmt.Println()
}

func DisconnectClaudeMax() {
	term.StartSpinner("")

	orgUserConfig := MustGetOrgUserConfig()
	orgUserConfig.UseClaudeSubscription = false
	MustUpdateOrgUserConfig(*orgUserConfig)

	accountCreds, err := GetAccountCredentials()
	if err != nil {
		term.OutputErrorAndExit("Error getting account credentials: %v", err)
	}

	if accountCreds != nil {
		accountCreds.ClaudeMax = nil
		if err := SetAccountCredentials(accountCreds); err != nil {
			term.OutputErrorAndExit("Error clearing Claude credentials: %v", err)
		}
	}

	term.StopSpinner()

	fmt.Println("✅ Your Claude subscription has been disconnected")
	fmt.Println()
	fmt.Println("To reconnect, run:\n" + term.ShowCmd("connect-claude"))
	fmt.Println()
}

func connectClaudeMaxOauth() {
	verifier, err := genCodeVerifier()
	if err != nil {
		term.OutputErrorAndExit("Error generating code verifier: %v", err)
	}
	challenge := sha256Base64(verifier)

	state, err := genCodeVerifier()
	if err != nil {
		term.OutputErrorAndExit("Error generating state: %v", err)
	}

	authURL := fmt.Sprintf(
		"https://claude.ai/oauth/authorize?code=true&client_id=%s&response_type=code&scope=%s&redirect_uri=%s&code_challenge=%s&code_challenge_method=S256&state=%s",
		claudeMaxClientId, url.QueryEscape(claudeMaxScopes), url.QueryEscape(claudeMaxRedirect), challenge, state,
	)

	term.StopSpinner()

	fmt.Println()
	ui.OpenURL("Opening Claude authentication page in your default browser...", authURL)
	fmt.Println()

	color.New(color.FgHiGreen, color.Bold).Println("📋 Click 'Authorize', copy the Authentication Code, then paste it below.")
	fmt.Println()

	pastedCode, err := term.GetUserPasswordInput("Authentication Code:")
	if err != nil {
		term.OutputErrorAndExit("Error reading pasted authentication code: %v", err)
	}

	split := strings.SplitN(pastedCode, "#", 2)
	if len(split) != 2 {
		term.OutputErrorAndExit("Invalid authentication code: %s", pastedCode)
	}
	code := split[0]
	pastedState := split[1]

	if code == "" || pastedState != state {
		term.OutputErrorAndExit("Claude authentication failed: missing or mismatched oauth code/state")
	}
	term.StartSpinner("")

	tokens, err := exchangeCode(code, verifier, state)
	if err != nil {
		term.OutputErrorAndExit("Error exchanging code: %v", err)
	}

	creds := types.AccountCredentials{
		ClaudeMax: &types.OauthCreds{
			OauthResponse: *tokens,
			ExpiresAt:     time.Now().Add(time.Duration(tokens.ExpiresIn) * time.Second),
		},
	}
	if err := SetAccountCredentials(&creds); err != nil {
		term.OutputErrorAndExit("Error setting account credentials: %v", err)
	}
}

func exchangeCode(code, verifier, state string) (*types.OauthResponse, error) {
	body, _ := json.Marshal(map[string]any{
		"grant_type":    "authorization_code",
		"code":          code,
		"state":         state,
		"code_verifier": verifier,
		"redirect_uri":  claudeMaxRedirect,
		"client_id":     claudeMaxClientId,
	})
	req, err := http.NewRequest("POST", claudeMaxTokenUrl, bytes.NewReader(body))
	if err != nil {
		return nil, fmt.Errorf("token exchange failed - error creating request: %s", err)
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("anthropic-beta", shared.AnthropicClaudeMaxBetaHeader)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		b, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, fmt.Errorf("token exchange failed - error reading body: %s", err)
		}
		return nil, fmt.Errorf("token exchange failed - status: %d, body: %s", resp.StatusCode, b)
	}
	var t types.OauthResponse
	if err := json.NewDecoder(resp.Body).Decode(&t); err != nil {
		return nil, err
	}
	return &t, nil
}

func genCodeVerifier() (string, error) {
	buf := make([]byte, 32)
	if _, err := rand.Read(buf); err != nil {
		return "", err
	}
	return base64.RawURLEncoding.EncodeToString(buf), nil
}

func sha256Base64(verifier string) string {
	sum := sha256.Sum256([]byte(verifier))
	return base64.RawURLEncoding.EncodeToString(sum[:])
}

func needsRefresh(creds *types.OauthCreds) bool {
	// refresh an hour early so we can make multiple calls before it expires
	return time.Now().After(creds.ExpiresAt.Add(-1 * time.Hour))
}

func refreshCreds(accountCreds *types.AccountCredentials) (*types.OauthCreds, int, error) {
	creds := accountCreds.ClaudeMax
	if creds == nil {
		return nil, 0, fmt.Errorf("no stored Claude credentials")
	}

	body, err := json.Marshal(map[string]any{
		"grant_type":    "refresh_token",
		"refresh_token": creds.RefreshToken,
		"client_id":     claudeMaxClientId,
	})
	if err != nil {
		return nil, 0, fmt.Errorf("refresh failed - marshal: %w", err)
	}

	req, err := http.NewRequest("POST", claudeMaxTokenUrl, bytes.NewReader(body))
	if err != nil {
		return nil, 0, fmt.Errorf("refresh failed - create request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("anthropic-beta", shared.AnthropicClaudeMaxBetaHeader)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, 0, fmt.Errorf("refresh failed - http: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		b, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, 0, fmt.Errorf("refresh failed - read body: %w", err)
		}
		return nil, resp.StatusCode, fmt.Errorf("refresh failed - status %d: %s", resp.StatusCode, b)
	}

	var r types.OauthResponse
	if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
		return nil, 0, fmt.Errorf("refresh failed - decode: %w", err)
	}

	newCreds := &types.OauthCreds{
		OauthResponse: r,
		ExpiresAt:     time.Now().Add(time.Duration(r.ExpiresIn) * time.Second),
	}

	// persist updated creds
	accountCreds.ClaudeMax = newCreds
	if err := SetAccountCredentials(accountCreds); err != nil {
		return nil, 0, fmt.Errorf("refresh failed - save: %w", err)
	}

	return newCreds, resp.StatusCode, nil
}


================================================
FILE: app/cli/lib/context_auto_load.go
================================================
package lib

import (
	"context"
	"encoding/base64"
	"fmt"
	"log"
	"os"
	"plandex-cli/api"
	"plandex-cli/types"
	shared "plandex-shared"
	"sync"

	"github.com/sashabaranov/go-openai"
)

func AutoLoadContextFiles(ctx context.Context, files []string) (string, error) {
	contexts, err := api.Client.ListContext(CurrentPlanId, CurrentBranch)
	if err != nil {
		return "", fmt.Errorf("failed to get contexts: %v", err)
	}

	var totalSize int64
	totalContexts := len(contexts)

	for _, context := range contexts {
		totalSize += context.BodySize
	}

	loadContextReqsByIndex := make(map[int]*shared.LoadContextParams)
	filesSkippedTooLarge := []filePathWithSize{}
	filesSkippedAfterSizeLimit := []string{}

	var mu sync.Mutex
	errCh := make(chan error, len(files))

	for i, path := range files {
		totalContexts++
		if totalContexts > shared.MaxContextCount {
			log.Println("Skipping file", path, "because it would exceed the max context count", totalContexts)
			filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, path)
			errCh <- nil
			continue
		}

		go func(index int, path string) {
			fileInfo, err := os.Stat(path)
			if err != nil {
				errCh <- fmt.Errorf("failed to get file info for %s: %v", path, err)
				return
			}

			if fileInfo.IsDir() {
				log.Println("Skipping directory", path)
				errCh <- nil // skip directories
				return
			}

			size := fileInfo.Size()

			mu.Lock()
			if size > shared.MaxContextBodySize {
				log.Println("Skipping file", path, "because it's too large", size)
				filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: path, Size: size})
				mu.Unlock()
				errCh <- nil
				return
			}
			if totalSize+size > shared.MaxTotalContextSize {
				log.Println("Skipping file", path, "because it would exceed the max context body size", totalSize+size)
				filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, path)
				mu.Unlock()
				errCh <- nil
				return
			}
			totalSize += size
			mu.Unlock()

			b, err := os.ReadFile(path)
			if err != nil {
				errCh <- fmt.Errorf("failed to read file %s: %v", path, err)
				return
			}

			var contextType shared.ContextType
			isImage := shared.IsImageFile(path)
			if isImage {
				contextType = shared.ContextImageType
			} else {
				contextType = shared.ContextFileType
			}

			var imageDetail openai.ImageURLDetail
			if isImage {
				imageDetail = openai.ImageURLDetailHigh
			}

			var body string
			if isImage {
				body = base64.StdEncoding.EncodeToString(b)
			} else {
				body = string(shared.NormalizeEOL(b))
			}

			mu.Lock()
			loadContextReqsByIndex[index] = &shared.LoadContextParams{
				ContextType: contextType,
				FilePath:    path,
				Name:        path,
				Body:        body,
				AutoLoaded:  true,
				ImageDetail: imageDetail,
			}
			mu.Unlock()
			errCh <- nil
		}(i, path)
	}

	for range files {
		if e := <-errCh; e != nil {
			return "", fmt.Errorf("failed to load context: %v", e)
		}
	}

	// Convert map back to ordered slice
	loadContextReqs := make(shared.LoadContextRequest, 0, len(loadContextReqsByIndex))
	for i := 0; i < len(files); i++ {
		if req := loadContextReqsByIndex[i]; req != nil {
			loadContextReqs = append(loadContextReqs, req)
		}
	}

	// even if there are no files to load, we still need to hit the API endpoint because the stream is waiting on a channel for the autoload to finish
	res, apiErr := api.Client.AutoLoadContext(ctx, CurrentPlanId, CurrentBranch, loadContextReqs)
	if apiErr != nil {
		return "", fmt.Errorf("failed to load context: %v", apiErr.Msg)
	}

	if res.MaxTokensExceeded {
		overage := res.TotalTokens - res.MaxTokens
		return "", fmt.Errorf("update would add %d 🪙 and exceed token limit (%d) by %d 🪙", res.TokensAdded, res.MaxTokens, overage)
	}

	msg := res.Msg

	// Print skip info if any
	if len(filesSkippedTooLarge) > 0 || len(filesSkippedAfterSizeLimit) > 0 {
		msg += "\n\n" + getSkippedFilesMsg(filesSkippedTooLarge, filesSkippedAfterSizeLimit, nil, nil)
	}

	return msg, nil
}

func MustLoadAutoContextMap() {
	MustLoadContext([]string{"."}, &types.LoadContextParams{
		DefsOnly:          true,
		SkipIgnoreWarning: true,
		AutoLoaded:        true,
	})
}


================================================
FILE: app/cli/lib/context_conflict.go
================================================
package lib

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/term"

	"github.com/fatih/color"
)

func checkContextConflicts(filesByPath map[string]string) (bool, error) {
	// log.Println("Checking for context conflicts.")
	// log.Println(spew.Sdump(filesByPath))

	currentPlan, err := api.Client.GetCurrentPlanState(CurrentPlanId, CurrentBranch)

	if err != nil {
		return false, fmt.Errorf("error getting current plan state: %v", err)
	}

	conflictedPaths := currentPlan.PlanResult.FileResultsByPath.ConflictedPaths(filesByPath)

	// log.Println("Conflicted paths:", conflictedPaths)

	if len(conflictedPaths) > 0 {
		term.StopSpinner()
		color.New(color.Bold, term.ColorHiYellow).Println("⚠️  Some updates conflict with pending changes:")
		for path := range conflictedPaths {
			fmt.Println("📄 " + path)
		}

		fmt.Println()

		res, err := term.ConfirmYesNo("Update context and rebuild changes?")

		if err != nil {
			return false, fmt.Errorf("error confirming update and rebuild: %v", err)
		}

		if !res {
			fmt.Println("Context update canceled")
			os.Exit(0)
		}
	}

	return len(conflictedPaths) > 0, nil
}


================================================
FILE: app/cli/lib/context_display.go
================================================
package lib

import shared "plandex-shared"

func GetContextLabelAndIcon(contextType shared.ContextType) (string, string) {
	var icon string
	var lbl string
	switch contextType {
	case shared.ContextFileType:
		icon = "📄"
		lbl = "file"
	case shared.ContextURLType:
		icon = "🌎"
		lbl = "url"
	case shared.ContextDirectoryTreeType:
		icon = "🗂 "
		lbl = "tree"
	case shared.ContextNoteType:
		icon = "✏️ "
		lbl = "note"
	case shared.ContextPipedDataType:
		icon = "↔️ "
		lbl = "piped"
	case shared.ContextImageType:
		icon = "🖼️ "
		lbl = "image"
	case shared.ContextMapType:
		icon = "🗺️ "
		lbl = "map"
	}

	return lbl, icon
}

func FindContextByIndex(contexts []*shared.Context, index int) *shared.Context {
	// Convert to 0-based index
	index--
	if index < 0 || index >= len(contexts) {
		return nil
	}
	return contexts[index]
}

func FindContextByName(contexts []*shared.Context, name string) *shared.Context {
	for _, ctx := range contexts {
		if ctx.Name == name || ctx.FilePath == name {
			return ctx
		}
	}
	return nil
}


================================================
FILE: app/cli/lib/context_load.go
================================================
package lib

import (
	"bufio"
	"encoding/base64"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/url"
	"strings"
	"sync"

	shared "plandex-shared"

	"github.com/fatih/color"
)

const maxSkippedFileList = 20

func MustLoadContext(resources []string, params *types.LoadContextParams) {
	if params.DefsOnly {
		// while caching is set up to work with multiple map paths, it can end up in a partially loaded state if token limits are exceeded, so better to just load one at a time
		if len(resources) > 1 {
			term.OutputErrorAndExit("Please load a single map directory at a time")
		}

		term.LongSpinnerWithWarning("🗺️  Building project map...", "🗺️  This can take a while in larger projects...")
	} else if params.NamesOnly {
		term.LongSpinnerWithWarning("🌳 Loading directory tree...", "🌳 This can take a while in larger projects...")
	} else {
		term.StartSpinner("📥 Loading context...")
	}

	onErr := func(err error) {
		term.StopSpinner()
		term.OutputErrorAndExit("Failed to load context: %v", err)
	}

	var loadContextReq shared.LoadContextRequest

	fileInfo, err := os.Stdin.Stat()
	if err != nil {
		onErr(fmt.Errorf("failed to stat stdin: %v", err))
	}

	var authVars map[string]string
	var openAIBase string

	if params.Note != "" || fileInfo.Mode()&os.ModeNamedPipe != 0 {
		authVars = MustVerifyAuthVarsSilent(auth.Current.IntegratedModelsMode)
	}

	if params.Note != "" {
		loadContextReq = append(loadContextReq, &shared.LoadContextParams{
			ContextType: shared.ContextNoteType,
			Body:        params.Note,
			ApiKeys:     authVars,
			OpenAIBase:  openAIBase,
			OpenAIOrgId: os.Getenv("OPENAI_ORG_ID"),
			SessionId:   params.SessionId,
			AutoLoaded:  params.AutoLoaded,
		})
	}

	if fileInfo.Mode()&os.ModeNamedPipe != 0 {
		reader := bufio.NewReader(os.Stdin)
		pipedData, err := io.ReadAll(reader)
		if err != nil {
			onErr(fmt.Errorf("failed to read piped data: %v", err))
		}

		if len(pipedData) > 0 {
			loadContextReq = append(loadContextReq, &shared.LoadContextParams{
				ContextType: shared.ContextPipedDataType,
				Body:        string(pipedData),
				ApiKeys:     authVars,
				OpenAIBase:  openAIBase,
				OpenAIOrgId: os.Getenv("OPENAI_ORG_ID"),
				SessionId:   params.SessionId,
				AutoLoaded:  params.AutoLoaded,
			})
		}
	}

	var inputUrls []string
	var inputFilePaths []string

	if len(resources) > 0 {
		for _, resource := range resources {
			// so far resources are either files or urls
			if url.IsValidURL(resource) {
				inputUrls = append(inputUrls, resource)
			} else {
				if strings.HasPrefix(resource, "."+string(os.PathSeparator)) {
					resource = resource[2:]
				}

				inputFilePaths = append(inputFilePaths, resource)
			}
		}
	}

	var contextMu sync.Mutex

	errCh := make(chan error)
	ignoredPaths := make(map[string]string)

	mapFilesTruncatedTooLarge := []filePathWithSize{}
	mapFilesSkippedAfterSizeLimit := []string{}

	// We'll reuse these for all skipping, including directory-tree partial skipping and URLs
	filesSkippedTooLarge := []filePathWithSize{}
	filesSkippedAfterSizeLimit := []string{}

	var totalSize int64

	numRoutines := 0

	// filter out already loaded contexts
	alreadyLoadedByComposite := make(map[string]*shared.Context)
	existingContexts, apiErr := api.Client.ListContext(CurrentPlanId, CurrentBranch)
	if apiErr != nil {
		onErr(fmt.Errorf("failed to list contexts: %v", apiErr.Msg))
	}

	existsByComposite := make(map[string]*shared.Context)
	for _, context := range existingContexts {
		switch context.ContextType {
		case shared.ContextFileType, shared.ContextDirectoryTreeType, shared.ContextMapType, shared.ContextImageType:
			existsByComposite[strings.Join([]string{string(context.ContextType), context.FilePath}, "|")] = context
		case shared.ContextURLType:
			existsByComposite[strings.Join([]string{string(context.ContextType), context.Url}, "|")] = context
		}
	}

	var cachedMapPaths map[string]bool
	var cachedMapLoadRes *shared.LoadContextResponse

	mapInputShas := map[string]string{}
	mapInputTokens := map[string]int{}
	mapInputSizes := map[string]int64{}

	toLoadMapPaths := []string{}
	mapInputPathsForPaths := map[string]string{}

	currentMapInputBatch := shared.FileMapInputs{}
	mapInputBatches := []shared.FileMapInputs{currentMapInputBatch}

	sem := make(chan struct{}, ContextMapMaxClientConcurrency)

	if len(inputFilePaths) > 0 {

		var mapSize int64

		if params.DefsOnly {
			for _, inputFilePath := range inputFilePaths {
				composite := strings.Join([]string{string(shared.ContextMapType), inputFilePath}, "|")
				if existsByComposite[composite] != nil {
					alreadyLoadedByComposite[composite] = existsByComposite[composite]
					continue
				}

				toLoadMapPaths = append(toLoadMapPaths, inputFilePath)
			}

			var uncachedMapPaths []string

			res, err := api.Client.LoadCachedFileMap(CurrentPlanId, CurrentBranch, shared.LoadCachedFileMapRequest{
				FilePaths: toLoadMapPaths,
			})

			if err != nil {
				onErr(fmt.Errorf("error checking cached file map: %v", err))
			}

			if res.LoadRes != nil {
				if res.LoadRes.MaxTokensExceeded {
					term.StopSpinner()
					overage := res.LoadRes.TotalTokens - res.LoadRes.MaxTokens

					term.OutputErrorAndExit("Update would add %d 🪙 and exceed token limit (%d) by %d 🪙\n", res.LoadRes.TokensAdded, res.LoadRes.MaxTokens, overage)
				}

				cachedMapLoadRes = res.LoadRes
				cachedMapPaths = res.CachedByPath

				for _, path := range toLoadMapPaths {
					if !cachedMapPaths[path] {
						uncachedMapPaths = append(uncachedMapPaths, path)
					}
				}
			} else {
				uncachedMapPaths = toLoadMapPaths
			}

			toLoadMapPaths = uncachedMapPaths
			inputFilePaths = toLoadMapPaths
		}

		if len(inputFilePaths) > 0 {
			baseDir := fs.GetBaseDirForFilePaths(inputFilePaths)

			paths, err := fs.GetProjectPaths(baseDir)
			if err != nil {
				onErr(fmt.Errorf("failed to get project paths: %v", err))
			}

			if !params.ForceSkipIgnore {
				var filteredPaths []string
				for _, inputFilePath := range inputFilePaths {
					if _, ok := paths.ActivePaths[inputFilePath]; !ok {
						ignored, reason, err := fs.IsIgnored(paths, inputFilePath, baseDir)
						if err != nil {
							onErr(fmt.Errorf("failed to check if %s is ignored: %v", inputFilePath, err))
						}
						if ignored {
							ignoredPaths[inputFilePath] = reason
						}
					} else {
						filteredPaths = append(filteredPaths, inputFilePath)
					}
				}
				inputFilePaths = filteredPaths

			}

			if params.NamesOnly {
				// "params.NamesOnly" => we create directory-tree contexts (ContextDirectoryTreeType)
				// Partial skipping of subpaths
				for _, inputFilePath := range inputFilePaths {
					composite := strings.Join([]string{string(shared.ContextDirectoryTreeType), inputFilePath}, "|")
					if existsByComposite[composite] != nil {
						alreadyLoadedByComposite[composite] = existsByComposite[composite]
						continue
					}

					numRoutines++
					go func(inputFilePath string) {
						sem <- struct{}{}
						defer func() { <-sem }()

						flattenedPaths, err := ParseInputPaths(ParseInputPathsParams{
							FileOrDirPaths: []string{inputFilePath},
							BaseDir:        baseDir,
							ProjectPaths:   paths,
							LoadParams:     params,
						})
						if err != nil {
							errCh <- fmt.Errorf("failed to parse input paths: %v", err)
							return
						}

						if !params.ForceSkipIgnore {
							var filteredPaths []string
							for _, path := range flattenedPaths {
								if _, ok := paths.ActivePaths[path]; ok {
									filteredPaths = append(filteredPaths, path)
								} else {
									ignored, reason, err := fs.IsIgnored(paths, path, baseDir)
									if err != nil {
										errCh <- fmt.Errorf("failed to check if %s is ignored: %v", path, err)
										return
									}
									if ignored {
										ignoredPaths[path] = reason
									}
								}
							}
							flattenedPaths = filteredPaths
						}

						// PARTIAL skipping of subpaths
						var keptPaths []string
						for _, p := range flattenedPaths {
							lineSize := int64(len(p))

							contextMu.Lock()
							if lineSize > shared.MaxContextBodySize {
								filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: p, Size: lineSize})
								contextMu.Unlock()
								continue
							}

							if totalSize+lineSize > shared.MaxContextBodySize {
								filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, p)
								contextMu.Unlock()
								continue
							}

							totalSize += lineSize
							contextMu.Unlock()

							keptPaths = append(keptPaths, p)
						}

						body := strings.Join(keptPaths, "\n")

						name := inputFilePath
						if name == "." {
							name = "cwd"
						}
						if name == ".." {
							name = "parent"
						}

						contextMu.Lock()
						loadContextReq = append(loadContextReq, &shared.LoadContextParams{
							ContextType:     shared.ContextDirectoryTreeType,
							Name:            name,
							Body:            body,
							FilePath:        inputFilePath,
							ForceSkipIgnore: params.ForceSkipIgnore,
							AutoLoaded:      params.AutoLoaded,
						})
						contextMu.Unlock()

						errCh <- nil
					}(inputFilePath)
				}

			} else {
				flattenedPaths, err := ParseInputPaths(ParseInputPathsParams{
					FileOrDirPaths: inputFilePaths,
					BaseDir:        baseDir,
					ProjectPaths:   paths,
					LoadParams:     params,
				})
				if err != nil {
					onErr(fmt.Errorf("failed to parse input paths: %v", err))
				}

				if !params.ForceSkipIgnore {
					var filteredPaths []string
					for _, path := range flattenedPaths {
						if _, ok := paths.ActivePaths[path]; ok {
							filteredPaths = append(filteredPaths, path)
						} else {
							ignored, reason, err := fs.IsIgnored(paths, path, baseDir)
							if err != nil {
								onErr(fmt.Errorf("failed to check if %s is ignored: %v", path, err))
							}
							if ignored {
								ignoredPaths[path] = reason
							}
						}
					}
					flattenedPaths = filteredPaths

				}

				var numPaths int
				if params.DefsOnly {
					filtered := []string{}
					for _, path := range flattenedPaths {
						if shared.HasFileMapSupport(path) {
							numPaths++

							if numPaths > shared.MaxContextMapPaths {
								mapFilesSkippedAfterSizeLimit = append(mapFilesSkippedAfterSizeLimit, path)
								continue
							}

							filtered = append(filtered, path)
						}
					}
					flattenedPaths = filtered
				} else if params.NamesOnly {
					filtered := []string{}
					for _, path := range flattenedPaths {
						numPaths++

						if numPaths > shared.MaxContextMapPaths {
							filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, path)
							continue
						}

						filtered = append(filtered, path)
					}
					flattenedPaths = filtered
				} else {
					filtered := []string{}
					for _, path := range flattenedPaths {
						numPaths++

						if numPaths > shared.MaxContextCount {
							filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, path)
							continue
						}

						filtered = append(filtered, path)
					}
					flattenedPaths = filtered
				}

				inputFilePaths = flattenedPaths

				for _, path := range flattenedPaths {
					var mapInputPath string
					if params.DefsOnly {
						for _, inputPath := range toLoadMapPaths {
							absPath, err := filepath.Abs(path)
							if err != nil {
								continue
							}
							absInputPath, err := filepath.Abs(inputPath)
							if err != nil {
								continue
							}
							if absPath == absInputPath ||
								strings.HasPrefix(absPath+string(os.PathSeparator), absInputPath+string(os.PathSeparator)) {
								mapInputPath = inputPath
								break
							}
						}

						if mapInputPath == "" {
							continue
						}

						mapInputPathsForPaths[path] = mapInputPath
					}

					var contextType shared.ContextType
					isImage := shared.IsImageFile(path)
					if isImage {
						contextType = shared.ContextImageType
					} else if params.DefsOnly {
						contextType = shared.ContextMapType
					} else {
						contextType = shared.ContextFileType
					}

					if !params.DefsOnly {
						composite := strings.Join([]string{string(contextType), path}, "|")
						if existsByComposite[composite] != nil {
							alreadyLoadedByComposite[composite] = existsByComposite[composite]
							continue
						}
					}

					numRoutines++

					go func(path string) {
						sem <- struct{}{}
						defer func() { <-sem }()

						var size int64

						fileInfo, err := os.Stat(path)
						if err != nil {
							errCh <- fmt.Errorf("failed to get file info for %s: %v", path, err)
							return
						}
						size = fileInfo.Size()

						if !params.DefsOnly && size > shared.MaxContextBodySize {
							contextMu.Lock()
							filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: path, Size: size})
							contextMu.Unlock()
							errCh <- nil
							return
						}

						if !params.DefsOnly {
							contextMu.Lock()
							if totalSize+size > shared.MaxContextBodySize {
								filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, path)
								contextMu.Unlock()
								errCh <- nil
								return
							}
							totalSize += size
							contextMu.Unlock()
						}

						if params.DefsOnly {
							res, err := getMapFileDetails(path, size, totalSize)
							if err != nil {
								errCh <- fmt.Errorf("failed to get map file details for %s: %v", path, err)
								return
							}

							contextMu.Lock()
							defer contextMu.Unlock()

							if currentMapInputBatch.NumFiles()+1 > shared.ContextMapMaxBatchSize || currentMapInputBatch.TotalSize()+size > shared.ContextMapMaxBatchBytes {
								currentMapInputBatch = shared.FileMapInputs{}
								mapInputBatches = append(mapInputBatches, currentMapInputBatch)
							}

							currentMapInputBatch[path] = res.mapContent
							mapSize += res.size
							mapInputShas[path] = res.shaVal
							mapInputTokens[path] = res.tokens
							mapInputSizes[path] = res.size

							if len(res.mapFilesTruncatedTooLarge) > 0 {
								mapFilesTruncatedTooLarge = append(mapFilesTruncatedTooLarge, res.mapFilesTruncatedTooLarge...)
							}

							if len(res.mapFilesSkippedAfterSizeLimit) > 0 {
								mapFilesSkippedAfterSizeLimit = append(mapFilesSkippedAfterSizeLimit, res.mapFilesSkippedAfterSizeLimit...)
							}

						} else if isImage {
							fileContent, err := os.ReadFile(path)
							if err != nil {
								errCh <- fmt.Errorf("failed to read the file %s: %v", path, err)
								return
							}

							contextMu.Lock()
							defer contextMu.Unlock()

							loadContextReq = append(loadContextReq, &shared.LoadContextParams{
								ContextType: shared.ContextImageType,
								Name:        path,
								Body:        base64.StdEncoding.EncodeToString(fileContent),
								FilePath:    path,
								ImageDetail: params.ImageDetail,
								AutoLoaded:  params.AutoLoaded,
							})
						} else {
							fileContent, err := os.ReadFile(path)
							if err != nil {
								errCh <- fmt.Errorf("failed to read the file %s: %v", path, err)
								return
							}
							fileContent = shared.NormalizeEOL(fileContent)

							contextMu.Lock()
							defer contextMu.Unlock()

							loadContextReq = append(loadContextReq, &shared.LoadContextParams{
								ContextType: shared.ContextFileType,
								Name:        path,
								Body:        string(fileContent),
								FilePath:    path,
								AutoLoaded:  params.AutoLoaded,
							})
						}

						errCh <- nil
					}(path)
				}
			}
		}
	}

	if len(inputUrls) > 0 {
		for _, u := range inputUrls {
			composite := strings.Join([]string{string(shared.ContextURLType), u}, "|")
			if existsByComposite[composite] != nil {
				alreadyLoadedByComposite[composite] = existsByComposite[composite]
				continue
			}

			numRoutines++
			go func(u string) {
				sem <- struct{}{}
				defer func() { <-sem }()

				body, err := url.FetchURLContent(u)
				if err != nil {
					errCh <- fmt.Errorf("failed to fetch content from URL %s: %v", u, err)
					return
				}

				name := url.SanitizeURL(u)
				// show the first 20 characters, then ellipsis then the last 20 characters of 'name'
				if len(name) > 40 {
					name = name[:20] + "⋯" + name[len(name)-20:]
				}

				// Check the size of the URL body, just like a file:
				size := int64(len(body))

				contextMu.Lock()
				defer contextMu.Unlock()

				if size > shared.MaxContextBodySize {
					filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: u, Size: size})
					errCh <- nil
					return
				}
				if totalSize+size > shared.MaxContextBodySize {
					filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, u)
					errCh <- nil
					return
				}
				totalSize += size

				loadContextReq = append(loadContextReq, &shared.LoadContextParams{
					ContextType: shared.ContextURLType,
					Name:        name,
					Body:        body,
					Url:         u,
					AutoLoaded:  params.AutoLoaded,
				})

				errCh <- nil
			}(u)
		}
	}

	for i := 0; i < numRoutines; i++ {
		err := <-errCh
		if err != nil {
			onErr(err)
		}
	}

	if params.DefsOnly {
		allMapBodies, err := processMapBatches(mapInputBatches)
		if err != nil {
			onErr(fmt.Errorf("failed to process map batches: %v", err))
		}

		for _, inputPath := range toLoadMapPaths {
			var name string
			if inputPath == "." {
				name = "cwd"
			} else if inputPath == ".." {
				name = "parent"
			} else {
				name = inputPath
			}

			pathBodies := shared.FileMapBodies{}
			pathShas := map[string]string{}
			pathTokens := map[string]int{}
			pathSizes := map[string]int64{}
			for path, body := range allMapBodies {
				mapInputPath := mapInputPathsForPaths[path]
				if mapInputPath == inputPath {
					pathBodies[path] = body
					pathShas[path] = mapInputShas[path]
					pathTokens[path] = mapInputTokens[path]
					pathSizes[path] = mapInputSizes[path]
				}
			}

			// load the map even if it's empty (no paths)
			// it needs to exist so it can be updated later
			loadContextReq = append(loadContextReq, &shared.LoadContextParams{
				ContextType: shared.ContextMapType,
				Name:        name,
				MapBodies:   pathBodies,
				InputShas:   pathShas,
				InputTokens: pathTokens,
				InputSizes:  pathSizes,
				FilePath:    inputPath,
				AutoLoaded:  params.AutoLoaded,
			})

		}
	}

	filesToLoad := map[string]string{}
	for _, context := range loadContextReq {
		if context.ContextType == shared.ContextFileType {
			filesToLoad[context.FilePath] = context.Body
		}
	}

	hasConflicts, err := checkContextConflicts(filesToLoad)

	if err != nil {
		onErr(fmt.Errorf("failed to check context conflicts: %v", err))
	}

	if len(loadContextReq)+len(cachedMapPaths) == 0 {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context loaded")

		didOutputReason := false
		if len(alreadyLoadedByComposite) > 0 {
			printAlreadyLoadedMsg(alreadyLoadedByComposite)
			didOutputReason = true
		}
		if len(ignoredPaths) > 0 && !params.SkipIgnoreWarning {
			printIgnoredMsg()
			didOutputReason = true
		}

		if !didOutputReason {
			fmt.Println()
			fmt.Printf("Use %s to load a file or URL:", color.New(color.BgCyan, color.FgHiWhite).Sprint(" plandex load [file-path|url] "))
			fmt.Println()
			fmt.Println("plandex load file.c file.h")
			fmt.Println("plandex load https://github.com/some-org/some-repo/README.md")

			fmt.Println()
			fmt.Printf("%s with the --recursive/-r flag:\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Load a whole directory"))
			fmt.Println("plandex load app/src -r")

			fmt.Println()
			fmt.Printf("%s with the --tree flag:\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Load a directory layout (file names only)"))

			fmt.Println()
			fmt.Printf("%s file paths are relative to the current directory\n", color.New(color.Bold, term.ColorHiYellow).Sprint("Note:"))

			fmt.Println()
			fmt.Printf("%s with the -n flag:\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Load a note"))
			fmt.Println("plandex load -n 'Some note here'")

			fmt.Println()
			fmt.Printf("%s from any command:\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Pipe data in"))
			fmt.Println("npm test | plandex load")
		}

		os.Exit(0)
	}

	var res *shared.LoadContextResponse
	if cachedMapLoadRes != nil {
		res = cachedMapLoadRes
	} else {
		res, apiErr = api.Client.LoadContext(CurrentPlanId, CurrentBranch, loadContextReq)
		if apiErr != nil {
			onErr(fmt.Errorf("failed to load context: %v", apiErr.Msg))
		}
	}

	term.StopSpinner()

	if hasConflicts {
		term.StartSpinner("🏗️  Starting build...")
		_, err := buildPlanInlineFn(false, nil)
		if err != nil {
			onErr(fmt.Errorf("failed to build plan: %v", err))
		}
		fmt.Println()
	}

	fmt.Println("✅ " + res.Msg)

	if len(alreadyLoadedByComposite) > 0 {
		printAlreadyLoadedMsg(alreadyLoadedByComposite)
	}

	if len(ignoredPaths) > 0 && !params.SkipIgnoreWarning {
		printIgnoredMsg()
	}

	if len(filesSkippedTooLarge) > 0 || len(filesSkippedAfterSizeLimit) > 0 ||
		len(mapFilesTruncatedTooLarge) > 0 || len(mapFilesSkippedAfterSizeLimit) > 0 {
		printSkippedFilesMsg(filesSkippedTooLarge, filesSkippedAfterSizeLimit,
			mapFilesTruncatedTooLarge, mapFilesSkippedAfterSizeLimit)
	}
}

func printAlreadyLoadedMsg(alreadyLoadedByComposite map[string]*shared.Context) {
	fmt.Println()
	pronoun := "they're"
	if len(alreadyLoadedByComposite) == 1 {
		pronoun = "it's"
	}
	fmt.Printf("🙅‍♂️ Skipped because %s already in context:\n", pronoun)
	for _, context := range alreadyLoadedByComposite {
		_, icon := context.TypeAndIcon()

		fmt.Printf("  • %s %s\n", icon, context.Name)
	}
}

func printIgnoredMsg() {
	fmt.Println()
	fmt.Println("ℹ️  " + color.New(color.FgWhite).Sprint("Due to .gitignore or .plandexignore, some paths weren't loaded.\nUse --force / -f to load ignored paths."))
}


================================================
FILE: app/cli/lib/context_paths.go
================================================
package lib

import (
	"fmt"
	"plandex-cli/fs"
	"plandex-cli/types"
)

type ParseInputPathsParams struct {
	FileOrDirPaths []string
	BaseDir        string
	ProjectPaths   *types.ProjectPaths
	LoadParams     *types.LoadContextParams
}

func ParseInputPaths(params ParseInputPathsParams) ([]string, error) {
	fileOrDirPaths := params.FileOrDirPaths
	baseDir := params.BaseDir
	projectPaths := params.ProjectPaths
	loadParams := params.LoadParams

	resPaths := []string{}

	for path := range projectPaths.AllPaths {
		// see if it's a child of any of the fileOrDirPaths
		found := false
		for _, p := range fileOrDirPaths {
			var err error
			found, err = fs.IsSubpathOf(p, path, baseDir)
			if err != nil {
				return nil, fmt.Errorf("error checking if %s is a subpath of %s: %s", path, p, err)
			}
			if found {
				break
			}
		}

		if !found {
			continue
		}

		if projectPaths.AllDirs[path] {
			if !(loadParams.Recursive || loadParams.NamesOnly || loadParams.DefsOnly) {
				// log.Println("path", path, "info.Name()", info.Name())
				return nil, fmt.Errorf("cannot process directory %s: requires --recursive/-r, --tree, or --map flag", path)
			}

			// calculate directory depth from base
			// depth := strings.Count(path[len(p):], string(filepath.Separator))
			// if params.MaxDepth != -1 && depth > params.MaxDepth {
			// 	return filepath.SkipDir
			// }

			if loadParams.NamesOnly {
				// add directory name to results
				resPaths = append(resPaths, path)
			}
		} else {
			// add file path to results
			resPaths = append(resPaths, path)
		}
	}

	return resPaths, nil
}


================================================
FILE: app/cli/lib/context_shared.go
================================================
package lib

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"os"
	"plandex-cli/api"
	"strings"
	"sync"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

const ContextMapMaxClientConcurrency = 250

type filePathWithSize struct {
	Path string
	Size int64
}

type mapFileDetails struct {
	size                          int64
	tokens                        int
	shaVal                        string
	mapFilesSkippedAfterSizeLimit []string
	mapFilesTruncatedTooLarge     []filePathWithSize
	mapContent                    string
}

func getMapFileDetails(path string, size, mapSize int64) (mapFileDetails, error) {
	var isImage bool
	var totalMapSizeExceeded bool

	res := mapFileDetails{
		size:                          size,
		mapFilesSkippedAfterSizeLimit: []string{},
		mapFilesTruncatedTooLarge:     []filePathWithSize{},
	}

	if !shared.HasFileMapSupport(path) {
		if shared.IsImageFile(path) {
			isImage = true

			var err error
			res.tokens, err = readImageTokensForDefsOnly(path, size, openai.ImageURLDetailHigh, 8*1024)
			if err != nil {
				return mapFileDetails{}, fmt.Errorf("failed to read image tokens for %s: %v", path, err)
			}
		} else {
			res.tokens = shared.GetBytesToTokensEstimate(size)
		}
	} else {
		var truncated bool
		if size > shared.MaxContextMapSingleInputSize {
			size = shared.MaxContextMapSingleInputSize
			truncated = true
			res.tokens = shared.GetBytesToTokensEstimate(size)
		}

		// should go in either skip list *or* truncated list, not both
		if mapSize+size > shared.MaxContextMapTotalInputSize {
			totalMapSizeExceeded = true
			res.mapFilesSkippedAfterSizeLimit = append(res.mapFilesSkippedAfterSizeLimit, path)
			res.tokens = shared.GetBytesToTokensEstimate(size)
		} else if truncated {
			res.mapFilesTruncatedTooLarge = append(res.mapFilesTruncatedTooLarge, filePathWithSize{Path: path, Size: size})
		}
	}

	if totalMapSizeExceeded || !shared.HasFileMapSupport(path) || isImage {
		shaVal := sha256.Sum256([]byte(fmt.Sprintf("%d", res.tokens)))
		res.shaVal = hex.EncodeToString(shaVal[:])

		res.mapContent = ""
		res.size = 0
	} else {
		// partial read for the map
		contentRes, err := getMapFileContent(path)
		if err != nil {
			return mapFileDetails{}, fmt.Errorf("failed to read file %s: %v", path, err)
		}

		res.mapContent = contentRes.content
		res.shaVal = contentRes.shaVal

		if contentRes.truncated {
			res.mapFilesTruncatedTooLarge = append(res.mapFilesTruncatedTooLarge, filePathWithSize{Path: path, Size: shared.MaxContextMapSingleInputSize})
			res.size = shared.MaxContextMapSingleInputSize
			res.tokens = shared.GetBytesToTokensEstimate(shared.MaxContextMapSingleInputSize)
		} else {
			// do the actual token count if we didn't truncate
			res.tokens = shared.GetNumTokensEstimate(res.mapContent)
		}
	}

	return res, nil
}

type mapFileContent struct {
	mapData   []byte
	content   string
	shaVal    string
	truncated bool
}

func getMapFileContent(path string) (mapFileContent, error) {
	f, err := os.Open(path)
	if err != nil {
		return mapFileContent{}, err
	}
	defer f.Close()

	info, err := f.Stat()
	if err != nil {
		return mapFileContent{}, err
	}
	size := info.Size()

	limit := int64(shared.MaxContextMapSingleInputSize)
	truncated := size > limit

	limitReader := io.LimitReader(f, limit)
	bytes, err := io.ReadAll(limitReader)
	if err != nil {
		return mapFileContent{}, err
	}

	sum := sha256.Sum256(bytes)
	shaVal := hex.EncodeToString(sum[:])

	return mapFileContent{mapData: bytes, content: string(bytes), shaVal: shaVal, truncated: truncated}, nil
}

func processMapBatches(mapInputBatches []shared.FileMapInputs) (shared.FileMapBodies, error) {
	allMapBodies := shared.FileMapBodies{}

	var mapMu sync.Mutex
	errCh := make(chan error, len(mapInputBatches))

	for _, batch := range mapInputBatches {
		if len(batch) == 0 {
			errCh <- nil
			continue
		}

		go func(batch shared.FileMapInputs) {
			mapRes, apiErr := api.Client.GetFileMap(shared.GetFileMapRequest{
				MapInputs: batch,
			})
			if apiErr != nil {
				errCh <- fmt.Errorf("failed to get file map: %v", apiErr)
				return
			}
			mapMu.Lock()
			for path, bodies := range mapRes.MapBodies {
				allMapBodies[path] = bodies
			}
			mapMu.Unlock()
			errCh <- nil
		}(batch)
	}

	for i := 0; i < len(mapInputBatches); i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	return allMapBodies, nil
}

func readImageTokensForDefsOnly(path string, size int64, detail openai.ImageURLDetail, headerBytes int64) (int, error) {
	file, err := os.Open(path)
	if err != nil {
		return 0, fmt.Errorf("failed to open file %s: %w", path, err)
	}
	defer file.Close()

	tokens, err := shared.GetImageTokensFromHeader(file, detail, headerBytes)
	if err != nil {
		tokens = shared.GetImageTokensEstimateFromBytes(size)
	}
	return tokens, nil
}

func printSkippedFilesMsg(
	filesSkippedTooLarge []filePathWithSize,
	filesSkippedAfterSizeLimit []string,
	mapFilesTruncatedTooLarge []filePathWithSize,
	mapFilesSkippedAfterSizeLimit []string,
) {
	fmt.Println()
	fmt.Println(getSkippedFilesMsg(filesSkippedTooLarge, filesSkippedAfterSizeLimit, mapFilesTruncatedTooLarge, mapFilesSkippedAfterSizeLimit))
}

func getSkippedFilesMsg(
	filesSkippedTooLarge []filePathWithSize,
	filesSkippedAfterSizeLimit []string,
	mapFilesTruncatedTooLarge []filePathWithSize,
	mapFilesSkippedAfterSizeLimit []string,
) string {
	var builder strings.Builder

	if len(filesSkippedTooLarge) > 0 {
		fmt.Fprintf(&builder, "ℹ️  These files were skipped because they're too large:\n")
		for i, file := range filesSkippedTooLarge {
			if i >= maxSkippedFileList {
				fmt.Fprintf(&builder, "  • and %d more\n", len(filesSkippedTooLarge)-maxSkippedFileList)
				break
			}
			fmt.Fprintf(&builder, "  • %s - %d MB\n", file.Path, file.Size/1024/1024)
		}
	}
	if len(mapFilesTruncatedTooLarge) > 0 {
		fmt.Fprintf(&builder, "ℹ️  These files were truncated because they're too large to map fully:\n")
		for i, file := range mapFilesTruncatedTooLarge {
			if i >= maxSkippedFileList {
				fmt.Fprintf(&builder, "  • and %d more\n", len(mapFilesTruncatedTooLarge)-maxSkippedFileList)
				break
			}
			if file.Size > 1024*1024 {
				fmt.Fprintf(&builder, "  • %s - %d MB\n", file.Path, file.Size/1024/1024)
			} else {
				fmt.Fprintf(&builder, "  • %s - %d KB\n", file.Path, file.Size/1024)
			}
		}
		if len(mapFilesTruncatedTooLarge) > 0 {
			fmt.Fprintf(&builder, "They will still be included in the map, but only the first %d KB will be mapped.\n", shared.MaxContextMapSingleInputSize/1024)
		}
	}
	if len(filesSkippedAfterSizeLimit) > 0 {
		fmt.Fprintf(&builder, "ℹ️  These files were skipped because the total size limit was exceeded:\n")
		for i, file := range filesSkippedAfterSizeLimit {
			if i >= maxSkippedFileList {
				fmt.Fprintf(&builder, "  • and %d more\n", len(filesSkippedAfterSizeLimit)-maxSkippedFileList)
				break
			}
			fmt.Fprintf(&builder, "  • %s\n", file)
		}
	}
	if len(mapFilesSkippedAfterSizeLimit) > 0 {
		fmt.Fprintf(&builder, "ℹ️  These files were skipped because the total map size limit was exceeded:\n")
		for i, file := range mapFilesSkippedAfterSizeLimit {
			if i >= maxSkippedFileList {
				fmt.Fprintf(&builder, "  • and %d more\n", len(mapFilesSkippedAfterSizeLimit)-maxSkippedFileList)
				break
			}
			fmt.Fprintf(&builder, "  • %s\n", file)
		}
		if len(mapFilesSkippedAfterSizeLimit) > 0 {
			fmt.Fprintf(&builder, "They will still be included in the map as paths in the project, but no maps will be generated for them.\n")
		}
	}
	return builder.String()
}


================================================
FILE: app/cli/lib/context_update.go
================================================
package lib

import (
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/url"
	"strconv"
	"strings"
	"sync"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
)

func CheckOutdatedContextWithOutput(quiet, autoConfirm bool, maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (contextOutdated, updated bool, err error) {
	if !quiet {
		term.StartSpinner("🔬 Checking context...")
	}

	var contexts []*shared.Context

	if maybeContexts != nil {
		contexts = maybeContexts
	} else {
		res, err := api.Client.ListContext(CurrentPlanId, CurrentBranch)
		if err != nil {
			term.StopSpinner()
			return false, false, fmt.Errorf("failed to list context: %s", err)
		}
		contexts = res
	}

	outdatedRes, err := CheckOutdatedContext(contexts, projectPaths)
	if err != nil {
		term.StopSpinner()
		return false, false, fmt.Errorf("failed to check outdated context: %s", err)
	}

	if !quiet {
		term.StopSpinner()
	}

	if len(outdatedRes.UpdatedContexts) == 0 && len(outdatedRes.RemovedContexts) == 0 {
		if !quiet {
			fmt.Println("✅ Context is up to date")
		}
		return false, false, nil
	}
	if len(outdatedRes.UpdatedContexts) > 0 {
		types := []string{}
		if outdatedRes.NumFiles > 0 {
			lbl := "file"
			if outdatedRes.NumFiles > 1 {
				lbl = "files"
			}
			lbl = strconv.Itoa(outdatedRes.NumFiles) + " " + lbl
			types = append(types, lbl)
		}
		if outdatedRes.NumUrls > 0 {
			lbl := "url"
			if outdatedRes.NumUrls > 1 {
				lbl = "urls"
			}
			lbl = strconv.Itoa(outdatedRes.NumUrls) + " " + lbl
			types = append(types, lbl)
		}
		if outdatedRes.NumTrees > 0 {
			lbl := "directory tree"
			if outdatedRes.NumTrees > 1 {
				lbl = "directory trees"
			}
			lbl = strconv.Itoa(outdatedRes.NumTrees) + " " + lbl
			types = append(types, lbl)
		}
		if outdatedRes.NumMaps > 0 {
			lbl := "map"
			if outdatedRes.NumMaps > 1 {
				lbl = "maps"
			}
			lbl = strconv.Itoa(outdatedRes.NumMaps) + " " + lbl
			types = append(types, lbl)
		}

		var msg string
		if len(types) <= 2 {
			msg += strings.Join(types, " and ")
		} else {
			for i, add := range types {
				if i == len(types)-1 {
					msg += ", and " + add
				} else {
					msg += ", " + add
				}
			}
		}

		phrase := "have been"
		if len(outdatedRes.UpdatedContexts) == 1 {
			phrase = "has been"
		}

		if !quiet {
			term.StopSpinner()

			color.New(term.ColorHiCyan, color.Bold).Printf("%s in context %s modified 👇\n\n", msg, phrase)

			tableString := tableForContextOutdated(outdatedRes.UpdatedContexts, outdatedRes.TokenDiffsById)
			fmt.Println(tableString)
		}
	}

	if len(outdatedRes.RemovedContexts) > 0 {
		types := []string{}
		if outdatedRes.NumFilesRemoved > 0 {
			lbl := "file"
			if outdatedRes.NumFilesRemoved > 1 {
				lbl = "files"
			}
			lbl = strconv.Itoa(outdatedRes.NumFilesRemoved) + " " + lbl
			types = append(types, lbl)
		}
		if outdatedRes.NumTreesRemoved > 0 {
			lbl := "directory tree"
			if outdatedRes.NumTreesRemoved > 1 {
				lbl = "directory trees"
			}
			lbl = strconv.Itoa(outdatedRes.NumTreesRemoved) + " " + lbl
			types = append(types, lbl)
		}

		var msg string
		if len(types) <= 2 {
			msg += strings.Join(types, " and ")
		} else {
			for i, add := range types {
				if i == len(types)-1 {
					msg += ", and " + add
				} else {
					msg += ", " + add
				}
			}
		}

		phrase := "have been"
		if len(outdatedRes.RemovedContexts) == 1 {
			phrase = "has been"
		}

		if !quiet {
			term.StopSpinner()

			color.New(term.ColorHiCyan, color.Bold).Printf("%s in context %s removed 👇\n\n", msg, phrase)

			tableString := tableForContextOutdated(outdatedRes.RemovedContexts, outdatedRes.TokenDiffsById)
			fmt.Println(tableString)
		}
	}

	confirmed := autoConfirm

	if !autoConfirm {
		confirmed, err = term.ConfirmYesNo("Update context now?")

		if err != nil {
			term.OutputErrorAndExit("failed to get user input: %s", err)
		}
	}

	if confirmed {
		reqFn := outdatedRes.ReqFn
		if reqFn == nil {
			return false, false, fmt.Errorf("no update request function provided")
		}
		_, err = UpdateContextWithOutput(UpdateContextParams{
			Contexts:    contexts,
			OutdatedRes: *outdatedRes,
			ReqFn:       reqFn,
		})
		if err != nil {
			return false, false, fmt.Errorf("error updating context: %v", err)
		}
		return true, true, nil
	} else {
		return true, false, nil
	}

}

type UpdateContextParams struct {
	Contexts    []*shared.Context
	OutdatedRes types.ContextOutdatedResult
	ReqFn       func() (map[string]*shared.UpdateContextParams, error)
}

type UpdateContextResult struct {
	HasConflicts bool
	Msg          string
}

func UpdateContextWithOutput(params UpdateContextParams) (UpdateContextResult, error) {
	term.StartSpinner("🔄 Updating context...")

	updateRes, err := UpdateContext(params)
	if err != nil {
		return UpdateContextResult{}, err
	}

	term.StopSpinner()

	fmt.Println("✅ " + updateRes.Msg)

	return updateRes, nil
}

func UpdateContext(params UpdateContextParams) (UpdateContextResult, error) {
	var err error
	reqFn := params.ReqFn
	if reqFn == nil {
		return UpdateContextResult{}, fmt.Errorf("no update request function provided")
	}
	req, err := reqFn()
	if err != nil {
		return UpdateContextResult{}, fmt.Errorf("error getting update request: %v", err)
	}
	var hasConflicts bool
	var msg string

	contextsById := map[string]*shared.Context{}
	for _, context := range params.Contexts {
		contextsById[context.Id] = context
	}
	deleteIds := map[string]bool{}
	for _, context := range params.OutdatedRes.RemovedContexts {
		deleteIds[context.Id] = true
	}

	filesToLoad := map[string]string{}
	for id := range req {
		context := contextsById[id]
		if context.ContextType == shared.ContextFileType {
			filesToLoad[context.FilePath] = context.Body
		}
	}
	for id := range deleteIds {
		context := contextsById[id]
		if context.ContextType == shared.ContextFileType {
			filesToLoad[context.FilePath] = ""
		}
	}

	hasConflicts, err = checkContextConflicts(filesToLoad)
	if err != nil {
		return UpdateContextResult{}, fmt.Errorf("failed to check context conflicts: %v", err)
	}

	if len(req) > 0 {
		res, apiErr := api.Client.UpdateContext(CurrentPlanId, CurrentBranch, req)
		if apiErr != nil {
			return UpdateContextResult{}, fmt.Errorf("failed to update context: %v", apiErr)
		}
		msg = res.Msg
	}

	if len(deleteIds) > 0 {
		res, apiErr := api.Client.DeleteContext(CurrentPlanId, CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		if apiErr != nil {
			return UpdateContextResult{}, fmt.Errorf("failed to delete contexts: %v", apiErr)
		}
		msg += " " + res.Msg
	}

	return UpdateContextResult{
		HasConflicts: hasConflicts,
		Msg:          strings.TrimSpace(msg),
	}, nil
}

// CheckOutdatedContext is where we replicate your partial-read logic for map files
// so that large map files or newly added map files do not read more than MaxContextMapSingleInputSize
func CheckOutdatedContext(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (*types.ContextOutdatedResult, error) {
	return checkOutdatedAndMaybeUpdateContext(false, maybeContexts, projectPaths)
}

type mapState struct {
	removedMapPaths      []string
	mapInputShas         map[string]string
	mapInputTokens       map[string]int
	mapInputSizes        map[string]int64
	totalMapSize         int64
	currentMapInputBatch shared.FileMapInputs
	mapInputBatches      []shared.FileMapInputs
}

func checkOutdatedAndMaybeUpdateContext(doUpdate bool, maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (*types.ContextOutdatedResult, error) {
	var contexts []*shared.Context

	if maybeContexts == nil {
		contextsRes, apiErr := api.Client.ListContext(CurrentPlanId, CurrentBranch)
		if apiErr != nil {
			return nil, fmt.Errorf("error retrieving context: %v", apiErr)
		}
		contexts = contextsRes
	} else {
		contexts = maybeContexts
	}

	totalTokens := 0
	for _, c := range contexts {
		totalTokens += c.NumTokens
	}

	var errs []error

	reqFns := map[string]func() (*shared.UpdateContextParams, error){}

	var updatedContexts []*shared.Context
	var tokenDiffsById = map[string]int{}
	var numFiles int
	var numUrls int
	var numTrees int
	var numMaps int
	var numFilesRemoved int
	var numTreesRemoved int
	var mu sync.Mutex
	var wg sync.WaitGroup
	contextsById := make(map[string]*shared.Context)
	deleteIds := make(map[string]bool)

	paths := projectPaths

	// We track skipped items for final warnings
	var filesSkippedTooLarge []filePathWithSize
	var filesSkippedAfterSizeLimit []string

	var mapFilesTruncatedTooLarge []filePathWithSize
	var mapFilesSkippedAfterSizeLimit []string

	mapFilesTruncatedSet := map[string]bool{}
	mapFilesSkippedAfterSizeLimitSet := map[string]bool{}

	mapFileInfoByPath := map[string]os.FileInfo{}
	mapFileRemovedByPath := map[string]bool{}

	var totalSize int64
	var totalBodySize int64
	var totalContextCount int

	sem := make(chan struct{}, ContextMapMaxClientConcurrency)

	for _, c := range contexts {
		contextsById[c.Id] = c
	}

	for _, context := range contexts {
		switch context.ContextType {
		case shared.ContextFileType:
			wg.Add(1)
			go func(ctx *shared.Context) {
				defer wg.Done()
				sem <- struct{}{}
				defer func() { <-sem }()

				if _, err := os.Stat(ctx.FilePath); os.IsNotExist(err) {
					mu.Lock()
					defer mu.Unlock()

					deleteIds[ctx.Id] = true
					numFilesRemoved++
					tokenDiffsById[ctx.Id] = -ctx.NumTokens
					return
				}

				fileContent, err := os.ReadFile(ctx.FilePath)
				if err != nil {
					mu.Lock()
					defer mu.Unlock()
					errs = append(errs, fmt.Errorf("failed to read the file %s: %v", ctx.FilePath, err))
					return
				}
				fileContent = shared.NormalizeEOL(fileContent)

				fileInfo, err := os.Stat(ctx.FilePath)
				if err != nil {
					mu.Lock()
					defer mu.Unlock()
					errs = append(errs, fmt.Errorf("failed to get file info for %s: %v", ctx.FilePath, err))
					return
				}
				size := fileInfo.Size()

				// Individual skip checks
				if size > shared.MaxContextBodySize {
					mu.Lock()
					defer mu.Unlock()

					filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: ctx.FilePath, Size: size})
					return
				}
				if totalSize+size > shared.MaxContextBodySize {
					mu.Lock()
					defer mu.Unlock()

					filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.FilePath)
					return
				}

				// Compare new sha
				hash := sha256.Sum256(fileContent)
				sha := hex.EncodeToString(hash[:])

				if sha != ctx.Sha {
					if totalContextCount >= shared.MaxContextCount {
						mu.Lock()
						defer mu.Unlock()

						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.FilePath)
						return
					}

					oldBodySize := int64(len(ctx.Body))
					newBodySize := int64(len(fileContent))
					if totalBodySize+(newBodySize-oldBodySize) > shared.MaxContextBodySize {
						mu.Lock()
						defer mu.Unlock()

						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.FilePath)
						return
					}

					// Accept
					mu.Lock()
					totalSize += size
					totalContextCount++
					totalBodySize += (newBodySize - oldBodySize)
					mu.Unlock()

					var numTokens int
					if shared.IsImageFile(ctx.FilePath) {
						tokens, err := shared.GetImageTokens(base64.StdEncoding.EncodeToString(fileContent), ctx.ImageDetail)
						if err != nil {
							mu.Lock()
							defer mu.Unlock()
							errs = append(errs, fmt.Errorf("failed to get image tokens for %s: %v", ctx.FilePath, err))
							return
						}
						numTokens = tokens
					} else {
						numTokens = shared.GetNumTokensEstimate(string(fileContent))
					}

					mu.Lock()
					defer mu.Unlock()

					tokenDiffsById[ctx.Id] = numTokens - ctx.NumTokens
					numFiles++
					updatedContexts = append(updatedContexts, ctx)

					reqFns[ctx.Id] = func() (*shared.UpdateContextParams, error) {
						return &shared.UpdateContextParams{
							Body: string(fileContent),
						}, nil
					}
				}
			}(context)

		case shared.ContextDirectoryTreeType:
			wg.Add(1)
			go func(ctx *shared.Context) {
				defer wg.Done()
				sem <- struct{}{}
				defer func() { <-sem }()

				if _, err := os.Stat(ctx.FilePath); os.IsNotExist(err) {
					mu.Lock()
					deleteIds[ctx.Id] = true
					numTreesRemoved++
					tokenDiffsById[ctx.Id] = -ctx.NumTokens
					mu.Unlock()
					return
				}

				baseDir := fs.GetBaseDirForFilePaths([]string{ctx.FilePath})
				flattenedPaths, err := ParseInputPaths(ParseInputPathsParams{
					FileOrDirPaths: []string{ctx.FilePath},
					BaseDir:        baseDir,
					ProjectPaths:   paths,
					LoadParams: &types.LoadContextParams{
						NamesOnly:       true,
						ForceSkipIgnore: ctx.ForceSkipIgnore,
					},
				})

				if err != nil {
					mu.Lock()
					defer mu.Unlock()

					errs = append(errs, fmt.Errorf("failed to get directory tree %s: %v", ctx.FilePath, err))
					return
				}

				if !ctx.ForceSkipIgnore && paths != nil {
					var filtered []string
					for _, p := range flattenedPaths {
						if _, ok := paths.ActivePaths[p]; ok {
							filtered = append(filtered, p)
						}
					}
					flattenedPaths = filtered
				}

				// Partial skipping for sub-paths
				var kept []string
				mu.Lock()
				for _, p := range flattenedPaths {
					lineSize := int64(len(p))
					// If line is individually too large, skip
					if lineSize > shared.MaxContextBodySize {
						filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: p, Size: lineSize})
						continue
					}
					if totalSize+lineSize > shared.MaxContextBodySize {
						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, p)
						continue
					}
					// Accept
					totalSize += lineSize
					kept = append(kept, p)
				}
				mu.Unlock()

				body := strings.Join(kept, "\n")
				newHash := sha256.Sum256([]byte(body))
				newSha := hex.EncodeToString(newHash[:])

				if newSha != ctx.Sha {
					if totalContextCount >= shared.MaxContextCount {
						mu.Lock()
						defer mu.Unlock()

						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.FilePath)
						return
					}

					oldBodySize := int64(len(ctx.Body))
					newBodySize := int64(len(body))
					if totalBodySize+(newBodySize-oldBodySize) > shared.MaxContextBodySize {
						mu.Lock()
						defer mu.Unlock()

						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.FilePath)
						return
					}

					numTokens := shared.GetNumTokensEstimate(body)

					mu.Lock()
					defer mu.Unlock()

					totalContextCount++
					totalBodySize += (newBodySize - oldBodySize)
					tokenDiffsById[ctx.Id] = numTokens - ctx.NumTokens
					numTrees++
					updatedContexts = append(updatedContexts, ctx)
					reqFns[ctx.Id] = func() (*shared.UpdateContextParams, error) {
						return &shared.UpdateContextParams{
							Body: body,
						}, nil
					}
				}
			}(context)

		case shared.ContextMapType:
			// Instead of reading all files in the same goroutine,
			// we now spawn one goroutine per map-file to mirror the loading logic concurrency.
			wg.Add(1)
			go func(ctx *shared.Context) {
				defer wg.Done()

				// We collect paths from the existing map
				var mapPaths []string
				for path := range ctx.MapShas {
					mapPaths = append(mapPaths, path)
				}

				// Next, see if there are newly added files
				baseDir := fs.GetBaseDirForFilePaths([]string{ctx.FilePath})
				flattenedPaths, err := ParseInputPaths(ParseInputPathsParams{
					FileOrDirPaths: []string{ctx.FilePath},
					BaseDir:        baseDir,
					ProjectPaths:   projectPaths,
					LoadParams:     &types.LoadContextParams{Recursive: true},
				})
				if err != nil {
					mu.Lock()
					defer mu.Unlock()
					errs = append(errs, fmt.Errorf("failed to get the directory tree %s: %v", ctx.FilePath, err))
					return
				}

				var filtered []string
				if projectPaths != nil {
					for _, p := range flattenedPaths {
						if _, ok := projectPaths.ActivePaths[p]; ok {
							filtered = append(filtered, p)
						}
					}
					flattenedPaths = filtered
				}

				// If a path was not already in the map, it's newly added
				for _, p := range flattenedPaths {
					if _, ok := ctx.MapShas[p]; !ok {
						mapPaths = append(mapPaths, p)
					}
				}

				totalMapPaths := len(mapPaths)

				currentMapInputBatch := shared.FileMapInputs{}
				state := mapState{
					removedMapPaths:      []string{},
					mapInputShas:         map[string]string{},
					mapInputTokens:       map[string]int{},
					mapInputSizes:        map[string]int64{},
					totalMapSize:         0,
					currentMapInputBatch: currentMapInputBatch,
					mapInputBatches:      []shared.FileMapInputs{currentMapInputBatch},
				}

				innerExistenceErrCh := make(chan error, len(mapPaths))

				// Existence: check each path in its own goroutine:

				for _, path := range mapPaths {
					go func(path string) {
						sem <- struct{}{}
						defer func() { <-sem }()

						var removed bool

						var hasFileInfo bool
						mu.Lock()
						if _, ok := mapFileInfoByPath[path]; ok {
							hasFileInfo = true
						} else if _, ok := mapFileRemovedByPath[path]; ok {
							removed = true
						}
						mu.Unlock()

						if !(hasFileInfo || removed) {
							fileInfo, err := os.Stat(path)
							if err != nil {
								if os.IsNotExist(err) {
									removed = true

								} else {
									innerExistenceErrCh <- fmt.Errorf("failed to stat map file %s: %v", path, err)
									return
								}
							}

							mu.Lock()
							prevTokens := ctx.MapTokens[path]
							prevSize := ctx.MapSizes[path]

							if removed {
								mapFileRemovedByPath[path] = true
								totalMapPaths--
								if _, existed := ctx.MapShas[path]; existed {
									state.removedMapPaths = append(state.removedMapPaths, path)
									tokenDiffsById[ctx.Id] -= prevTokens
									state.totalMapSize -= prevSize
								}
							} else {
								mapFileInfoByPath[path] = fileInfo
							}
							mu.Unlock()
						}

						innerExistenceErrCh <- nil
					}(path)
				}

				for range mapPaths {
					err := <-innerExistenceErrCh
					if err != nil {
						mu.Lock()
						defer mu.Unlock()
						errs = append(errs, err)
						return
					}
				}

				// Updates: check each path in its own goroutine:
				innerUpdatesErrCh := make(chan error, len(mapPaths))

				for _, path := range mapPaths {
					go func(path string) {
						sem <- struct{}{}
						defer func() { <-sem }()

						var removed bool
						var fileInfo os.FileInfo

						var hasFileInfo bool
						mu.Lock()
						if _, ok := mapFileInfoByPath[path]; ok {
							fileInfo = mapFileInfoByPath[path]
							hasFileInfo = true
						} else if _, ok := mapFileRemovedByPath[path]; ok {
							removed = true
						}
						mu.Unlock()

						if removed {
							innerUpdatesErrCh <- nil
							return
						}

						if !hasFileInfo {
							innerUpdatesErrCh <- fmt.Errorf("failed to get map file info for %s - should already be set", path)
							return
						}

						size := fileInfo.Size()
						var totalMapSize int64
						mu.Lock()
						prevTokens := ctx.MapTokens[path]
						prevSize := ctx.MapSizes[path]
						prevSha := ctx.MapShas[path]
						totalMapSize = state.totalMapSize
						mu.Unlock()

						res, err := getMapFileDetails(path, size, totalMapSize)
						if err != nil {
							innerUpdatesErrCh <- fmt.Errorf("failed to get map file details for %s: %v", path, err)
							return
						}

						if res.shaVal == prevSha {
							// no change
							innerUpdatesErrCh <- nil
							return
						}

						mu.Lock()

						totalMapPaths++

						if totalMapPaths > shared.MaxContextMapPaths {
							if _, ok := mapFilesSkippedAfterSizeLimitSet[path]; !ok {
								mapFilesSkippedAfterSizeLimitSet[path] = true
								mapFilesSkippedAfterSizeLimit = append(mapFilesSkippedAfterSizeLimit, path)
							}
							mu.Unlock()
							innerUpdatesErrCh <- nil
							return
						}

						defer mu.Unlock()

						if state.currentMapInputBatch.NumFiles()+1 > shared.ContextMapMaxBatchSize || state.totalMapSize+res.size > shared.ContextMapMaxBatchBytes {
							state.currentMapInputBatch = shared.FileMapInputs{}
							state.mapInputBatches = append(state.mapInputBatches, state.currentMapInputBatch)
						}

						sizeChange := int64(res.size) - prevSize
						state.totalMapSize += sizeChange
						tokenDiffsById[ctx.Id] += (res.tokens - prevTokens)

						state.mapInputShas[path] = res.shaVal
						state.mapInputTokens[path] = res.tokens
						state.currentMapInputBatch[path] = res.mapContent
						state.mapInputSizes[path] = res.size

						if len(res.mapFilesTruncatedTooLarge) > 0 {
							for _, file := range res.mapFilesTruncatedTooLarge {
								if _, ok := mapFilesTruncatedSet[file.Path]; !ok {
									mapFilesTruncatedSet[file.Path] = true
									mapFilesTruncatedTooLarge = append(mapFilesTruncatedTooLarge, file)
								}
							}
						}

						if len(res.mapFilesSkippedAfterSizeLimit) > 0 {
							for _, file := range res.mapFilesSkippedAfterSizeLimit {
								if _, ok := mapFilesSkippedAfterSizeLimitSet[file]; !ok {
									mapFilesSkippedAfterSizeLimitSet[file] = true
									mapFilesSkippedAfterSizeLimit = append(mapFilesSkippedAfterSizeLimit, file)
								}
							}
						}

						innerUpdatesErrCh <- nil
					}(path)
				}

				for range mapPaths {
					err := <-innerUpdatesErrCh
					if err != nil {
						mu.Lock()
						defer mu.Unlock()
						errs = append(errs, err)
						return
					}
				}

				hasAnyUpdate := len(state.removedMapPaths) > 0 || len(state.mapInputShas) > 0

				if hasAnyUpdate {
					mu.Lock()
					defer mu.Unlock()

					updatedContexts = append(updatedContexts, ctx)

					numMaps++

					reqFns[ctx.Id] = func() (*shared.UpdateContextParams, error) {
						updatedMapBodies, err := processMapBatches(state.mapInputBatches)
						if err != nil {
							return nil, fmt.Errorf("failed to process map batches: %v", err)
						}

						return &shared.UpdateContextParams{
							MapBodies:       updatedMapBodies,
							InputShas:       state.mapInputShas,
							InputTokens:     state.mapInputTokens,
							InputSizes:      state.mapInputSizes,
							RemovedMapPaths: state.removedMapPaths,
						}, nil
					}
				}

			}(context)

		case shared.ContextURLType:
			wg.Add(1)
			go func(ctx *shared.Context) {
				defer wg.Done()
				sem <- struct{}{}
				defer func() { <-sem }()

				body, err := url.FetchURLContent(ctx.Url)

				if err != nil {
					mu.Lock()
					defer mu.Unlock()
					errs = append(errs, fmt.Errorf("failed to fetch the URL %s: %v", ctx.Url, err))
					return
				}

				size := int64(len(body))
				if size > shared.MaxContextBodySize {
					mu.Lock()
					defer mu.Unlock()
					filesSkippedTooLarge = append(filesSkippedTooLarge, filePathWithSize{Path: ctx.Url, Size: size})
					return
				}
				if totalSize+size > shared.MaxContextBodySize {
					mu.Lock()
					defer mu.Unlock()
					filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.Url)
					return
				}
				hash := sha256.Sum256([]byte(body))
				newSha := hex.EncodeToString(hash[:])
				if newSha != ctx.Sha {
					if totalContextCount >= shared.MaxContextCount {
						mu.Lock()
						defer mu.Unlock()
						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.Url)
						return
					}
					oldBodySize := int64(len(ctx.Body))
					newBodySize := size
					if totalBodySize+(newBodySize-oldBodySize) > shared.MaxContextBodySize {
						mu.Lock()
						defer mu.Unlock()
						filesSkippedAfterSizeLimit = append(filesSkippedAfterSizeLimit, ctx.Url)
						return
					}

					numTokens := shared.GetNumTokensEstimate(string(body))

					mu.Lock()
					defer mu.Unlock()

					totalSize += size
					totalContextCount++
					totalBodySize += (newBodySize - oldBodySize)

					tokenDiffsById[ctx.Id] = numTokens - ctx.NumTokens

					numUrls++
					updatedContexts = append(updatedContexts, ctx)
					reqFns[ctx.Id] = func() (*shared.UpdateContextParams, error) {
						return &shared.UpdateContextParams{
							Body: string(body),
						}, nil
					}
				}
			}(context)
		}
	}

	wg.Wait()

	if len(errs) > 0 {
		return nil, fmt.Errorf("failed to check context outdated: %v", errs)
	}

	// Identify contexts to remove
	var removedContexts []*shared.Context
	for id := range deleteIds {
		removedContexts = append(removedContexts, contextsById[id])
	}

	// If nothing changed
	if len(reqFns) == 0 && len(removedContexts) == 0 {
		return &types.ContextOutdatedResult{
			Msg: "Context is up to date",
		}, nil
	}

	reqFn := func() (map[string]*shared.UpdateContextParams, error) {
		req := map[string]*shared.UpdateContextParams{}
		var mu sync.Mutex

		errCh := make(chan error, len(reqFns))
		for id, fn := range reqFns {
			go func(id string, fn func() (*shared.UpdateContextParams, error)) {
				res, err := fn()
				if err != nil {
					errCh <- err
					return
				}
				mu.Lock()
				req[id] = res
				mu.Unlock()
				errCh <- nil
			}(id, fn)
		}
		for i := 0; i < len(reqFns); i++ {
			err := <-errCh
			if err != nil {
				return nil, err
			}
		}
		return req, nil
	}

	// Build final result
	outdatedRes := types.ContextOutdatedResult{
		UpdatedContexts: updatedContexts,
		RemovedContexts: removedContexts,
		TokenDiffsById:  tokenDiffsById,
		NumFiles:        numFiles,
		NumUrls:         numUrls,
		NumTrees:        numTrees,
		NumMaps:         numMaps,
		NumFilesRemoved: numFilesRemoved,
		NumTreesRemoved: numTreesRemoved,
		ReqFn:           reqFn,
	}

	var hasConflicts bool
	var msg string
	if doUpdate {
		res, err := UpdateContext(UpdateContextParams{
			Contexts:    contexts,
			OutdatedRes: outdatedRes,
			ReqFn:       reqFn,
		})
		if err != nil {
			return nil, fmt.Errorf("failed to update context: %v", err)
		}
		hasConflicts = res.HasConflicts
		msg = res.Msg
		outdatedRes.Msg = msg
	} else {
		var tokensDiff int
		for _, diff := range tokenDiffsById {
			tokensDiff += diff
		}
		newTotal := totalTokens + tokensDiff
		outdatedRes.Msg = shared.SummaryForUpdateContext(shared.SummaryForUpdateContextParams{
			NumFiles:    numFiles,
			NumTrees:    numTrees,
			NumUrls:     numUrls,
			NumMaps:     numMaps,
			TokensDiff:  tokensDiff,
			TotalTokens: newTotal,
		})
	}

	if hasConflicts {
		term.StartSpinner("🏗️  Starting build...")
		_, err := buildPlanInlineFn(false, nil)
		term.StopSpinner()
		fmt.Println()
		if err != nil {
			return nil, fmt.Errorf("failed to build plan: %v", err)
		}
	}

	// Warn about any items skipped
	if len(filesSkippedTooLarge) > 0 || len(filesSkippedAfterSizeLimit) > 0 ||
		len(mapFilesTruncatedTooLarge) > 0 || len(mapFilesSkippedAfterSizeLimit) > 0 {
		printSkippedFilesMsg(filesSkippedTooLarge, filesSkippedAfterSizeLimit,
			mapFilesTruncatedTooLarge, mapFilesSkippedAfterSizeLimit)
	}

	return &outdatedRes, nil
}

func tableForContextOutdated(updatedContexts []*shared.Context, tokenDiffsById map[string]int) string {
	if len(updatedContexts) == 0 {
		return ""
	}

	tableString := &strings.Builder{}
	table := tablewriter.NewWriter(tableString)
	table.SetHeader([]string{"Name", "Type", "🪙"})
	table.SetAutoWrapText(false)

	for _, ctx := range updatedContexts {
		t, icon := ctx.TypeAndIcon()
		diff := tokenDiffsById[ctx.Id]
		diffStr := "+" + strconv.Itoa(diff)
		tableColor := tablewriter.FgHiGreenColor

		if diff < 0 {
			diffStr = strconv.Itoa(diff)
			tableColor = tablewriter.FgHiRedColor
		}

		row := []string{
			" " + icon + " " + ctx.Name,
			t,
			diffStr,
		}

		table.Rich(row, []tablewriter.Colors{
			{tableColor, tablewriter.Bold},
			{tableColor},
			{tableColor},
		})
	}

	table.Render()
	return tableString.String()
}


================================================
FILE: app/cli/lib/current.go
================================================
package lib

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/format"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
)

var CurrentProjectId string
var CurrentPlanId string
var CurrentBranch string
var HomeCurrentProjectDir string
var HomeCurrentPlanPath string

func MustResolveOrCreateProject() {
	resolveProject(true, true)
}

func MustResolveProject() {
	resolveProject(true, false)
}

func MaybeResolveProject() {
	resolveProject(false, false)
}

func resolveProject(mustResolve, shouldCreate bool) {
	if fs.PlandexDir == "" {
		var err error
		if shouldCreate {
			_, _, err = fs.FindOrCreatePlandex()
		} else {
			fs.FindPlandexDir()
		}

		if err != nil && mustResolve {
			term.OutputErrorAndExit("error finding or creating plandex: %v", err)
		}
	}

	if (fs.PlandexDir == "" || fs.ProjectRoot == "") && mustResolve {
		fmt.Printf(
			"🤷‍♂️ No plans in current directory\nTry %s to create a plan or %s to see plans in nearby directories\n",
			color.New(color.Bold, term.ColorHiCyan).Sprint("plandex new"),
			color.New(color.Bold, term.ColorHiCyan).Sprint("plandex plans"))
		os.Exit(0)
	}

	if fs.PlandexDir == "" {
		return
	}

	MigrateLegacyProjectFile(auth.Current.UserId)

	// check if projects-v2.json exists in PlandexDir
	path := filepath.Join(fs.PlandexDir, "projects-v2.json")
	_, err := os.Stat(path)

	if os.IsNotExist(err) {
		log.Println("projects-v2.json does not exist")
		log.Println("Initializing project")
		mustInitProject(nil)
	} else if err != nil {
		term.OutputErrorAndExit("error checking if projects-v2.json exists: %v", err)
	}

	var settings *types.CurrentProjectSettings
	var loadProjectSettings func()
	loadProjectSettings = func() {
		// read projects-v2.json
		bytes, err := os.ReadFile(path)

		if err != nil {
			term.OutputErrorAndExit("error reading projects-v2.json: %v", err)
		}

		var settingsByAccount types.CurrentProjectSettingsByAccount
		err = json.Unmarshal(bytes, &settingsByAccount)

		if err != nil {
			term.OutputErrorAndExit("error unmarshalling projects-v2.json: %v", err)
		}

		settings = settingsByAccount[auth.Current.UserId]
		if settings == nil {
			mustInitProject(&settingsByAccount)
			loadProjectSettings()
		}
	}

	loadProjectSettings()

	CurrentProjectId = settings.Id
	MigrateLegacyCurrentPlanFile(auth.Current.UserId)

	HomeCurrentProjectDir = filepath.Join(fs.HomePlandexDir, CurrentProjectId)
	HomeCurrentPlanPath = filepath.Join(HomeCurrentProjectDir, "current-plans-v2.json")

	err = os.MkdirAll(HomeCurrentProjectDir, os.ModePerm)

	if err != nil {
		term.OutputErrorAndExit("error creating project dir: %v", err)
	}

	MustLoadCurrentPlan()
	MigrateLegacyPlanSettingsFile(auth.Current.UserId)
}

func MustLoadCurrentPlan() {
	if CurrentProjectId == "" {
		term.OutputErrorAndExit("No current project")
	}

	// Check if the file exists
	_, err := os.Stat(HomeCurrentPlanPath)

	if os.IsNotExist(err) {
		return
	} else if err != nil {
		term.OutputErrorAndExit("error checking if current-plans-v2.json exists: %v", err)
	}

	// Read the contents of the file
	fileBytes, err := os.ReadFile(HomeCurrentPlanPath)
	if err != nil {
		term.OutputErrorAndExit("error reading current-plans-v2.json: %v", err)
	}

	var currentPlansByAccount types.CurrentPlanSettingsByAccount
	err = json.Unmarshal(fileBytes, &currentPlansByAccount)
	if err != nil {
		term.OutputErrorAndExit("error unmarshalling current-plans-v2.json: %v", err)
	}

	currentPlan := currentPlansByAccount[auth.Current.UserId]

	if currentPlan != nil {
		CurrentPlanId = currentPlan.Id
	}

	if CurrentPlanId != "" {
		err = loadCurrentBranch()

		if err != nil {
			term.OutputErrorAndExit("error loading current branch: %v", err)
		}

		if CurrentBranch == "" {
			err = WriteCurrentBranch("main")

			if err != nil {
				term.OutputErrorAndExit("error setting current branch: %v", err)
			}
		}
	}
}

func loadCurrentBranch() error {
	// Load plan-specific settings
	if CurrentPlanId == "" {
		return fmt.Errorf("no current plan")
	}

	path := filepath.Join(HomeCurrentProjectDir, CurrentPlanId, "settings-v2.json")

	// Check if the file exists
	_, err := os.Stat(path)

	if os.IsNotExist(err) {
		return nil
	} else if err != nil {
		return fmt.Errorf("error checking if settings-v2.json exists: %v", err)
	}

	fileBytes, err := os.ReadFile(path)
	if err != nil {
		term.OutputErrorAndExit("error reading settings-v2.json: %v", err)
	}

	var settingsByAccount types.PlanSettingsByAccount
	err = json.Unmarshal(fileBytes, &settingsByAccount)
	if err != nil {
		term.OutputErrorAndExit("error unmarshalling settings-v2.json: %v", err)
	}
	settings := settingsByAccount[auth.Current.UserId]

	if settings == nil {
		return nil
	}

	CurrentBranch = settings.Branch

	return nil
}

func GetCurrentPlanTable(plan *shared.Plan, currentBranchesByPlanId map[string]*shared.Branch, onlyCols []string) string {
	b := &strings.Builder{}
	table := tablewriter.NewWriter(b)
	table.SetAutoWrapText(false)

	var cols []string

	if onlyCols == nil {
		cols = []string{"Current Plan", "Updated", "Created" /*"Branches",*/, "Branch", "Context", "Convo"}
	} else {
		cols = onlyCols
	}

	table.SetHeader(cols)

	name := color.New(color.Bold, term.ColorHiGreen).Sprint(plan.Name)
	branch := currentBranchesByPlanId[CurrentPlanId]

	var row []string

	for _, col := range cols {
		switch col {
		case "Current Plan":
			row = append(row, name)
		case "Updated":
			row = append(row, format.Time(plan.UpdatedAt))
		case "Created":
			row = append(row, format.Time(plan.CreatedAt))
		case "Branch":
			row = append(row, CurrentBranch)
		case "Context":
			row = append(row, strconv.Itoa(branch.ContextTokens)+" 🪙")
		case "Convo":
			row = append(row, strconv.Itoa(branch.ConvoTokens)+" 🪙")
		}
	}

	style := []tablewriter.Colors{
		{tablewriter.FgGreenColor, tablewriter.Bold},
	}

	table.Rich(row, style)
	table.Render()

	return b.String()
}

func mustInitProject(existingSettings *types.CurrentProjectSettingsByAccount) {
	res, apiErr := api.Client.CreateProject(shared.CreateProjectRequest{Name: filepath.Base(fs.ProjectRoot)})

	if apiErr != nil {
		term.OutputErrorAndExit("error creating project: %v", apiErr.Msg)
	}

	log.Println("Project created:", res.Id)

	CurrentProjectId = res.Id

	var settingsByAccount types.CurrentProjectSettingsByAccount
	if existingSettings != nil {
		settingsByAccount = *existingSettings
	} else {
		settingsByAccount = types.CurrentProjectSettingsByAccount{}
	}

	settingsByAccount[auth.Current.UserId] = &types.CurrentProjectSettings{
		Id: CurrentProjectId,
	}

	// write projects-v2.json
	path := filepath.Join(fs.PlandexDir, "projects-v2.json")
	bytes, err := json.Marshal(settingsByAccount)

	if err != nil {
		term.OutputErrorAndExit("error marshalling project settings: %v", err)
	}

	err = os.WriteFile(path, bytes, os.ModePerm)

	if err != nil {
		term.OutputErrorAndExit("error writing projects-v2.json: %v", err)
	}

	log.Println("Wrote projects-v2.json")

	// write current-plans-v2.json to PlandexHomeDir/[projectId]/current-plans-v2.json
	dir := filepath.Join(fs.HomePlandexDir, CurrentProjectId)
	err = os.MkdirAll(dir, os.ModePerm)

	if err != nil {
		term.OutputErrorAndExit("error creating project dir: %v", err)
	}

	path = filepath.Join(dir, "current-plans-v2.json")
	bytes, err = json.Marshal(types.CurrentPlanSettingsByAccount{
		auth.Current.UserId: &types.CurrentPlanSettings{
			Id: "",
		},
	})

	if err != nil {
		term.OutputErrorAndExit("error marshalling plan settings: %v", err)
	}

	err = os.WriteFile(path, bytes, os.ModePerm)

	if err != nil {
		term.OutputErrorAndExit("error writing current-plans-v2.json: %v", err)
	}

	log.Println("Wrote current-plans-v2.json")
}


================================================
FILE: app/cli/lib/custom_models.go
================================================
package lib

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/schema"
	"plandex-cli/term"
	shared "plandex-shared"
	"strings"

	"github.com/fatih/color"
)

type CustomModelsCheckLocalChangesResult struct {
	HasLocalChanges  bool
	LocalModelsInput shared.ModelsInput
}

func GetCustomModelsPath(userId string) string {
	return filepath.Join(fs.HomePlandexDir, "accounts", userId, "custom-models.json")
}

func GetServerModelsInput() (*shared.ModelsInput, error) {
	errCh := make(chan *shared.ApiError, 3)
	var (
		customModels     []*shared.CustomModel
		customProviders  []*shared.CustomProvider
		customModelPacks []*shared.ModelPackSchema
	)

	go func() {
		models, apiErr := api.Client.ListCustomModels()
		if apiErr != nil {
			errCh <- apiErr
			return
		}
		customModels = models
		errCh <- nil
	}()

	go func() {
		// custom providers are not supported on cloud
		if auth.Current.IsCloud {
			errCh <- nil
			return
		}
		providers, apiErr := api.Client.ListCustomProviders()
		if apiErr != nil {
			errCh <- apiErr
			return
		}
		customProviders = providers
		errCh <- nil
	}()

	go func() {
		modelPacks, apiErr := api.Client.ListModelPacks()
		if apiErr != nil {
			errCh <- apiErr
			return
		}

		schemas := make([]*shared.ModelPackSchema, len(modelPacks))
		for i, modelPack := range modelPacks {
			schemas[i] = modelPack.ToModelPackSchema()
		}

		customModelPacks = schemas
		errCh <- nil
	}()

	for i := 0; i < 3; i++ {
		err := <-errCh
		if err != nil {
			return nil, fmt.Errorf("error fetching custom models: %v", err.Msg)
		}
	}

	serverModelsInput := &shared.ModelsInput{
		CustomModels:     customModels,
		CustomProviders:  customProviders,
		CustomModelPacks: customModelPacks,
	}

	return serverModelsInput, nil
}

func CustomModelsCheckLocalChanges(path string) (CustomModelsCheckLocalChangesResult, error) {
	hashPath := path + ".hash"

	exists, err := fs.FileExists(path)
	if err != nil {
		return CustomModelsCheckLocalChangesResult{}, err
	}

	if !exists {
		return CustomModelsCheckLocalChangesResult{}, nil
	}

	localJsonData, err := os.ReadFile(path)
	if err != nil {
		return CustomModelsCheckLocalChangesResult{}, fmt.Errorf("error reading JSON file: %v", err)
	}

	var localClientModelsInput shared.ClientModelsInput
	err = json.Unmarshal(localJsonData, &localClientModelsInput)
	if err != nil {
		return CustomModelsCheckLocalChangesResult{}, fmt.Errorf("error unmarshalling JSON file: %v", err)
	}

	localModelsInput := localClientModelsInput.ToModelsInput()

	lastSavedHash, err := os.ReadFile(hashPath)

	if err != nil && !os.IsNotExist(err) {
		return CustomModelsCheckLocalChangesResult{}, fmt.Errorf("error reading hash file: %v", err)
	}

	currentHash, err := localModelsInput.Hash()
	if err != nil {
		return CustomModelsCheckLocalChangesResult{}, fmt.Errorf("error hashing models: %v", err)
	}

	return CustomModelsCheckLocalChangesResult{
		HasLocalChanges:  currentHash != string(lastSavedHash),
		LocalModelsInput: localModelsInput,
	}, nil
}

func WriteCustomModelsFile(path string, modelsInput *shared.ModelsInput) error {
	err := os.MkdirAll(filepath.Dir(path), 0755)
	if err != nil {
		return fmt.Errorf("error creating directory: %v", err)
	}

	clientModelsInput := modelsInput.ToClientModelsInput()
	clientModelsInput.PrepareUpdate()

	jsonData, err := json.MarshalIndent(clientModelsInput, "", "  ")
	if err != nil {
		return fmt.Errorf("error marshalling models: %v", err)
	}

	err = os.WriteFile(path, jsonData, 0644)
	if err != nil {
		return fmt.Errorf("error writing file: %v", err)
	}

	err = SaveCustomModelsHash(path, modelsInput)
	if err != nil {
		return fmt.Errorf("error saving hash file: %v", err)
	}

	return nil
}

func SaveCustomModelsHash(basePath string, modelsInput *shared.ModelsInput) error {
	hashPath := basePath + ".hash"

	hash, err := modelsInput.Hash()
	if err != nil {
		return fmt.Errorf("error hashing models: %v", err)
	}

	err = os.WriteFile(hashPath, []byte(hash), 0644)
	if err != nil {
		return fmt.Errorf("error writing hash file: %v", err)
	}

	return nil
}

func MustSyncCustomModels(path string, serverModelsInput *shared.ModelsInput) bool {
	term.StartSpinner("")

	jsonData, err := os.ReadFile(path)
	if err != nil {
		term.OutputErrorAndExit("Error reading custom models file: %v", err)
		return false
	}

	clientModelsInput, err := schema.ValidateModelsInputJSON(jsonData)
	if err != nil {
		term.StopSpinner()
		color.New(color.Bold, term.ColorHiRed).Println("🚨 Error validating custom models file")
		fmt.Println(err.Error())
		return false
	}

	modelsInput := clientModelsInput.ToModelsInput()

	noDuplicates, errMsg := modelsInput.CheckNoDuplicates()
	if !noDuplicates {
		term.StopSpinner()
		color.New(color.Bold, term.ColorHiRed).Println("🚨 Some items in custom models file are duplicated:")
		fmt.Println()
		fmt.Println(errMsg)
		return false
	}

	if modelsInput.Equals(*serverModelsInput) {
		term.StopSpinner()
		return false
	}

	apiErr := api.Client.CreateCustomModels(&modelsInput)
	if apiErr != nil {
		term.OutputErrorAndExit("Error importing models: %v", apiErr.Msg)
		return false
	}

	err = SaveCustomModelsHash(path, &modelsInput)
	if err != nil {
		term.OutputErrorAndExit("Error saving hash file: %v", err)
		return false
	}

	inputModelIds := map[string]bool{}
	inputProviderNames := map[string]bool{}
	inputModelPackNames := map[string]bool{}
	for _, model := range clientModelsInput.CustomModels {
		inputModelIds[string(model.ModelId)] = true
	}
	for _, provider := range clientModelsInput.CustomProviders {
		inputProviderNames[provider.Name] = true
	}
	for _, modelPack := range clientModelsInput.CustomModelPacks {
		inputModelPackNames[modelPack.Name] = true
	}

	updatedModelsInput := modelsInput.FilterUnchanged(serverModelsInput)

	customModels := serverModelsInput.CustomModels
	customProviders := serverModelsInput.CustomProviders
	customModelPacks := serverModelsInput.CustomModelPacks

	term.StopSpinner()

	added := strings.Builder{}
	updated := strings.Builder{}
	deleted := strings.Builder{}

	existsById := map[string]bool{}
	for _, model := range customModels {
		existsById[string(model.ModelId)] = true
	}
	for _, provider := range customProviders {
		existsById[provider.Name] = true
	}
	for _, modelPack := range customModelPacks {
		existsById[modelPack.Name] = true
	}

	for _, provider := range updatedModelsInput.CustomProviders {
		action := "✅ Added"
		builder := &added
		if existsById[provider.Name] {
			action = "🔄 Updated"
			builder = &updated
		}
		builder.WriteString(fmt.Sprintf("%s custom %s → %s\n",
			action,
			color.New(term.ColorHiCyan).Sprint("provider"),
			color.New(color.Bold, term.ColorHiGreen).Sprint(provider.Name)))
	}
	for _, provider := range customProviders {
		if !inputProviderNames[provider.Name] {
			deleted.WriteString(fmt.Sprintf("❌ Removed custom %s → %s\n",
				color.New(term.ColorHiCyan).Sprint("provider"),
				color.New(color.Bold, term.ColorHiRed).Sprint(provider.Name)))
		}
	}

	for _, model := range updatedModelsInput.CustomModels {
		action := "✅ Added"
		builder := &added
		if existsById[string(model.ModelId)] {
			action = "🔄 Updated"
			builder = &updated
		}
		builder.WriteString(fmt.Sprintf("%s custom %s → %s\n",
			action,
			color.New(term.ColorHiCyan).Sprint("model"),
			color.New(color.Bold, term.ColorHiGreen).Sprint(string(model.ModelId))))
	}
	for _, model := range customModels {
		if !inputModelIds[string(model.ModelId)] {
			deleted.WriteString(fmt.Sprintf("❌ Removed custom %s → %s\n",
				color.New(term.ColorHiCyan).Sprint("model"),
				color.New(color.Bold, term.ColorHiRed).Sprint(string(model.ModelId))))
		}
	}

	for _, modelPack := range updatedModelsInput.CustomModelPacks {
		action := "✅ Added"
		builder := &added
		if existsById[modelPack.Name] {
			action = "🔄 Updated"
			builder = &updated
		}
		builder.WriteString(fmt.Sprintf("%s custom %s → %s\n",
			action,
			color.New(term.ColorHiCyan).Sprint("model pack"),
			color.New(color.Bold, term.ColorHiGreen).Sprint(modelPack.Name)))
	}
	for _, modelPack := range customModelPacks {
		if !inputModelPackNames[modelPack.Name] {
			deleted.WriteString(fmt.Sprintf("❌ Removed custom %s → %s\n",
				color.New(term.ColorHiCyan).Sprint("model pack"),
				color.New(color.Bold, term.ColorHiRed).Sprint(modelPack.Name)))
		}
	}

	if updated.Len()+added.Len()+deleted.Len() == 0 {
		return false
	}

	fmt.Print(added.String())
	fmt.Print(updated.String())
	fmt.Print(deleted.String())

	return true
}

func SyncCustomModels() error {
	userId := auth.Current.UserId
	if userId == "" {
		return fmt.Errorf("auth.Current.UserId is empty")
	}

	serverModelsInput, err := GetServerModelsInput()
	if err != nil {
		return fmt.Errorf("error getting server models input: %v", err)
	}

	MustSyncCustomModels(GetCustomModelsPath(userId), serverModelsInput)

	return nil
}


================================================
FILE: app/cli/lib/editor.go
================================================
package lib

import (
	"os"
	"os/exec"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/term"
	shared "plandex-shared"
	"sort"
	"strings"
)

func MaybePromptAndOpen(path string, defaultConfig *shared.PlanConfig, planConfig *shared.PlanConfig) bool {
	var cmd string
	var args []string
	var openManually bool

	var checkConfig *shared.PlanConfig
	if planConfig != nil {
		checkConfig = planConfig
	} else if defaultConfig != nil {
		checkConfig = defaultConfig
	} else {
		term.OutputErrorAndExit("Missing config")
	}

	if checkConfig.EditorOpenManually {
		return false
	}

	if checkConfig.EditorCommand == "" {
		editorRes := SelectEditor(true)
		cmd = editorRes.Cmd
		args = editorRes.Args
		openManually = editorRes.OpenManually

		// update the default editor config
		toUpdateDefault := *defaultConfig
		toUpdateDefault.Editor = editorRes.Name
		toUpdateDefault.EditorCommand = cmd
		toUpdateDefault.EditorArgs = args
		toUpdateDefault.EditorOpenManually = openManually

		apiErr := api.Client.UpdateDefaultPlanConfig(shared.UpdateDefaultPlanConfigRequest{
			Config: &toUpdateDefault,
		})
		if apiErr != nil {
			term.OutputErrorAndExit("Error updating default config: %v", apiErr)
		}

		// also update the current plan config
		if planConfig != nil {
			toUpdate := *planConfig
			toUpdate.Editor = editorRes.Name
			toUpdate.EditorCommand = cmd
			toUpdate.EditorArgs = args
			toUpdate.EditorOpenManually = openManually
			apiErr = api.Client.UpdatePlanConfig(CurrentPlanId, shared.UpdatePlanConfigRequest{
				Config: &toUpdate,
			})
			if apiErr != nil {
				term.OutputErrorAndExit("Error updating plan config: %v", apiErr)
			}
		}
	} else {
		cmd = checkConfig.EditorCommand
		args = checkConfig.EditorArgs
	}

	if openManually {
		return false
	}

	err := exec.Command(cmd, append(args, path)...).Start()
	if err != nil {
		term.OutputErrorAndExit("Error opening template: %v", err)
	}

	return true
}

type SelectEditorResult struct {
	Name         string
	Cmd          string
	Args         []string
	OpenManually bool
}

func SelectEditor(includeOpenManuallyOpt bool) SelectEditorResult {
	editors := detectEditors()

	opts := []string{}
	for _, c := range editors {
		opts = append(opts, c.name)
	}
	const otherOpt = "Other (custom command)"
	opts = append(opts, otherOpt)

	const openManuallyOpt = "Open files manually"
	if includeOpenManuallyOpt {
		opts = append(opts, openManuallyOpt)
	}

	choice, err := term.SelectFromList("What's your preferred editor?", opts)
	if err != nil {
		term.OutputErrorAndExit("Error selecting editor: %v", err)
	}

	var name string
	var cmd string
	var args []string

	if choice == otherOpt {
		choice, err = term.GetRequiredUserStringInput("Enter the command to open the editor")
		if err != nil {
			term.OutputErrorAndExit("Error getting editor command: %v", err)
		}
		name = choice
		parts := strings.Fields(choice)
		if len(parts) == 0 {
			term.OutputErrorAndExit("Invalid editor command: %s", choice)
		}
		cmd = parts[0]
		if len(parts) > 1 {
			args = parts[1:]
		}
	} else if choice == openManuallyOpt {
		return SelectEditorResult{
			Name:         "Open manually",
			Cmd:          "",
			Args:         []string{},
			OpenManually: true,
		}
	} else {
		var candidate editorCandidate
		for _, c := range editors {
			if c.name == choice {
				candidate = c
				break
			}
		}
		name = candidate.name
		cmd = candidate.cmd
		args = candidate.args
	}

	return SelectEditorResult{
		Name: name,
		Cmd:  cmd,
		Args: args,
	}
}

type editorCandidate struct {
	name        string
	cmd         string
	args        []string
	isJetBrains bool
}

const maxEditorOpts = 5

func detectEditors() []editorCandidate {
	guess := []editorCandidate{
		// Popular non-JetBrains launchers
		{"VS Code", "code", nil, false},
		{"Cursor", "cursor", nil, false},
		{"Zed", "zed", nil, false},
		{"Neovim", "nvim", nil, false},

		// JetBrains IDE-specific launchers
		{"IntelliJ IDEA", "idea", nil, true},
		{"GoLand", "goland", nil, true},
		{"PyCharm", "pycharm", nil, true},
		{"CLion", "clion", nil, true},
		{"WebStorm", "webstorm", nil, true},
		{"PhpStorm", "phpstorm", nil, true},
		{"DataGrip", "datagrip", nil, true},
		{"RubyMine", "rubymine", nil, true},
		{"Rider", "rider", nil, true},
		{"DataSpell", "dataspell", nil, true},

		// JetBrains universal CLI (2023.2+)
		{"JetBrains (jb)", "jb", []string{"open"}, true},

		{"Vim", "vim", nil, false},
		{"Nano", "nano", nil, false},
		{"Helix", "hx", nil, false},
		{"Micro", "micro", nil, false},
		{"Sublime Text", "subl", nil, false},
		{"TextMate", "mate", nil, false},
		{"Kakoune", "kak", nil, false},
		{"Emacs", "emacs", nil, false},
		{"Kate", "kate", nil, false},
	}
	pref := map[string]bool{}
	for _, env := range []string{"VISUAL", "EDITOR"} {
		if v := os.Getenv(env); v != "" {
			// keep only the binary name, drop path/flags
			cmd := filepath.Base(strings.Fields(v)[0])
			pref[cmd] = true
		}
	}

	_, err := exec.LookPath("jb") // true if universal launcher exists
	jbOnPath := err == nil

	var found []editorCandidate
	for _, c := range guess {
		if _, err := exec.LookPath(c.cmd); err != nil {
			continue // not on PATH
		}

		// If jb is present, drop per-IDE launchers *unless* this exact cmd
		// is marked preferred by VISUAL/EDITOR.
		if jbOnPath && c.isJetBrains && !pref[c.cmd] {
			continue
		}
		found = append(found, c)
	}

	for cmd := range pref {
		if _, err := exec.LookPath(cmd); err == nil {
			already := false
			for _, c := range found {
				if c.cmd == cmd {
					already = true
					break
				}
			}
			if !already {
				found = append(found, editorCandidate{name: cmd, cmd: cmd})
			}
		}
	}
	sort.SliceStable(found, func(i, j int) bool {
		pi, pj := pref[found[i].cmd], pref[found[j].cmd]
		if pi == pj {
			return false // keep original order
		}
		return pi // true → i comes before j
	})
	if len(found) > maxEditorOpts {
		found = found[:maxEditorOpts]
	}

	return found
}


================================================
FILE: app/cli/lib/git.go
================================================
package lib

import (
	"fmt"
	"log"
	"os/exec"
	"regexp"
	"strings"
	"sync"
	"time"
)

var gitMutex sync.Mutex

func GitAddAndCommit(dir, message string, lockMutex bool) error {
	if lockMutex {
		gitMutex.Lock()
		defer gitMutex.Unlock()
	}

	err := GitAdd(dir, ".", false)
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
	}

	err = GitCommit(dir, message, nil, false)
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v", dir, err)
	}

	return nil
}

func GitAddAndCommitPaths(dir, message string, paths []string, lockMutex bool) error {
	if len(paths) == 0 {
		return nil
	}

	if lockMutex {
		gitMutex.Lock()
		defer gitMutex.Unlock()
	}

	for _, path := range paths {
		err := GitAdd(dir, path, false)
		if err != nil {
			return fmt.Errorf("error adding file %s to git repository for dir: %s, err: %v", path, dir, err)
		}
	}

	err := GitCommit(dir, message, paths, false)
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v", dir, err)
	}

	return nil
}

func GitAdd(repoDir, path string, lockMutex bool) error {
	if lockMutex {
		gitMutex.Lock()
		defer gitMutex.Unlock()
	}

	res, err := exec.Command("git", "-C", repoDir, "add", path).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}

	return nil
}

func GitCommit(repoDir, commitMsg string, paths []string, lockMutex bool) error {
	if lockMutex {
		gitMutex.Lock()
		defer gitMutex.Unlock()
	}

	args := []string{"-C", repoDir, "commit", "-m", commitMsg, "--allow-empty"}

	if len(paths) > 0 {
		args = append(args, paths...)
	}

	res, err := exec.Command("git", args...).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}

	return nil
}

func CheckUncommittedChanges() (bool, error) {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	// Check if there are any changes
	res, err := exec.Command("git", "status", "--porcelain").CombinedOutput()
	if err != nil {
		return false, fmt.Errorf("error checking for uncommitted changes: %v, output: %s", err, string(res))
	}

	// If there's output, there are uncommitted changes
	return strings.TrimSpace(string(res)) != "", nil
}

func GitStashCreate(message string) error {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	res, err := exec.Command("git", "stash", "push", "--include-untracked", "-m", message).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error creating git stash: %v, output: %s", err, string(res))
	}

	return nil
}

// this matches output for git version 2.39.3
// need to test on other versions and check for more variations
// there isn't any structured way to get stash conflicts from git, unfortunately
const PopStashConflictMsg = "overwritten by merge"
const ConflictMsgFilesEnd = "commit your changes"

func GitStashPop(forceOverwrite bool) error {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	res, err := exec.Command("git", "stash", "pop").CombinedOutput()

	// we should no longer have conflicts since we are forcing an update before
	// running the 'apply' command as well as resetting any files with uncommitted change
	// still leaving this though in case something goes wrong

	if err != nil {
		log.Println("Error popping git stash:", string(res))

		if strings.Contains(string(res), PopStashConflictMsg) {
			log.Println("Conflicts detected")

			if !forceOverwrite {
				return fmt.Errorf("conflict popping git stash: %s", string(res))
			}

			// Parse the output to find which files have conflicts
			conflictFiles := parseConflictFiles(string(res))

			log.Println("Conflicting files:", conflictFiles)

			for _, file := range conflictFiles {
				// Reset each conflicting file individually
				checkoutRes, err := exec.Command("git", "checkout", "--ours", file).CombinedOutput()
				if err != nil {
					return fmt.Errorf("error resetting file %s: %v", file, string(checkoutRes))
				}
			}
			dropRes, err := exec.Command("git", "stash", "drop").CombinedOutput()
			if err != nil {
				return fmt.Errorf("error dropping git stash: %v", string(dropRes))
			}
			return nil
		} else {
			log.Println("No conflicts detected")

			return fmt.Errorf("error popping git stash: %v", string(res))
		}
	}

	return nil
}

func GitClearUncommittedChanges() error {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	// Reset staged changes
	res, err := exec.Command("git", "reset", "--hard").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error resetting staged changes | err: %v, output: %s", err, string(res))
	}

	// Clean untracked files
	res, err = exec.Command("git", "clean", "-d", "-f").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error cleaning untracked files | err: %v, output: %s", err, string(res))
	}

	return nil
}

func GitFileHasUncommittedChanges(path string) (bool, error) {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	res, err := exec.Command("git", "status", "--porcelain", path).CombinedOutput()
	if err != nil {
		return false, fmt.Errorf("error checking for uncommitted changes for file %s | err: %v, output: %s", path, err, string(res))
	}

	return strings.TrimSpace(string(res)) != "", nil
}

func GitCheckoutFile(path string) error {
	gitMutex.Lock()
	defer gitMutex.Unlock()

	res, err := exec.Command("git", "checkout", path).CombinedOutput()
	if err != nil {
		log.Println("Error checking out file:", string(res))

		return fmt.Errorf("error checking out file %s | err: %v, output: %s", path, err, string(res))
	}

	return nil
}

const GitLogTimestampFormat = "Mon Jan 2, 2006 | 3:04:05pm"

var GitLogTimestampRegex = regexp.MustCompile(`\w{3} \w{3} \d{1,2}, \d{4} \| \d{1,2}:\d{2}:\d{2}(am|pm) UTC`)

func GetGitLogTimestamp(log string) (time.Time, error) {
	matches := GitLogTimestampRegex.FindStringSubmatch(log)
	if len(matches) < 2 {
		return time.Time{}, fmt.Errorf("no timestamp found in log")
	}

	return time.Parse(GitLogTimestampFormat, strings.TrimSuffix(matches[0], " UTC"))
}

func parseConflictFiles(gitOutput string) []string {
	var conflictFiles []string
	lines := strings.Split(gitOutput, "\n")

	inFilesSection := false

	for _, line := range lines {
		if inFilesSection {
			file := strings.TrimSpace(line)
			if file == "" {
				continue
			}
			conflictFiles = append(conflictFiles, strings.TrimSpace(line))
		} else if strings.Contains(line, PopStashConflictMsg) {
			inFilesSection = true
		} else if strings.Contains(line, ConflictMsgFilesEnd) {
			break
		}
	}
	return conflictFiles
}


================================================
FILE: app/cli/lib/legacy_files.go
================================================
package lib

import (
	"encoding/json"
	"log"
	"os"
	"path/filepath"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
)

func MigrateLegacyProjectFile(currentUserId string) {
	if fs.PlandexDir == "" {
		return
	}

	if currentUserId == "" {
		return
	}

	// Migrate project.json to projects-v2.json
	// New formats map to a user id so we can handle multiple accounts in the same plandex dir
	projectPath := filepath.Join(fs.PlandexDir, "project.json")
	if _, err := os.Stat(projectPath); err == nil {
		var settings types.CurrentProjectSettings
		bytes, err := os.ReadFile(projectPath)
		if err != nil {
			term.OutputErrorAndExit("error reading project.json: %v", err)
		}

		err = json.Unmarshal(bytes, &settings)
		if err != nil {
			term.OutputErrorAndExit("error unmarshalling project.json: %v", err)
		}

		v2Path := filepath.Join(fs.PlandexDir, "projects-v2.json")
		settingsByAccount := types.CurrentProjectSettingsByAccount{
			currentUserId: &settings,
		}
		bytes, err = json.Marshal(settingsByAccount)
		if err != nil {
			term.OutputErrorAndExit("error marshalling projects-v2.json: %v", err)
		}

		err = os.WriteFile(v2Path, bytes, 0644)
		if err != nil {
			term.OutputErrorAndExit("error writing projects-v2.json: %v", err)
		}

		// Delete the v1 file after successful migration
		if err := os.Remove(projectPath); err != nil {
			term.OutputErrorAndExit("could not delete old project.json: %v", err)
		}
		log.Println("Migrated project.json to projects-v2.json")

	} else if !os.IsNotExist(err) {
		term.OutputErrorAndExit("error checking for project.json: %v", err)
	}
}

func MigrateLegacyCurrentPlanFile(currentUserId string) {
	if fs.PlandexDir == "" {
		return
	}

	if currentUserId == "" {
		return
	}

	if CurrentProjectId == "" {
		return
	}

	// Migrate current_plan.json to current-plans-v2.json
	planPath := filepath.Join(fs.HomePlandexDir, CurrentProjectId, "current_plan.json")

	if _, err := os.Stat(planPath); err == nil {
		var settings types.CurrentPlanSettings
		bytes, err := os.ReadFile(planPath)
		if err != nil {
			term.OutputErrorAndExit("error reading current_plan.json: %v", err)
		}

		err = json.Unmarshal(bytes, &settings)
		if err != nil {
			term.OutputErrorAndExit("error unmarshalling current_plan.json: %v", err)
		}

		v2Path := filepath.Join(fs.HomePlandexDir, CurrentProjectId, "current-plans-v2.json")
		settingsByAccount := types.CurrentPlanSettingsByAccount{
			currentUserId: &settings,
		}
		bytes, err = json.Marshal(settingsByAccount)
		if err != nil {
			term.OutputErrorAndExit("error marshalling current-plans-v2.json: %v", err)
		}

		err = os.WriteFile(v2Path, bytes, 0644)
		if err != nil {
			term.OutputErrorAndExit("error writing current-plans-v2.json: %v", err)
		}

		// Delete the v1 file after successful migration
		if err := os.Remove(planPath); err != nil {
			term.OutputErrorAndExit("could not delete old current_plan.json: %v", err)
		}
		log.Println("Migrated current_plan.json to current-plans-v2.json")
	} else if !os.IsNotExist(err) {
		term.OutputErrorAndExit("error checking for current_plan.json: %v", err)
	}
}

func MigrateLegacyPlanSettingsFile(currentUserId string) {
	if fs.PlandexDir == "" {
		return
	}

	if currentUserId == "" {
		return
	}

	if CurrentPlanId == "" {
		return
	}

	// Migrate settings.json to settings-v2.json for current plan
	settingsPath := filepath.Join(fs.HomePlandexDir, CurrentProjectId, CurrentPlanId, "settings.json")
	if _, err := os.Stat(settingsPath); err == nil {
		var settings types.PlanSettings
		bytes, err := os.ReadFile(settingsPath)
		if err != nil {
			term.OutputErrorAndExit("error reading settings.json: %v", err)
		}

		err = json.Unmarshal(bytes, &settings)
		if err != nil {
			term.OutputErrorAndExit("error unmarshalling settings.json: %v", err)
		}

		v2Path := filepath.Join(fs.HomePlandexDir, CurrentProjectId, CurrentPlanId, "settings-v2.json")
		settingsByAccount := types.PlanSettingsByAccount{
			currentUserId: &settings,
		}
		bytes, err = json.Marshal(settingsByAccount)
		if err != nil {
			term.OutputErrorAndExit("error marshalling settings-v2.json: %v", err)
		}

		err = os.WriteFile(v2Path, bytes, 0644)
		if err != nil {
			term.OutputErrorAndExit("error writing settings-v2.json: %v", err)
		}

		// Delete the v1 file after successful migration
		if err := os.Remove(settingsPath); err != nil {
			term.OutputErrorAndExit("could not delete old settings.json: %v", err)
		}
		log.Println("Migrated settings.json to settings-v2.json")
	} else if !os.IsNotExist(err) {
		term.OutputErrorAndExit("error checking for settings.json: %v", err)
	}
}


================================================
FILE: app/cli/lib/log_format.go
================================================
package lib

import (
	"regexp"
	"strings"
	"time"
)

// Regular expressions for parsing log entries
var (
	// Match the update ID and timestamp
	updateRegex = regexp.MustCompile(`📝 Update ([a-f0-9]+)\[0;22m \| \[36m(.*?)\[0m`)
	
	// Match message number and type
	messageRegex = regexp.MustCompile(`Message #(\d+) \| (.+?) \|`)
	
	// Match coin count
	coinRegex = regexp.MustCompile(`(\d+) 🪙`)
	
	// Match context load summary
	contextRegex = regexp.MustCompile(`Loaded (\d+) .+ into context`)
)

// LogEntry represents a parsed log entry
type LogEntry struct {
	ID        string
	Timestamp string
	Type      string
	Message   string
}

// ParseLogEntry parses a raw log entry string into a structured LogEntry
func ParseLogEntry(raw string) LogEntry {
	lines := strings.Split(raw, "\n")
	entry := LogEntry{}
	
	// Parse first line for update ID and timestamp
	if matches := updateRegex.FindStringSubmatch(lines[0]); len(matches) >= 3 {
		entry.ID = matches[1]
		entry.Timestamp = parseTimestamp(matches[2])
	}
	
	// Parse second line for message type and details
	if len(lines) > 1 {
		if matches := messageRegex.FindStringSubmatch(lines[1]); len(matches) >= 3 {
			entry.Type = cleanType(matches[2])
			entry.Message = lines[1]
		} else if matches := contextRegex.FindStringSubmatch(lines[1]); len(matches) >= 2 {
			entry.Type = "Context Load"
			entry.Message = lines[1]
		}
	}
	
	return entry
}

// FormatCompactSummary creates a compact one-line summary of the log entry
func FormatCompactSummary(entry LogEntry) string {
	var summary strings.Builder
	
	// Add timestamp
	summary.WriteString(entry.Timestamp)
	summary.WriteString(" | ")
	
	// Add type indicator and summary based on type
	switch {
	case strings.Contains(entry.Type, "User prompt"):
		summary.WriteString("💬 User: ")
		msg := extractFirstLine(entry.Message)
		if len(msg) > 40 {
			msg = msg[:37] + "..."
		}
		summary.WriteString(msg)
		
	case strings.Contains(entry.Type, "Plandex reply"):
		summary.WriteString("🤖 AI: ")
		if coins := coinRegex.FindStringSubmatch(entry.Message); len(coins) >= 2 {
			summary.WriteString(coins[1] + "🪙")
		}
		
	case strings.Contains(entry.Type, "Context Load"):
		summary.WriteString("📚 ")
		if matches := contextRegex.FindStringSubmatch(entry.Message); len(matches) >= 2 {
			summary.WriteString("Loaded " + matches[1] + " items")
		}
		
	case strings.Contains(entry.Type, "Build"):
		summary.WriteString("🏗️ Build changes")
		
	default:
		summary.WriteString(entry.Type)
	}
	
	return summary.String()
}

// Helper functions

func parseTimestamp(ts string) string {
	// Convert timestamp to a consistent format
	ts = strings.TrimSpace(ts)
	if ts == "Today" {
		return time.Now().Format("15:04:05")
	}
	if ts == "Yesterday" {
		return "Yesterday"
	}
	return ts
}

func cleanType(t string) string {
	// Remove ANSI color codes and clean up type string
	t = strings.TrimSpace(t)
	return strings.ReplaceAll(t, "[0m", "")
}

func extractFirstLine(s string) string {
	if idx := strings.Index(s, "\n"); idx != -1 {
		return s[:idx]
	}
	return s
}


================================================
FILE: app/cli/lib/model_credentials.go
================================================
package lib

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/term"
	"plandex-cli/types"
	shared "plandex-shared"
	"sort"
	"strings"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/fatih/color"
)

type ProviderAuthStatus int

const (
	FullySatisfied ProviderAuthStatus = iota
	PartiallySatisfied
	FullyMissing
)

type ProviderCredentialStatus struct {
	ProviderComposite string
	Status            ProviderAuthStatus
	MissingVars       []string
}

type PublisherCredentialStatus struct {
	Publisher        shared.ModelPublisher
	SelectedProvider *ProviderCredentialStatus
	PartialProviders []ProviderCredentialStatus
}

type CredentialCheckResult struct {
	AllSatisfied bool
	Publishers   []PublisherCredentialStatus
	AuthVars     map[string]string
}

func CheckCredentialStatus(opts shared.ModelProviderOptions, claudeMaxEnabled bool) (CredentialCheckResult, error) {
	publishersToProviders := groupProvidersByPublisher(opts)

	selectedAuthVars := map[string]string{}
	var publisherStatuses []PublisherCredentialStatus
	allSatisfied := true

	for publisher, providers := range publishersToProviders {
		var selectedProvider *ProviderCredentialStatus
		partialProviders := []ProviderCredentialStatus{}

		for _, provider := range providers {
			if provider.Config.HasClaudeMaxAuth && !claudeMaxEnabled {
				continue
			}

			authVars, err := ResolveProviderAuthVars(provider.Config)
			if err != nil {
				return CredentialCheckResult{}, fmt.Errorf("error checking API keys/credentials: %v", err)
			}
			status, missingVars, err := checkProviderCredentialStatus(provider.Config, authVars)
			if err != nil {
				return CredentialCheckResult{}, fmt.Errorf("error checking API keys/credentials: %v", err)
			}

			providerStatus := ProviderCredentialStatus{
				ProviderComposite: provider.Config.ToComposite(),
				Status:            status,
				MissingVars:       missingVars,
			}

			if status == FullySatisfied {
				selectedProvider = &providerStatus
				mergeAuthVars(selectedAuthVars, authVars)
				break // first fully satisfied provider found, stop looking further
			} else if status == PartiallySatisfied {
				partialProviders = append(partialProviders, providerStatus)
			}
			// otherwise,if fully missing, don't set selected provider
		}

		if selectedProvider == nil {
			allSatisfied = false
		}

		publisherStatuses = append(publisherStatuses, PublisherCredentialStatus{
			Publisher:        publisher,
			SelectedProvider: selectedProvider,
			PartialProviders: partialProviders,
		})
	}

	return CredentialCheckResult{
		AllSatisfied: allSatisfied,
		Publishers:   publisherStatuses,
		AuthVars:     selectedAuthVars,
	}, nil
}

func groupProvidersByPublisher(opts shared.ModelProviderOptions) map[shared.ModelPublisher][]shared.ModelProviderOption {
	grouped := map[shared.ModelPublisher][]shared.ModelProviderOption{}
	for _, option := range opts {
		for pub := range option.Publishers {
			grouped[pub] = append(grouped[pub], option)
		}
	}
	// stable priority sort
	for pub := range grouped {
		sort.SliceStable(grouped[pub], func(i, j int) bool {
			return grouped[pub][i].Priority < grouped[pub][j].Priority
		})
	}
	return grouped
}

func checkProviderCredentialStatus(cfg *shared.ModelProviderConfigSchema, authVars map[string]string) (ProviderAuthStatus, []string, error) {
	var missing []string

	if cfg.SkipAuth {
		return FullySatisfied, nil, nil
	}

	if cfg.HasClaudeMaxAuth {
		creds, err := GetAccountCredentials()
		if err != nil {
			return FullyMissing, nil, fmt.Errorf("error getting account credentials: %v", err)
		}
		if creds == nil || creds.ClaudeMax == nil {
			return FullyMissing, nil, nil
		}
	}

	if cfg.ApiKeyEnvVar != "" && authVars[cfg.ApiKeyEnvVar] == "" {
		missing = append(missing, cfg.ApiKeyEnvVar)
	}

	for _, extra := range cfg.ExtraAuthVars {
		if extra.Required && authVars[extra.Var] == "" {
			missing = append(missing, extra.Var)
		}
	}

	numRequired := 0
	for _, extra := range cfg.ExtraAuthVars {
		if extra.Required {
			numRequired++
		}
	}
	if cfg.ApiKeyEnvVar != "" {
		numRequired++
	}

	switch {
	case len(missing) == 0:
		return FullySatisfied, nil, nil
	case len(missing) == numRequired:
		return FullyMissing, missing, nil
	default:
		return PartiallySatisfied, missing, nil
	}
}

func MustVerifyAuthVars(integratedModels bool) map[string]string {
	return mustVerifyAuthVars(integratedModels, false)
}

func MustVerifyAuthVarsSilent(integratedModels bool) map[string]string {
	return mustVerifyAuthVars(integratedModels, true)
}

func mustVerifyAuthVars(integratedModels, silent bool) map[string]string {
	if !silent {
		term.StartSpinner("")
	}

	planSettings, apiErr := api.Client.GetSettings(CurrentPlanId, CurrentBranch)
	if apiErr != nil {
		term.OutputErrorAndExit("Error getting settings: %v", apiErr)
	}

	orgUserConfig := MustGetOrgUserConfig()

	opts := planSettings.GetModelProviderOptions()

	if !silent {
		if hasAnthropicModels(opts) {
			didConnect := promptClaudeMaxIfNeeded()
			term.StartSpinner("")
			if !didConnect && orgUserConfig.UseClaudeSubscription {
				didConnect = connectClaudeMaxIfNeeded()
				if !didConnect {
					refreshClaudeMaxCredsIfNeeded()
				}
			}
		}
	}

	// For IntegratedModelsMode on Cloud, we only send the connected Claude subscription api key—nothing else
	// If we're in IntegratedModelsMode and there's no connected Claude sub, return nil
	if integratedModels {
		if orgUserConfig.UseClaudeSubscription {
			creds, err := GetAccountCredentials()
			if err != nil {
				term.OutputErrorAndExit("Error getting Claude subscription credentials: %v", err)
			}

			if creds != nil && creds.ClaudeMax != nil {
				return map[string]string{
					shared.AnthropicClaudeMaxTokenEnvVar: creds.ClaudeMax.AccessToken,
				}
			}
		}
		return nil
	}

	checkResult, err := CheckCredentialStatus(opts, orgUserConfig.UseClaudeSubscription)
	if err != nil {
		term.OutputErrorAndExit("Error checking API keys/credentials: %v", err)
	}
	if checkResult.AllSatisfied {
		return checkResult.AuthVars
	}

	showCredentialErrorMessage(checkResult, opts)
	os.Exit(1)
	return nil
}

func ResolveProviderAuthVars(cfg *shared.ModelProviderConfigSchema) (map[string]string, error) {
	authVars := map[string]string{}

	if cfg.SkipAuth {
		return authVars, nil
	}

	if cfg.HasAWSAuth {
		// PLANDEX_AWS_PROFILE enables credential file loading from ~/.aws/credentials
		// this ensures it's opt-in so we only use bedrock if user explicitly intends to
		profile := os.Getenv("PLANDEX_AWS_PROFILE")
		if profile != "" {
			os.Setenv("AWS_PROFILE", profile)
			if err := loadAWSVars(authVars); err == nil {
				return authVars, nil
			}
		}
		// if no PLANDEX_AWS_PROFILE is set OR loading aws vars fails, just silently fall through to the default env var checks

		// because we're disabling the EC2 metadata service, the aws check will fail unless appropriate env vars or credentials file is found, but it's not actually a problem—just indicates AWS creds aren't set
	}

	if cfg.HasClaudeMaxAuth {
		creds, err := GetAccountCredentials()
		if err != nil {
			return nil, fmt.Errorf("error getting account credentials: %v", err)
		}

		if creds != nil && creds.ClaudeMax != nil {
			token := creds.ClaudeMax.AccessToken
			authVars[shared.AnthropicClaudeMaxTokenEnvVar] = token
		}
	}

	if cfg.ApiKeyEnvVar != "" {
		val := os.Getenv(cfg.ApiKeyEnvVar)
		if val != "" {
			authVars[cfg.ApiKeyEnvVar] = val
		}
	}

	for _, extra := range cfg.ExtraAuthVars {
		val := os.Getenv(extra.Var)
		if val == "" && extra.Default != "" {
			val = extra.Default
		}

		if extra.MaybeJSONFilePath {
			if val == "" {
				continue
			}
			content, err := maybeLoadFile(val)
			if err != nil {
				return nil, fmt.Errorf("failed to load file for %s: %v", extra.Var, err)
			}
			authVars[extra.Var] = content
		} else if val != "" {
			authVars[extra.Var] = val
		}
	}

	return authVars, nil
}

func maybeLoadFile(pathOrJson string) (string, error) {
	if strings.HasPrefix(strings.TrimSpace(pathOrJson), "{") {
		// var contains json directly, so we can return it as is
		return pathOrJson, nil
	}

	// see if it's base64 encoded json
	decoded, err := base64.StdEncoding.DecodeString(pathOrJson)
	if err == nil {
		s := string(decoded)
		if strings.HasPrefix(strings.TrimSpace(s), "{") {
			return s, nil
		}
	}

	content, err := os.ReadFile(pathOrJson)
	if err != nil {
		return "", err
	}

	return string(content), nil
}

func loadAWSVars(vars map[string]string) error {
	// disable IMDS to prevent slow request
	os.Setenv("AWS_EC2_METADATA_DISABLED", "true")

	cfg, err := config.LoadDefaultConfig(context.Background())
	if err != nil {
		return fmt.Errorf("failed to load AWS config: %v", err)
	}

	creds, err := cfg.Credentials.Retrieve(context.Background())
	if err != nil {
		return fmt.Errorf("failed to retrieve AWS credentials: %v", err)
	}

	vars["AWS_ACCESS_KEY_ID"] = creds.AccessKeyID
	vars["AWS_SECRET_ACCESS_KEY"] = creds.SecretAccessKey
	vars["AWS_REGION"] = cfg.Region
	if creds.SessionToken != "" {
		vars["AWS_SESSION_TOKEN"] = creds.SessionToken
	}

	return nil
}

func mergeAuthVars(dest, src map[string]string) {
	for k, v := range src {
		dest[k] = v
	}
}

func showCredentialErrorMessage(res CredentialCheckResult, opts shared.ModelProviderOptions) {
	term.StopSpinner()
	boldRed := color.New(color.Bold, term.ColorHiRed)
	cyanChip := color.New(color.BgCyan, color.FgHiWhite)
	fmt.Println(boldRed.Sprint("🚨 Required API key(s) or model credentials are missing"))

	someOK, someMissing := false, false
	for _, p := range res.Publishers {
		if p.SelectedProvider != nil && p.SelectedProvider.Status == FullySatisfied {
			someOK = true
		} else {
			someMissing = true
		}
	}
	if someOK && someMissing {
		fmt.Println()
		fmt.Println(color.New(color.Bold, term.ColorHiYellow).Sprint("⚠️  Some models are missing a provider"))
		sorted := make([]PublisherCredentialStatus, 0, len(res.Publishers))
		for _, p := range res.Publishers {
			sorted = append(sorted, p)
		}
		sort.Slice(sorted, func(i, j int) bool {
			readyI := sorted[i].SelectedProvider != nil && sorted[i].SelectedProvider.Status == FullySatisfied
			readyJ := sorted[j].SelectedProvider != nil && sorted[j].SelectedProvider.Status == FullySatisfied
			return readyI && !readyJ
		})
		for _, p := range sorted {
			ready := p.SelectedProvider != nil && p.SelectedProvider.Status == FullySatisfied
			var lbl string
			if ready {
				lbl = p.SelectedProvider.ProviderComposite
			} else {
				lbl = "missing"
			}
			fmt.Printf("%s %s models → %s\n", mark(ready), p.Publisher, lbl)
		}
	}

	var partialLines []string
	added := map[string]bool{}
	for _, pub := range res.Publishers {
		partialProviders := pub.PartialProviders
		for _, sp := range partialProviders {
			// already added this provider
			if added[sp.ProviderComposite] {
				continue
			}

			// compute vars set vs missing
			opt, ok := opts[sp.ProviderComposite]
			if !ok {
				continue
			}
			req := requiredVars(opt.Config)
			var setVars []string
			for _, v := range req {
				missing := false
				for _, mv := range sp.MissingVars {
					if mv == v {
						missing = true
						break
					}
				}
				if !missing {
					setVars = append(setVars, v)
				}
			}
			added[sp.ProviderComposite] = true
			partialLines = append(partialLines,
				fmt.Sprintf("%s\n  set → %s\n  missing → %s",
					color.New(color.Bold).Sprint(sp.ProviderComposite),
					strings.Join(setVars, ", "),
					strings.Join(sp.MissingVars, ", "),
				))
		}
	}
	if len(partialLines) > 0 {
		sort.Strings(partialLines)
		fmt.Println()
		fmt.Println(color.New(term.ColorHiYellow, color.Bold).Sprint("⚠️  Providers with partial credentials"))
		for _, l := range partialLines {
			fmt.Println(l)
		}
	}

	byPub := providersByPublisher(opts)

	byPubWithoutOpenRouter := map[shared.ModelPublisher][]shared.ModelProvider{}
	for pub, providers := range byPub {
		nonOrProviders := []shared.ModelProvider{}
		for _, provider := range providers {
			if provider != shared.ModelProviderOpenRouter {
				nonOrProviders = append(nonOrProviders, provider)
			}
		}
		if len(nonOrProviders) > 0 {
			byPubWithoutOpenRouter[pub] = nonOrProviders
		}
	}

	allPublishersHaveOpenRouter := allPublishersHaveProvider(byPub, shared.ModelProviderOpenRouter)

	if allPublishersHaveOpenRouter {
		fmt.Println()
		fmt.Println(color.New(term.ColorHiCyan, color.Bold).Sprint("🚀 Quick option → OpenRouter.ai"))
		fmt.Println("OpenRouter allows you to use all models in the current model pack with a single account and API key. To get started:")
		fmt.Println()
		step := func(n int, txt string) { fmt.Printf("%d. %s\n", n, txt) }
		step(1, "Sign up at "+color.New(color.Bold).Sprint("https://openrouter.ai/sign-up"))
		step(2, "Buy some credits at "+color.New(color.Bold).Sprint("https://openrouter.ai/settings/credits"))
		step(3, "Generate an API key at "+color.New(color.Bold).Sprint("https://openrouter.ai/settings/keys"))
		if term.IsRepl {
			step(4, "Quit the REPL with "+cyanChip.Sprint(" \\quit "))
			step(5, "Run "+cyanChip.Sprint(" export OPENROUTER_API_KEY=… "))
			step(6, "Restart the REPL with "+cyanChip.Sprint(" plandex "))
		} else {
			step(4, "Run "+cyanChip.Sprint(" export OPENROUTER_API_KEY=… "))
		}
	}

	if len(byPubWithoutOpenRouter) > 0 {
		fmt.Println()
		fmt.Println(color.New(term.ColorHiCyan, color.Bold).Sprint("🔑 Other model providers"))
		if allPublishersHaveOpenRouter {
			fmt.Println("You can also use the following providers for the current model pack:")
		} else {
			fmt.Println("You can use the following providers for the current model pack:")
		}

		fmt.Println()
		pubs := make([]string, 0, len(byPubWithoutOpenRouter))
		for p := range byPubWithoutOpenRouter {
			pubs = append(pubs, string(p))
		}
		sort.Strings(pubs)
		for _, p := range pubs {
			providers := byPubWithoutOpenRouter[shared.ModelPublisher(p)]
			providerNames := make([]string, 0, len(providers))
			for _, provider := range providers {
				providerNames = append(providerNames, string(provider))
			}
			fmt.Printf("%s → %s\n", color.New(color.Bold).Sprint(p+" models"), strings.Join(providerNames, ", "))
		}

		fmt.Println(color.New(color.Bold, term.ColorHiCyan).Sprint("\n📖 Per-provider instructions"))
		fmt.Println("For details on the API key/credentials required for each provider, go to:\n" + color.New(color.Bold).Sprint("https://docs.plandex.ai/models/model-providers"))
	}

	fmt.Println()
}

// return required env‑var names (API key + required extras)
func requiredVars(cfg *shared.ModelProviderConfigSchema) []string {
	var vars []string
	if cfg.ApiKeyEnvVar != "" {
		vars = append(vars, cfg.ApiKeyEnvVar)
	}
	for _, ex := range cfg.ExtraAuthVars {
		if ex.Required {
			vars = append(vars, ex.Var)
		}
	}
	return vars
}

func providersByPublisher(opts shared.ModelProviderOptions) map[shared.ModelPublisher][]shared.ModelProvider {
	byPub := map[shared.ModelPublisher][]shared.ModelProvider{}
	sortedOpts := make([]shared.ModelProviderOption, 0, len(opts))
	for _, opt := range opts {
		sortedOpts = append(sortedOpts, opt)
	}
	sort.Slice(sortedOpts, func(i, j int) bool {
		return sortedOpts[i].Priority < sortedOpts[j].Priority
	})
	for _, opt := range sortedOpts {
		for pub := range opt.Publishers {
			byPub[pub] = append(byPub[pub], opt.Config.Provider)
		}
	}
	return byPub
}

func allPublishersHaveProvider(byPub map[shared.ModelPublisher][]shared.ModelProvider, p shared.ModelProvider) bool {
	if len(byPub) == 0 {
		return false
	}

	for _, providers := range byPub {
		found := false
		for _, provider := range providers {
			if provider == p {
				found = true
				break
			}
		}

		if !found {
			return false
		}
	}
	return true
}

// emoji for satisfied vs missing
func mark(ok bool) string {
	if ok {
		return "✅"
	}
	return "❌"
}

var cachedAccountCredentials *types.AccountCredentials

func SetAccountCredentials(creds *types.AccountCredentials) error {
	if auth.Current == nil {
		return fmt.Errorf("no authenticated user")
	}
	dir := filepath.Join(fs.HomePlandexDir, auth.Current.UserId, auth.Current.OrgId)
	err := os.MkdirAll(dir, 0700)
	if err != nil {
		return fmt.Errorf("error creating account credentials directory: %v", err)
	}
	path := filepath.Join(dir, "creds.json")
	bytes, err := json.MarshalIndent(creds, "", "  ")
	if err != nil {
		return fmt.Errorf("error marshalling account credentials: %v", err)
	}
	err = os.WriteFile(path, bytes, 0600)
	if err != nil {
		return fmt.Errorf("error writing account credentials: %v", err)
	}

	cachedAccountCredentials = creds

	return nil
}

func GetAccountCredentials() (*types.AccountCredentials, error) {
	if cachedAccountCredentials != nil {
		return cachedAccountCredentials, nil
	}

	if auth.Current == nil {
		return nil, fmt.Errorf("no authenticated user")
	}
	path := filepath.Join(fs.HomePlandexDir, auth.Current.UserId, auth.Current.OrgId, "creds.json")

	bytes, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}
		return nil, err
	}

	var creds types.AccountCredentials
	err = json.Unmarshal(bytes, &creds)
	if err != nil {
		return nil, err
	}

	cachedAccountCredentials = &creds

	return &creds, nil
}


================================================
FILE: app/cli/lib/model_settings.go
================================================
package lib

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/fs"
	"plandex-cli/schema"
	"plandex-cli/term"
	shared "plandex-shared"

	"github.com/fatih/color"
)

var DefaultModelSettingsPath string

func init() {
	DefaultModelSettingsPath = filepath.Join(fs.HomePlandexDir, "default-model-settings.json")
}

func GetPlanModelSettingsPath(planId string) string {
	return filepath.Join(fs.HomePlandexDir, planId, "model-settings.json")
}

type ModelSettingsCheckLocalChangesResult struct {
	HasLocalChanges           bool
	LocalModelPackSchemaRoles *shared.ModelPackSchemaRoles
}

func ModelSettingsCheckLocalChanges(path string) (ModelSettingsCheckLocalChangesResult, error) {
	hashPath := path + ".hash"

	exists, err := fs.FileExists(path)
	if err != nil {
		return ModelSettingsCheckLocalChangesResult{}, fmt.Errorf("error checking model settings file: %v", err)
	}

	if !exists {
		return ModelSettingsCheckLocalChangesResult{}, nil
	}

	lastSavedHash, err := os.ReadFile(hashPath)
	if err != nil && !os.IsNotExist(err) {
		return ModelSettingsCheckLocalChangesResult{}, fmt.Errorf("error reading hash file: %v", err)
	}

	localJsonData, err := os.ReadFile(path)
	if err != nil {
		return ModelSettingsCheckLocalChangesResult{}, fmt.Errorf("error reading JSON file: %v", err)
	}

	var clientModelPackSchemaRoles *shared.ClientModelPackSchemaRoles
	err = json.Unmarshal(localJsonData, &clientModelPackSchemaRoles)
	if err != nil {
		return ModelSettingsCheckLocalChangesResult{}, fmt.Errorf("error unmarshalling JSON file: %v", err)
	}

	currentHash, err := clientModelPackSchemaRoles.ToModelPackSchemaRoles().Hash()
	if err != nil {
		return ModelSettingsCheckLocalChangesResult{}, fmt.Errorf("error hashing model pack: %v", err)
	}

	modelPackSchemaRoles := clientModelPackSchemaRoles.ToModelPackSchemaRoles()

	return ModelSettingsCheckLocalChangesResult{
		HasLocalChanges:           currentHash != string(lastSavedHash),
		LocalModelPackSchemaRoles: &modelPackSchemaRoles,
	}, nil
}

func WriteModelSettingsFile(path string, originalSettings *shared.PlanSettings) error {
	err := os.MkdirAll(filepath.Dir(path), 0755)
	if err != nil {
		return fmt.Errorf("error creating directory: %v", err)
	}

	modelPackSchemaRoles := originalSettings.GetModelPack().ToModelPackSchema().ModelPackSchemaRoles

	clientModelPackRoles := modelPackSchemaRoles.ToClientModelPackSchemaRoles()

	bytes, err := json.MarshalIndent(clientModelPackRoles, "", "  ")
	if err != nil {
		return fmt.Errorf("error marshalling model pack: %v", err)
	}

	err = os.WriteFile(path, bytes, 0644)
	if err != nil {
		return fmt.Errorf("error writing JSON file: %v", err)
	}

	err = SaveModelPackRolesHash(path, &modelPackSchemaRoles)
	if err != nil {
		return fmt.Errorf("error saving model pack roles hash: %v", err)
	}

	return nil
}

func SaveModelPackRolesHash(basePath string, serverModelPack *shared.ModelPackSchemaRoles) error {
	hashPath := basePath + ".hash"

	hash, err := serverModelPack.Hash()
	if err != nil {
		return fmt.Errorf("error hashing model pack: %v", err)
	}

	err = os.WriteFile(hashPath, []byte(hash), 0644)
	if err != nil {
		return fmt.Errorf("error writing hash file: %v", err)
	}

	return nil
}

func ApplyModelSettings(path string, originalSettings *shared.PlanSettings) (*shared.PlanSettings, error) {
	jsonData, err := os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("error reading JSON file: %v", err)
	}

	settings, err := originalSettings.DeepCopy()
	if err != nil {
		return nil, fmt.Errorf("error copying settings: %v", err)
	}

	clientModelPackRoles, err := schema.ValidateModelPackInlineJSON(jsonData)
	if err != nil {
		term.StopSpinner()
		color.New(color.Bold, term.ColorHiRed).Println("🚨 Error validating JSON file")
		fmt.Println(err.Error())
		os.Exit(1)
	}
	modelPackRoles := clientModelPackRoles.ToModelPackSchemaRoles()

	modelPackSchema := shared.ModelPackSchema{
		Name:                 "custom",
		Description:          "Model pack with custom settings",
		ModelPackSchemaRoles: modelPackRoles,
	}
	modelPack := modelPackSchema.ToModelPack()
	settings.SetCustomModelPack(&modelPack)

	err = SaveModelPackRolesHash(path, &modelPackRoles)
	if err != nil {
		return nil, fmt.Errorf("error saving model settings hash: %v", err)
	}

	return settings, nil
}

func SaveLatestPlanModelSettingsIfNeeded() (bool, error) {
	path := GetPlanModelSettingsPath(CurrentPlanId)
	jsonData, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return false, nil
		}
		return false, fmt.Errorf("error reading JSON file: %v", err)
	}

	var clientModelPackSchemaRoles *shared.ClientModelPackSchemaRoles
	err = json.Unmarshal(jsonData, &clientModelPackSchemaRoles)
	if err != nil {
		return false, fmt.Errorf("error unmarshalling JSON file: %v", err)
	}

	modelPackSchemaRoles := clientModelPackSchemaRoles.ToModelPackSchemaRoles()

	localHash, err := modelPackSchemaRoles.Hash()
	if err != nil {
		return false, fmt.Errorf("error hashing model pack: %v", err)
	}

	settings, apiErr := api.Client.GetSettings(CurrentPlanId, CurrentBranch)
	if apiErr != nil {
		return false, fmt.Errorf("error getting settings: %v", apiErr)
	}

	serverHash, err := settings.GetModelPack().ToModelPackSchema().ModelPackSchemaRoles.Hash()
	if err != nil {
		return false, fmt.Errorf("error hashing model pack: %v", err)
	}

	if localHash == serverHash {
		return false, nil
	}

	err = WriteModelSettingsFile(path, settings)
	if err != nil {
		return false, fmt.Errorf("error writing model settings file: %v", err)
	}

	return true, nil
}

// save settings in file to server
func SyncPlanModelSettings() error {
	settings, err := api.Client.GetSettings(CurrentPlanId, CurrentBranch)
	if err != nil {
		return fmt.Errorf("error getting settings: %v", err)
	}

	updatedSettings, apiErr := ApplyModelSettings(GetPlanModelSettingsPath(CurrentPlanId), settings)
	if apiErr != nil {
		return fmt.Errorf("error applying model settings: %v", err)
	}

	res, updateErr := api.Client.UpdateSettings(CurrentPlanId, CurrentBranch, shared.UpdateSettingsRequest{
		ModelPackName: updatedSettings.ModelPackName,
		ModelPack:     updatedSettings.ModelPack,
	})

	if updateErr != nil {
		return fmt.Errorf("error updating settings: %v", err)
	}

	if res == nil {
		return nil
	}

	fmt.Println(res.Msg)

	return nil
}

func SyncDefaultModelSettings() error {
	settings, err := api.Client.GetOrgDefaultSettings()
	if err != nil {
		return fmt.Errorf("error getting settings: %v", err)
	}

	updatedSettings, apiErr := ApplyModelSettings(DefaultModelSettingsPath, settings)
	if apiErr != nil {
		return fmt.Errorf("error applying model settings: %v", err)
	}

	res, updateErr := api.Client.UpdateOrgDefaultSettings(shared.UpdateSettingsRequest{
		ModelPackName: updatedSettings.ModelPackName,
		ModelPack:     updatedSettings.ModelPack,
	})

	if updateErr != nil {
		return fmt.Errorf("error updating settings: %v", err)
	}

	if res == nil {
		return nil
	}

	fmt.Println(res.Msg)

	return nil
}


================================================
FILE: app/cli/lib/models_sync.go
================================================
package lib

import (
	"fmt"
	"plandex-cli/auth"
	"plandex-cli/term"

	"github.com/fatih/color"
)

func PromptSyncModelsIfNeeded() error {
	var changes []string
	var onApprove []func() error

	userId := auth.Current.UserId
	if userId == "" {
		return fmt.Errorf("auth.Current.UserId is empty")
	}

	customModelsPath := GetCustomModelsPath(userId)

	customModelsRes, err := CustomModelsCheckLocalChanges(customModelsPath)
	if err != nil {
		return fmt.Errorf("error checking custom models: %v", err)
	}

	if customModelsRes.HasLocalChanges {
		changes = append(
			changes,
			fmt.Sprintf("%s → %s", color.New(term.ColorHiCyan, color.Bold).Sprint("Custom models"), customModelsPath))

		onApprove = append(onApprove, SyncCustomModels)
	}

	defaultModelSettingsRes, err := ModelSettingsCheckLocalChanges(DefaultModelSettingsPath)
	if err != nil {
		return fmt.Errorf("error checking default model settings: %v", err)
	}

	if defaultModelSettingsRes.HasLocalChanges {
		changes = append(
			changes,
			fmt.Sprintf("%s → %s", color.New(term.ColorHiCyan, color.Bold).Sprint("Default model settings"), DefaultModelSettingsPath))

		onApprove = append(onApprove, SyncDefaultModelSettings)
	}

	planModelSettingsRes, err := ModelSettingsCheckLocalChanges(GetPlanModelSettingsPath(CurrentPlanId))
	if err != nil {
		return fmt.Errorf("error checking plan model settings: %v", err)
	}

	if planModelSettingsRes.HasLocalChanges {
		changes = append(
			changes,
			fmt.Sprintf("%s → %s", color.New(term.ColorHiCyan, color.Bold).Sprint("Plan model settings"), GetPlanModelSettingsPath(CurrentPlanId)))

		onApprove = append(onApprove, SyncPlanModelSettings)
	}

	if len(changes) == 0 {
		return nil
	}

	term.StopSpinner()
	color.New(color.Bold, term.ColorHiYellow).Println("⚠️  Model settings have local changes")

	fmt.Println()
	for _, change := range changes {
		fmt.Println(change)
	}
	fmt.Println()

	shouldSave, err := term.ConfirmYesNo("Save changes now?")
	if err != nil {
		return fmt.Errorf("error confirming: %v", err)
	}

	if !shouldSave {
		return nil
	}

	for _, fn := range onApprove {
		err := fn()
		if err != nil {
			return fmt.Errorf("error syncing models: %v", err)
		}
	}

	return nil
}


================================================
FILE: app/cli/lib/org_user_config.go
================================================
package lib

import (
	"plandex-cli/api"
	"plandex-cli/term"

	shared "plandex-shared"
)

var cachedOrgUserConfig *shared.OrgUserConfig

func MustGetOrgUserConfig() *shared.OrgUserConfig {
	if cachedOrgUserConfig != nil {
		return cachedOrgUserConfig
	}

	orgUserConfig, err := api.Client.GetOrgUserConfig()
	if err != nil {
		term.OutputErrorAndExit("Error getting org user config: %v", err)
	}
	cachedOrgUserConfig = orgUserConfig
	return orgUserConfig
}

func MustUpdateOrgUserConfig(orgUserConfig shared.OrgUserConfig) {
	err := api.Client.UpdateOrgUserConfig(orgUserConfig)
	if err != nil {
		term.OutputErrorAndExit("Error updating org user config: %v", err)
	}
	SetCachedOrgUserConfig(&orgUserConfig)
}

func SetCachedOrgUserConfig(orgUserConfig *shared.OrgUserConfig) {
	cachedOrgUserConfig = orgUserConfig
}


================================================
FILE: app/cli/lib/plan_config.go
================================================
package lib

import (
	"os"
	"plandex-cli/api"
	"plandex-cli/term"
	"sort"

	shared "plandex-shared"

	"github.com/olekukonko/tablewriter"
)

var cachedPlanConfig *shared.PlanConfig

func MustGetCurrentPlanConfig() *shared.PlanConfig {
	if cachedPlanConfig != nil {
		return cachedPlanConfig
	}

	planConfig, apiErr := api.Client.GetPlanConfig(CurrentPlanId)
	if apiErr != nil {
		term.OutputErrorAndExit("Error getting plan config: %v", apiErr)
	}
	cachedPlanConfig = planConfig
	return planConfig
}

func SetCachedPlanConfig(planConfig *shared.PlanConfig) {
	cachedPlanConfig = planConfig
}

func ShowPlanConfig(config *shared.PlanConfig, key string) {
	table := tablewriter.NewWriter(os.Stdout)
	table.SetAutoWrapText(true)
	table.SetHeader([]string{"Name", "Value", "Description"})

	numVisibleSettings := 0
	for k, setting := range shared.ConfigSettingsByKey {
		if key != "" && k != key {
			continue
		}

		if setting.Visible == nil || setting.Visible(config) {
			numVisibleSettings++
		}
	}
	numOutput := 0

	sortedSettings := make([][]string, 0, len(shared.ConfigSettingsByKey))

	for k, setting := range shared.ConfigSettingsByKey {
		if key != "" && k != key {
			continue
		}

		if setting.Visible == nil || setting.Visible(config) {
			var sortKey string
			if setting.SortKey != "" {
				sortKey = setting.SortKey
			} else {
				sortKey = k
			}
			sortedSettings = append(sortedSettings, []string{sortKey, setting.Name, setting.Getter(config), setting.Desc})
		}
	}

	sort.Slice(sortedSettings, func(i, j int) bool {
		return sortedSettings[i][0] < sortedSettings[j][0]
	})

	for _, row := range sortedSettings {
		table.Append(row[1:])
		numOutput++
		if numOutput < numVisibleSettings {
			table.Append([]string{"", "", ""})
		}
	}

	table.Render()
}


================================================
FILE: app/cli/lib/plans.go
================================================
package lib

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/types"
	"sync"
)

func WriteCurrentPlan(id string) error {
	if fs.HomePlandexDir == "" {
		return fmt.Errorf("HomePlandexDir not set")
	}

	if CurrentProjectId == "" || HomeCurrentPlanPath == "" {
		return fmt.Errorf("no current project")
	}

	var currentPlanSettingsByAccount *types.CurrentPlanSettingsByAccount

	bytes, err := os.ReadFile(HomeCurrentPlanPath)
	if err == nil {
		err = json.Unmarshal(bytes, &currentPlanSettingsByAccount)
		if err != nil {
			return fmt.Errorf("error unmarshalling current-plans-v2.json: %v", err)
		}
	} else if !os.IsNotExist(err) {
		return fmt.Errorf("error checking if current-plans-v2.json exists: %v", err)
	}

	if currentPlanSettingsByAccount == nil {
		currentPlanSettingsByAccount = &types.CurrentPlanSettingsByAccount{}
	}

	settings := types.CurrentPlanSettings{
		Id: id,
	}

	(*currentPlanSettingsByAccount)[auth.Current.UserId] = &settings

	bytes, err = json.Marshal(currentPlanSettingsByAccount)
	if err != nil {
		return fmt.Errorf("error marshalling current plan: %v", err)
	}

	err = os.WriteFile(HomeCurrentPlanPath, bytes, 0644)
	if err != nil {
		return fmt.Errorf("error writing current plan: %v", err)
	}

	CurrentPlanId = id

	return nil
}

func ClearCurrentPlan() error {
	if fs.HomePlandexDir == "" {
		return fmt.Errorf("HomePlandexDir not set")
	}

	if CurrentProjectId == "" || HomeCurrentPlanPath == "" {
		return fmt.Errorf("no current project")
	}

	var currentPlanSettingsByAccount *types.CurrentPlanSettingsByAccount

	bytes, err := os.ReadFile(HomeCurrentPlanPath)
	if err == nil {
		err = json.Unmarshal(bytes, &currentPlanSettingsByAccount)
		if err != nil {
			return fmt.Errorf("error unmarshalling current-plans-v2.json: %v", err)
		}
	} else if !os.IsNotExist(err) {
		return fmt.Errorf("error checking if current-plans-v2.json exists: %v", err)
	}

	if currentPlanSettingsByAccount != nil {
		delete(*currentPlanSettingsByAccount, auth.Current.UserId)
	}

	bytes, err = json.Marshal(currentPlanSettingsByAccount)
	if err != nil {
		return fmt.Errorf("error marshalling current plan: %v", err)
	}

	err = os.WriteFile(HomeCurrentPlanPath, bytes, 0644)
	if err != nil {
		return fmt.Errorf("error writing current plan: %v", err)
	}

	CurrentPlanId = ""

	return nil
}

func WriteCurrentBranch(branch string) error {
	if fs.HomePlandexDir == "" {
		return fmt.Errorf("HomePlandexDir not set")
	}

	if CurrentProjectId == "" || HomeCurrentPlanPath == "" {
		return fmt.Errorf("no current project")
	}

	if CurrentPlanId == "" {
		return fmt.Errorf("no current plan")
	}

	dir := filepath.Join(fs.HomePlandexDir, CurrentProjectId, CurrentPlanId)

	err := os.MkdirAll(dir, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error creating plan dir: %v", err)
	}

	path := filepath.Join(dir, "settings-v2.json")

	var settingsByAccount *types.PlanSettingsByAccount

	bytes, err := os.ReadFile(path)
	if err == nil {
		err = json.Unmarshal(bytes, &settingsByAccount)
		if err != nil {
			return fmt.Errorf("error unmarshalling settings-v2.json: %v", err)
		}
	} else if !os.IsNotExist(err) {
		return fmt.Errorf("error checking if settings-v2.json exists: %v", err)
	}

	if settingsByAccount == nil {
		settingsByAccount = &types.PlanSettingsByAccount{}
	}

	existingSettings := (*settingsByAccount)[auth.Current.UserId]

	if existingSettings == nil {
		existingSettings = &types.PlanSettings{}
	}

	existingSettings.Branch = branch
	(*settingsByAccount)[auth.Current.UserId] = existingSettings

	bytes, err = json.Marshal(settingsByAccount)
	if err != nil {
		return fmt.Errorf("error marshalling current plan settings: %v", err)
	}

	err = os.WriteFile(path, bytes, 0644)

	if err != nil {
		return fmt.Errorf("error writing current plan settings: %v", err)
	}

	CurrentBranch = branch

	return nil
}

func GetCurrentBranchNamesByPlanId(planIds []string) (map[string]string, error) {
	if fs.HomePlandexDir == "" {
		return nil, fmt.Errorf("HomePlandexDir not set")
	}

	if CurrentProjectId == "" || HomeCurrentPlanPath == "" {
		return nil, fmt.Errorf("no current project")
	}

	var mu sync.Mutex
	branches := make(map[string]string)
	errCh := make(chan error, len(planIds))
	for _, planId := range planIds {
		go func(planId string) {
			branch, err := getPlanCurrentBranch(planId)
			if err != nil {
				errCh <- fmt.Errorf("error getting plan current branch: %v", err)
			} else {
				mu.Lock()
				defer mu.Unlock()
				branches[planId] = branch
				errCh <- nil
			}
		}(planId)
	}

	for i := 0; i < len(planIds); i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	return branches, nil
}

func getPlanCurrentBranch(planId string) (string, error) {
	if fs.HomePlandexDir == "" {
		return "", fmt.Errorf("HomePlandexDir not set")
	}

	if CurrentProjectId == "" || HomeCurrentPlanPath == "" {
		return "", fmt.Errorf("no current project")
	}

	v2Path := filepath.Join(fs.HomePlandexDir, CurrentProjectId, planId, "settings-v2.json")

	var settings *types.PlanSettings

	// check if settings-v2.json exists
	_, err := os.Stat(v2Path)
	if err == nil {
		// read settings-v2.json
		var settingsByAccount types.PlanSettingsByAccount
		bytes, err := os.ReadFile(v2Path)
		if err != nil {
			return "", fmt.Errorf("error reading settings-v2.json: %v", err)
		}
		err = json.Unmarshal(bytes, &settingsByAccount)
		if err != nil {
			return "", fmt.Errorf("error unmarshalling settings-v2.json: %v", err)
		}

		settings = settingsByAccount[auth.Current.UserId]
	} else if os.IsNotExist(err) {
		return "main", nil
	} else {
		return "", fmt.Errorf("error checking if settings-v2.json exists: %v", err)
	}

	if settings == nil {
		return "main", nil
	}

	return settings.Branch, nil
}


================================================
FILE: app/cli/lib/repl.go
================================================
package lib

import (
	"encoding/json"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"plandex-cli/fs"
	"plandex-cli/term"
	"strconv"
	"syscall"
)

var ReplSettingsDir string

type ReplMode string

const (
	ReplModeTell ReplMode = "tell"
	ReplModeChat ReplMode = "chat"
)

type ReplState struct {
	Mode    ReplMode
	IsMulti bool
}

var CurrentReplState = ReplState{
	Mode:    ReplModeChat,
	IsMulti: false,
}

type ReplSettings struct {
	State   ReplState
	History []string
}

var ReplCmdAliases = map[string]string{
	"chat":  "ch",
	"tell":  "t",
	"multi": "m",
	"quit":  "q",
	"help":  "h",
	"run":   "r",
	"send":  "s",
}

func init() {
	ReplSettingsDir = filepath.Join(fs.HomePlandexDir, "repl_settings")
}

func EnsureReplSettingsFile() {
	if err := os.MkdirAll(ReplSettingsDir, os.ModePerm); err != nil {
		term.OutputErrorAndExit("Error creating repl history directory: %v", err)
	}

	settingsFile := filepath.Join(ReplSettingsDir, CurrentProjectId+".json")
	if _, err := os.Stat(settingsFile); os.IsNotExist(err) {
		file, err := os.Create(settingsFile)
		if err != nil {
			term.OutputErrorAndExit("Error creating history file: %v", err)
		}
		defer file.Close()

		// Write empty settings object
		var settings ReplSettings

		data, err := json.Marshal(settings)
		if err != nil {
			term.OutputErrorAndExit("Error converting settings to JSON: %v", err)
		}

		if _, err := file.Write(data); err != nil {
			term.OutputErrorAndExit("Error writing to history file: %v", err)
		}
	}
}

func writeSettings(settings *ReplSettings) {
	settingsFile := filepath.Join(ReplSettingsDir, CurrentProjectId+".json")
	data, err := json.Marshal(settings)
	if err != nil {
		term.OutputErrorAndExit("Error converting settings to JSON: %v", err)
	}

	if err := os.WriteFile(settingsFile, data, 0644); err != nil {
		term.OutputErrorAndExit("Error writing settings file: %v", err)
	}
}

func getSettings() *ReplSettings {
	EnsureReplSettingsFile()

	settingsFile := filepath.Join(ReplSettingsDir, CurrentProjectId+".json")

	// Read existing settings
	data, err := os.ReadFile(settingsFile)
	if err != nil {
		term.OutputErrorAndExit("Error reading history file: %v", err)
	}

	// Parse JSON
	var settings ReplSettings
	if err := json.Unmarshal(data, &settings); err != nil {
		term.OutputErrorAndExit("Error parsing history file: %v", err)
	}

	return &settings
}

func LoadState() {
	settings := getSettings()

	if settings.State.Mode != "" {
		CurrentReplState = settings.State
	} else {
		// Write default state
		WriteState()
	}
}

func WriteState() {
	settings := getSettings()
	settings.State = CurrentReplState
	writeSettings(settings)
}

func WriteHistory(input string) {
	settings := getSettings()
	// Add new input
	settings.History = append(settings.History, input)
	writeSettings(settings)
}

func GetHistory() []string {
	settings := getSettings()
	return settings.History
}

// ExecPlandexCommand spawns the same binary, wiring std streams directly so you
// don't have to capture output. Any os.Exit calls in the child won't kill your REPL.
func ExecPlandexCommand(args []string) (string, error) {
	return ExecPlandexCommandWithParams(args, ExecPlandexCommandParams{})
}

type ExecPlandexCommandParams struct {
	DisableSuggestions bool
	SessionId          string
}

func ExecPlandexCommandWithParams(args []string, params ExecPlandexCommandParams) (string, error) {
	// Create temp file
	tmpFile, err := os.CreateTemp("", "plandex-output-*")
	if err != nil {
		return "", err
	}
	tmpPath := tmpFile.Name()
	tmpFile.Close()
	defer os.Remove(tmpPath)

	var env []string = os.Environ()
	if os.Getenv("PLANDEX_REPL") == "" {
		columns := term.GetTerminalWidth()
		hasDarkBackground := term.HasDarkBackground()
		streamForegroundColor := term.GetStreamForegroundColor()

		var glamourStyle string
		if hasDarkBackground {
			glamourStyle = "dark"
		} else {
			glamourStyle = "light"
		}

		// Set env vars
		env = append(env,
			"PLANDEX_REPL=1",
			"PLANDEX_REPL_OUTPUT_FILE="+tmpPath,
			"PLANDEX_COLUMNS="+strconv.Itoa(columns),
			"PLANDEX_STREAM_FOREGROUND_COLOR="+streamForegroundColor.Sequence(false),
			"GLAMOUR_STYLE="+glamourStyle,
			"PLANDEX_SKIP_UPGRADE=1",
		)

		if params.SessionId != "" {
			env = append(env, "PLANDEX_REPL_SESSION_ID="+params.SessionId)
		}
	}

	if params.DisableSuggestions {
		env = append(env, "PLANDEX_DISABLE_SUGGESTIONS=1")
	}

	// Run command
	cmd := exec.Command(os.Args[0], args...)
	cmd.Env = env

	// Connect stdin directly
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	err = cmd.Start()
	if err != nil {
		return "", err
	}

	signal.Ignore(syscall.SIGINT)
	defer signal.Reset(syscall.SIGINT)

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

	go func() {
		sig := <-sigChan
		syscall.Kill(-cmd.Process.Pid, sig.(syscall.Signal))
	}()

	err = cmd.Wait()
	if err != nil {
		if _, ok := err.(*exec.ExitError); ok {
			return "", nil
		}
		return "", err
	}

	// Read output from temp file
	output, err := os.ReadFile(tmpPath)
	if err != nil {
		return "", err
	}

	return string(output), nil
}


================================================
FILE: app/cli/lib/rewind.go
================================================
package lib

import (
	"fmt"
	"os"
	"path/filepath"
	"plandex-cli/fs"
	shared "plandex-shared"
	"sort"
	"sync"
	"time"
)

// GetUndonePlanApplies returns the list of PlanApplies that will be undone by rewinding to targetSHA.
// An apply is considered "undone" if its timestamp is after OR equal to the target SHA's timestamp,
// since we want to revert to the state before the target SHA.
func GetUndonePlanApplies(currentState *shared.CurrentPlanState, timestamp time.Time) []*shared.PlanApply {
	if currentState == nil {
		return nil
	}

	var undoneApplies []*shared.PlanApply
	for _, apply := range currentState.PlanApplies {
		// Include applies after OR equal to target time
		if !apply.CreatedAt.Before(timestamp) {
			undoneApplies = append(undoneApplies, apply)
		}
	}

	// Sort by creation time ascending to ensure proper order
	sort.Slice(undoneApplies, func(i, j int) bool {
		return undoneApplies[i].CreatedAt.Before(undoneApplies[j].CreatedAt)
	})

	return undoneApplies
}

// GetAffectedFilePaths extracts the set of file paths that were modified by the given PlanApplies.
// It looks up each PlanFileResultId in the current state to get the actual file paths.
func GetAffectedFilePaths(currentState *shared.CurrentPlanState, applies []*shared.PlanApply) map[string]bool {
	if currentState == nil || currentState.PlanResult == nil {
		return nil
	}

	// First collect all file result IDs
	fileResultIds := make(map[string]bool)
	for _, apply := range applies {
		if apply == nil {
			continue
		}
		for _, fileId := range apply.PlanFileResultIds {
			if fileId != "" {
				fileResultIds[fileId] = true
			}
		}
	}

	// Then get the actual file paths from the plan result
	affectedPaths := make(map[string]bool)
	for _, result := range currentState.PlanResult.Results {
		if result == nil {
			continue
		}

		// Skip if this result wasn't part of an undone apply
		if !fileResultIds[result.Id] {
			continue
		}

		// Skip if the result was rejected
		if result.RejectedAt != nil {
			continue
		}

		// Skip if the result was never applied
		if result.AppliedAt == nil {
			continue
		}

		// Validate path
		if result.Path == "" {
			continue
		}

		// Check if path is in plan context
		if currentState.ContextsByPath[result.Path] == nil {
			continue
		}

		affectedPaths[result.Path] = true
	}

	return affectedPaths
}

// RewindAnalysis captures all the information about a potential rewind operation
type RewindAnalysis struct {
	// Files that need to be modified when rewinding from current plan state to target plan state
	RequiredChanges map[string]string
	// Files that have been modified on disk relative to current plan state (potential conflicts)
	Conflicts map[string]bool
}

// AnalyzeRewind examines the three states (disk, current plan, target plan) to determine:
// 1. What files need to be changed to reach target state
// 2. Which of those changes would conflict with user modifications
func AnalyzeRewind(targetState, currentState *shared.CurrentPlanState) (*RewindAnalysis, error) {
	if targetState == nil || currentState == nil {
		return nil, fmt.Errorf("both target and current states must be provided")
	}

	// First determine what files need to be changed between current and target plan states
	requiredChanges := make(map[string]string)

	// Track all paths we need to examine for either changes or conflicts
	allPaths := make(map[string]bool)

	// Add paths from both states
	for path, context := range targetState.ContextsByPath {
		if context.ContextType != shared.ContextFileType {
			continue
		}
		allPaths[path] = true
	}
	for path, context := range currentState.ContextsByPath {
		if context.ContextType != shared.ContextFileType {
			continue
		}
		allPaths[path] = true
	}

	// For each path, check if content differs between current and target states
	for path := range allPaths {
		targetContent := ""
		if ctx := targetState.ContextsByPath[path]; ctx != nil {
			targetContent = ctx.Body
		}

		currentContent := ""
		if ctx := currentState.ContextsByPath[path]; ctx != nil {
			currentContent = ctx.Body
		}

		// If content differs between plan states, this is a required change
		if targetContent != currentContent {
			if targetContent == "" {
				// File should be removed
				requiredChanges[path] = ""
			} else {
				// File should be added or modified
				requiredChanges[path] = targetContent
			}
		}
	}

	// Now check for conflicts by comparing disk state with current plan state
	// A conflict exists if a file that needs to be changed has been modified on disk
	conflicts := make(map[string]bool)

	var mu sync.Mutex
	errCh := make(chan error, len(requiredChanges))

	for path := range requiredChanges {
		go func(path string) {
			var outErr error
			defer func() { errCh <- outErr }()

			// Get the content from current plan state
			currentContent := ""
			if ctx := currentState.ContextsByPath[path]; ctx != nil {
				currentContent = ctx.Body
			}

			// Get the actual file content from disk
			dstPath := filepath.Join(fs.ProjectRoot, path)
			diskContent, err := os.ReadFile(dstPath)
			if err != nil {
				if os.IsNotExist(err) {
					// If file doesn't exist on disk and current state has no content,
					// there's no conflict
					if currentContent == "" {
						return
					}
					// Otherwise it's a conflict because file was deleted
					mu.Lock()
					conflicts[path] = true
					mu.Unlock()
					return
				}
				outErr = fmt.Errorf("failed to read %s: %w", path, err)
				return
			}

			// If disk content differs from current plan state, we have a conflict
			if string(diskContent) != currentContent {
				mu.Lock()
				conflicts[path] = true
				mu.Unlock()
			}
		}(path)
	}

	// Collect any errors from goroutines
	for i := 0; i < len(requiredChanges); i++ {
		if err := <-errCh; err != nil {
			return nil, err
		}
	}

	return &RewindAnalysis{
		RequiredChanges: requiredChanges,
		Conflicts:       conflicts,
	}, nil
}

// RemoveEmptyDirs recursively removes empty directories starting from the given path
func RemoveEmptyDirs(path string, baseDir string) error {
	// Check if the path is a directory
	info, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}
	if !info.IsDir() {
		return nil
	}

	// List directory contents
	entries, err := os.ReadDir(path)
	if err != nil {
		return err
	}

	// If directory has contents, leave it alone
	if len(entries) > 0 {
		return nil
	}

	// Directory is empty, remove it if it's not the base dir
	if path != baseDir {
		if err := os.Remove(path); err != nil {
			return err
		}
	}

	// Recursively check parent directory
	parent := filepath.Dir(path)
	if parent != baseDir && parent != path {
		return RemoveEmptyDirs(parent, baseDir)
	}

	return nil
}

// ApplyRewindChanges updates files on disk to match target state
func ApplyRewindChanges(requiredChanges map[string]string) error {
	if len(requiredChanges) == 0 {
		return nil
	}

	// Track directories that might need cleanup
	dirsToCheck := make(map[string]bool)
	var mu sync.Mutex

	errCh := make(chan error, len(requiredChanges))

	for path, content := range requiredChanges {
		go func(path, content string) {
			dstPath := filepath.Join(fs.ProjectRoot, path)

			if content == "" {
				// Remove the file
				err := os.Remove(dstPath)
				if err != nil && !os.IsNotExist(err) {
					errCh <- fmt.Errorf("failed to remove %s: %w", path, err)
					return
				}
				// Mark parent directory for cleanup
				parentDir := filepath.Dir(dstPath)
				mu.Lock()
				dirsToCheck[parentDir] = true
				mu.Unlock()
				errCh <- nil
				return
			}

			// Ensure directory exists
			if err := os.MkdirAll(filepath.Dir(dstPath), 0755); err != nil {
				errCh <- fmt.Errorf("failed to create directory for %s: %w", path, err)
				return
			}

			// Write the file
			if err := os.WriteFile(dstPath, []byte(content), 0644); err != nil {
				errCh <- fmt.Errorf("failed to write %s: %w", path, err)
				return
			}

			errCh <- nil
		}(path, content)
	}

	// Collect any errors
	for i := 0; i < len(requiredChanges); i++ {
		if err := <-errCh; err != nil {
			return err
		}
	}

	// Clean up empty directories
	for dir := range dirsToCheck {
		if err := RemoveEmptyDirs(dir, fs.ProjectRoot); err != nil {
			// Log but don't fail the operation for directory cleanup errors
			fmt.Printf("Warning: failed to clean up directory %s: %v\n", dir, err)
		}
	}

	return nil
}


================================================
FILE: app/cli/main.go
================================================
package main

import (
	"log"
	"os"
	"path/filepath"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/cmd"
	"plandex-cli/fs"
	"plandex-cli/lib"
	"plandex-cli/plan_exec"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/ui"

	shared "plandex-shared"

	"gopkg.in/natefinch/lumberjack.v2"
)

func init() {
	// inter-package dependency injections to avoid circular imports
	auth.SetApiClient(api.Client)

	auth.SetOpenUnauthenticatedCloudURLFn(ui.OpenUnauthenticatedCloudURL)
	auth.SetOpenAuthenticatedURLFn(ui.OpenAuthenticatedURL)

	term.SetOpenAuthenticatedURLFn(ui.OpenAuthenticatedURL)
	term.SetOpenUnauthenticatedCloudURLFn(ui.OpenUnauthenticatedCloudURL)
	term.SetConvertTrialFn(auth.ConvertTrial)

	plan_exec.SetPromptSyncModelsIfNeeded(lib.PromptSyncModelsIfNeeded)

	lib.SetBuildPlanInlineFn(func(autoConfirm bool, maybeContexts []*shared.Context) (bool, error) {
		authVars := lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode)
		return plan_exec.Build(plan_exec.ExecParams{
			CurrentPlanId: lib.CurrentPlanId,
			CurrentBranch: lib.CurrentBranch,
			AuthVars:      authVars,
			CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
				return lib.CheckOutdatedContextWithOutput(true, autoConfirm, maybeContexts, projectPaths)
			},
		}, types.BuildFlags{})
	})

	// set up a rotating file logger
	logger := &lumberjack.Logger{
		Filename:   filepath.Join(fs.HomePlandexDir, "plandex.log"),
		MaxSize:    10,   // megabytes before rotation
		MaxBackups: 3,    // number of backups to keep
		MaxAge:     28,   // days to keep old logs
		Compress:   true, // compress rotated files
	}

	// Set the output of the logger
	log.SetOutput(logger)
	log.SetFlags(log.LstdFlags | log.Lmicroseconds | log.Lshortfile)

	// log.Println("Starting Plandex - logging initialized")
}

func main() {
	// Manually check for help flags at the root level
	if len(os.Args) == 2 && (os.Args[1] == "-h" || os.Args[1] == "--help") {
		// Display your custom help here
		term.PrintCustomHelp(true)
		os.Exit(0)
	}

	var firstArg string
	if len(os.Args) > 1 {
		firstArg = os.Args[1]
	}

	if firstArg != "version" && firstArg != "browser" && firstArg != "help" && firstArg != "h" {
		checkForUpgrade()
	}

	cmd.Execute()
}


================================================
FILE: app/cli/nodemon.json
================================================
{
  "watch": [
    ".",
    "../shared"
  ],
  "ext": "go,mod,sum",
  "exec": "./dev.sh"
}

================================================
FILE: app/cli/plan.json
================================================
{
  "name": "draft",
  "proposalId": "",
  "rootId": "",
  "createdAt": "2023-11-04T09:44:29.147Z",
  "updatedAt": "2023-11-04T09:44:29.147Z",
  "description": null,
  "contextTokens": 0,
  "convoTokens": 0,
  "convoSummarizedTokens": 0
}

================================================
FILE: app/cli/plan_exec/action_menu.go
================================================
package plan_exec

import (
	"fmt"
	"os"
	"plandex-cli/api"
	"plandex-cli/lib"
	"plandex-cli/term"
	shared "plandex-shared"
	"strings"

	"github.com/eiannone/keyboard"
	"github.com/fatih/color"
	"github.com/olekukonko/tablewriter"
)

type hotkeyOption struct {
	char            string
	key             keyboard.Key
	command         string
	description     string
	replOnly        bool
	terminalOnly    bool
	dropdownOnly    bool
	applyScriptOnly bool
}

var allHotkeyOptions = []hotkeyOption{
	{
		char:         "d",
		command:      "diff ui",
		description:  "Review diffs in browser UI",
		replOnly:     false,
		terminalOnly: false,
	},
	{
		char:         "g",
		command:      "git diff format",
		description:  "Review diffs in git diff format",
		replOnly:     false,
		terminalOnly: false,
	},
	{
		char:         "r",
		command:      "reject",
		description:  "Reject some or all pending changes",
		replOnly:     false,
		terminalOnly: false,
	},

	{
		char:         "a",
		command:      "apply",
		description:  "Apply all pending changes",
		replOnly:     false,
		terminalOnly: false,
	},

	{
		char:            "f",
		command:         "full auto",
		description:     "Apply and debug in full auto mode",
		replOnly:        true,
		terminalOnly:    false,
		applyScriptOnly: true,
	},

	{
		char:         "q",
		key:          keyboard.KeyEnter,
		command:      "exit menu",
		description:  "Exit menu",
		dropdownOnly: true,
	},
}

func showHotkeyMenu(diffs []string) {
	hasApplyScript := false
	for _, diff := range diffs {
		if diff == "_apply.sh" {
			hasApplyScript = true
			break
		}
	}

	numDiffs := len(diffs)
	if hasApplyScript {
		numDiffs--
	}

	if numDiffs > 0 {
		s := "files have"
		if numDiffs == 1 {
			s = "file has"
		}
		color.New(color.Bold, term.ColorHiGreen).Printf("🧐 %d %s pending changes\n", numDiffs, s)

		for _, diff := range diffs {
			if diff == "_apply.sh" {
				continue
			}

			fmt.Printf("• 📄 %s\n", diff)
		}
		fmt.Println()
	}

	if hasApplyScript {
		color.New(color.Bold, term.ColorHiYellow).Println("🚀 Commands pending")
		fmt.Println()
	}

	var b strings.Builder
	table := tablewriter.NewWriter(&b)
	table.SetAutoWrapText(false)
	table.SetHeaderLine(false)
	table.SetAlignment(tablewriter.ALIGN_LEFT)

	for _, opt := range allHotkeyOptions {
		if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) || opt.dropdownOnly || (opt.applyScriptOnly && !hasApplyScript) {
			continue
		}

		c := color.New(term.ColorHiCyan, color.Bold)
		if opt.command == "apply" {
			c = color.New(term.ColorHiGreen, color.Bold)
		} else if opt.command == "reject" {
			c = color.New(term.ColorHiRed, color.Bold)
		} else if opt.command == "full auto" {
			c = color.New(term.ColorHiYellow, color.Bold)
		}

		table.Append([]string{
			c.Sprintf("(%s)", opt.char),
			opt.command,
			opt.description,
		})
	}

	table.Render()
	fmt.Print(b.String())

	fmt.Printf("%s %s %s %s %s",
		color.New(term.ColorHiMagenta, color.Bold).Sprint("Press a hotkey,"),
		color.New(color.FgHiWhite, color.Bold).Sprintf("↓"),
		color.New(term.ColorHiMagenta, color.Bold).Sprintf("to select, or"),
		color.New(color.FgHiWhite, color.Bold).Sprintf("enter"),
		color.New(term.ColorHiMagenta, color.Bold).Sprintf("to exit menu/keep iterating>"),
	)
}

func handleHotkey(diffs []string, params ExecParams) {
	char, key, err := term.GetUserKeyInput()
	if err != nil {
		fmt.Printf("\nError getting key: %v\n", err)
		showHotkeyMenu(diffs)
		handleHotkey(diffs, params)
	}

	if key == keyboard.KeyArrowDown {
		options := []string{}
		for _, opt := range allHotkeyOptions {
			if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) {
				continue
			}

			options = append(options, opt.description)
		}

		selected, err := term.SelectFromList(
			"Select an action",
			options,
		)
		if err != nil {
			fmt.Printf("\nError selecting action: %v\n", err)
			showHotkeyMenu(diffs)
			handleHotkey(diffs, params)
		}

		if selected != "" {
			var option hotkeyOption
			for _, opt := range allHotkeyOptions {
				if opt.description == selected {
					if (opt.terminalOnly && term.IsRepl) || (opt.replOnly && !term.IsRepl) {
						continue
					}

					option = opt
					break
				}
			}

			handleHotkeyOption(option, diffs, params)
		}
	}

	handleHotkeyOption(hotkeyOption{char: string(char), key: key}, diffs, params)
}

func handleHotkeyOption(option hotkeyOption, diffs []string, params ExecParams) {
	exitUnlessDiffs := func() {
		diffs, apiErr := getDiffs(params)
		if apiErr != nil {
			fmt.Printf("\nError getting plan diffs: %v\n", apiErr.Msg)
			os.Exit(0)
		}

		if len(diffs) == 0 {
			os.Exit(0)
		}

		showHotkeyMenu(diffs)
		handleHotkey(diffs, params)
	}

	fmt.Println()

	if option.char == "d" {
		fmt.Println()
		_, err := lib.ExecPlandexCommandWithParams([]string{"diffs", "--ui", "--from-tell-menu"}, lib.ExecPlandexCommandParams{
			DisableSuggestions: true,
		})
		if err != nil {
			fmt.Printf("\nError showing diffs: %v\n", err)
		}
		fmt.Println()
	} else if option.char == "g" {
		fmt.Println()
		_, err := lib.ExecPlandexCommandWithParams([]string{"diffs", "--git"}, lib.ExecPlandexCommandParams{
			DisableSuggestions: true,
		})
		if err != nil {
			fmt.Printf("\nError showing diffs: %v\n", err)
		}
		fmt.Println()
	} else if option.char == "a" {
		fmt.Print("(a)")
		fmt.Println()
		_, err := lib.ExecPlandexCommand([]string{"apply"})
		if err != nil {
			fmt.Printf("\nError applying changes: %v\n", err)
		}
		fmt.Println()
		os.Exit(0)
	} else if option.char == "r" {
		fmt.Println()
		_, err := lib.ExecPlandexCommand([]string{"reject"})
		if err != nil {
			fmt.Printf("\nError rejecting changes: %v\n", err)
		}
		fmt.Println()
		exitUnlessDiffs()
	} else if option.char == "f" {
		fmt.Print("(f)")
		fmt.Println()

		color.New(term.ColorHiYellow, color.Bold).Println("⚠️  Full auto mode allows automatic apply, execution, and multiple rounds of debugging without review.")
		fmt.Println()

		_, err := lib.ExecPlandexCommand([]string{"apply", "--full"})
		if err != nil {
			fmt.Printf("\nError applying changes: %v\n", err)
		}
		fmt.Println()
		os.Exit(0)
	} else if option.char == "q" || option.key == keyboard.KeyEnter {
		os.Exit(0)
	} else {
		fmt.Println("\nInvalid hotkey")
	}

	showHotkeyMenu(diffs)
	handleHotkey(diffs, params)
}

func getDiffs(params ExecParams) ([]string, *shared.ApiError) {
	currentPlan, apiErr := api.Client.GetCurrentPlanState(params.CurrentPlanId, params.CurrentBranch)
	if apiErr != nil {
		return nil, apiErr
	}

	return currentPlan.PlanResult.SortedPaths, nil
}


================================================
FILE: app/cli/plan_exec/apply_exec.go
================================================
package plan_exec

import (
	"fmt"
	"log"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/lib"
	"plandex-cli/term"
	"plandex-cli/types"

	shared "plandex-shared"

	"github.com/fatih/color"
)

func GetOnApplyExecFail(applyFlags types.ApplyFlags, tellFlags types.TellFlags) types.OnApplyExecFailFn {
	return getOnApplyExecFail(applyFlags, tellFlags, "")
}

func GetOnApplyExecFailWithCommand(applyFlags types.ApplyFlags, tellFlags types.TellFlags, execCommand string) types.OnApplyExecFailFn {
	return getOnApplyExecFail(applyFlags, tellFlags, execCommand)
}

func getOnApplyExecFail(applyFlags types.ApplyFlags, tellFlags types.TellFlags, execCommand string) types.OnApplyExecFailFn {
	var onExecFail types.OnApplyExecFailFn
	onExecFail = func(status int, output string, attempt int, toRollback *types.ApplyRollbackPlan, onErr types.OnErrFn, onSuccess func()) {
		var proceed bool
		resetAttempts := false

		if applyFlags.AutoDebug > 0 {
			if attempt >= applyFlags.AutoDebug {
				timesLbl := "times"
				if attempt == 1 {
					timesLbl = "time"
				}
				color.New(term.ColorHiRed, color.Bold).Printf("Commands failed %d %s.\n", attempt, timesLbl)
			} else {
				proceed = true
			}
		}

		if !proceed {
			const (
				DebugAndRetry          = "Debug and retry once"
				DebugInFullAutoMode    = "Debug in full auto mode"
				RollbackChangesAndExit = "Rollback changes and exit"
				ApplyChangesAndExit    = "Apply changes and exit"
			)
			opts := []string{
				DebugAndRetry,
				DebugInFullAutoMode,
				RollbackChangesAndExit,
				ApplyChangesAndExit,
			}

			selection, err := term.SelectFromList("What do you want to do?", opts)
			if err != nil {
				term.OutputErrorAndExit("failed to get confirmation user input: %s", err)
			}

			switch selection {
			case DebugAndRetry:
				proceed = true
			case DebugInFullAutoMode:
				proceed = true
				resetAttempts = true

				term.StartSpinner("")
				config, apiErr := api.Client.GetPlanConfig(lib.CurrentPlanId)

				if apiErr != nil {
					term.OutputErrorAndExit("failed to get plan config: %s", apiErr)
				}

				if config.AutoMode != shared.AutoModeFull {
					config.SetAutoMode(shared.AutoModeFull)
					apiErr = api.Client.UpdatePlanConfig(lib.CurrentPlanId, shared.UpdatePlanConfigRequest{
						Config: config,
					})

					if apiErr != nil {
						term.OutputErrorAndExit("failed to update plan config: %s", apiErr)
					}

					lib.SetCachedPlanConfig(config)

					applyFlags.AutoCommit = true
					applyFlags.AutoConfirm = true
					applyFlags.AutoExec = true
					applyFlags.AutoDebug = config.AutoDebugTries

					tellFlags.AutoApply = true
					tellFlags.AutoContext = true
					tellFlags.ExecEnabled = true
					tellFlags.SmartContext = true

					term.StopSpinner()
					fmt.Println()
					fmt.Println("✅ Full auto mode enabled")
					fmt.Println()
				} else {
					term.StopSpinner()
				}

			case RollbackChangesAndExit:
				if toRollback != nil {
					lib.Rollback(toRollback, true)
				}
				os.Exit(1)
			case ApplyChangesAndExit:
				onSuccess()
				return
			}
		}

		if proceed {
			if toRollback != nil && toRollback.HasChanges() {
				lib.Rollback(toRollback, true)
			}

			authVars := lib.MustVerifyAuthVarsSilent(auth.Current.IntegratedModelsMode)

			prompt := fmt.Sprintf("Execution failed with exit status %d. Output:\n\n%s\n\n--\n\n",
				status, output)

			tellFlags.IsUserContinue = false

			if execCommand != "" {
				tellFlags.IsApplyDebug = false
				tellFlags.ExecEnabled = false
				tellFlags.IsUserDebug = true
			} else {
				tellFlags.IsApplyDebug = true
				tellFlags.ExecEnabled = true
				tellFlags.IsUserDebug = false
			}

			log.Printf("Calling TellPlan for next debug attempt")

			TellPlan(ExecParams{
				CurrentPlanId: lib.CurrentPlanId,
				CurrentBranch: lib.CurrentBranch,
				AuthVars:      authVars,
				CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
					return lib.CheckOutdatedContextWithOutput(true, true, maybeContexts, projectPaths)
				},
			}, prompt, tellFlags)

			log.Printf("Applying plan after tell")

			if resetAttempts {
				attempt = 0
			}

			lib.MustApplyPlanAttempt(lib.ApplyPlanParams{
				PlanId:      lib.CurrentPlanId,
				Branch:      lib.CurrentBranch,
				ApplyFlags:  applyFlags,
				TellFlags:   tellFlags,
				OnExecFail:  onExecFail,
				ExecCommand: execCommand,
			}, attempt+1)
		}
	}

	return onExecFail
}


================================================
FILE: app/cli/plan_exec/build.go
================================================
package plan_exec

import (
	"fmt"
	"log"
	"plandex-cli/api"
	"plandex-cli/fs"
	"plandex-cli/stream"
	streamtui "plandex-cli/stream_tui"
	"plandex-cli/term"
	"plandex-cli/types"

	shared "plandex-shared"
)

func Build(params ExecParams, flags types.BuildFlags) (bool, error) {
	buildBg := flags.BuildBg

	term.StartSpinner("")

	err := PromptSyncModelsIfNeeded()
	if err != nil {
		term.OutputErrorAndExit("Error syncing models: %v", err)
	}

	term.StartSpinner("")

	contexts, apiErr := api.Client.ListContext(params.CurrentPlanId, params.CurrentBranch)

	if apiErr != nil {
		term.OutputErrorAndExit("Error getting context: %v", apiErr)
	}

	paths, err := fs.GetProjectPaths(fs.GetBaseDirForContexts(contexts))

	if err != nil {
		return false, fmt.Errorf("error getting project paths: %v", err)
	}

	anyOutdated, didUpdate, err := params.CheckOutdatedContext(contexts, paths)

	if err != nil {
		term.OutputErrorAndExit("error checking outdated context: %v", err)
	}

	if anyOutdated && !didUpdate {
		term.StopSpinner()
		log.Println("Build canceled")
		return false, nil
	}

	apiErr = api.Client.BuildPlan(params.CurrentPlanId, params.CurrentBranch, shared.BuildPlanRequest{
		ConnectStream: !buildBg,
		ProjectPaths:  paths.ActivePaths,
		AuthVars:      params.AuthVars,
	}, stream.OnStreamPlan)

	term.StopSpinner()

	if apiErr != nil {
		if apiErr.Msg == shared.NoBuildsErr {
			fmt.Println("🤷‍♂️ This plan has no pending changes to build")
			return false, nil
		}

		return false, fmt.Errorf("error building plan: %v", apiErr.Msg)
	}

	if !buildBg {
		ch := make(chan error)

		go func() {
			err := streamtui.StartStreamUI("", true, !flags.AutoApply)

			if err != nil {
				ch <- fmt.Errorf("error starting stream UI: %v", err)
				return
			}

			ch <- nil
		}()

		// Wait for the stream to finish
		err := <-ch

		if err != nil {
			return false, err
		}
	}

	return true, nil
}


================================================
FILE: app/cli/plan_exec/params.go
================================================
package plan_exec

import (
	"plandex-cli/types"
	shared "plandex-shared"
)

type ExecParams struct {
	CurrentPlanId        string
	CurrentBranch        string
	AuthVars             map[string]string
	CheckOutdatedContext func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error)
}

var PromptSyncModelsIfNeeded func() error

func SetPromptSyncModelsIfNeeded(fn func() error) {
	PromptSyncModelsIfNeeded = fn
}


================================================
FILE: app/cli/plan_exec/tell.go
================================================
package plan_exec

import (
	"fmt"
	"log"
	"os"
	"plandex-cli/api"
	"plandex-cli/auth"
	"plandex-cli/fs"
	"plandex-cli/stream"
	streamtui "plandex-cli/stream_tui"
	"plandex-cli/term"
	"plandex-cli/types"
	"plandex-cli/ui"
	"time"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/shopspring/decimal"
)

// For cloud trials in Integrated Models mode, we warn after the stream finishes when the balance is less than $1
const CloudTrialBalanceWarningThreshold = 1

func TellPlan(
	params ExecParams,
	prompt string,
	flags types.TellFlags,
) {

	tellBg := flags.TellBg
	tellStop := flags.TellStop
	tellNoBuild := flags.TellNoBuild
	isUserContinue := flags.IsUserContinue
	isDebugCmd := flags.IsUserDebug
	isChatOnly := flags.IsChatOnly
	autoContext := flags.AutoContext
	smartContext := flags.SmartContext
	execEnabled := flags.ExecEnabled
	autoApply := flags.AutoApply
	isApplyDebug := flags.IsApplyDebug
	isImplementationOfChat := flags.IsImplementationOfChat
	skipChangesMenu := flags.SkipChangesMenu
	done := make(chan struct{})

	if prompt == "" && isImplementationOfChat {
		prompt = "Go ahead with the plan based on what we've discussed so far."
	}

	outputPromptIfTell := func() {
		if isUserContinue || prompt == "" {
			return
		}

		term.StopSpinner()
		// print prompt so it isn't lost
		color.New(term.ColorHiCyan, color.Bold).Println("\nYour prompt 👇")
		fmt.Println()
		fmt.Println(prompt)
		fmt.Println()
	}

	term.StartSpinner("")

	err := PromptSyncModelsIfNeeded()
	if err != nil {
		outputPromptIfTell()
		term.OutputErrorAndExit("Error syncing models: %v", err)
	}

	term.StartSpinner("")

	contexts, apiErr := api.Client.ListContext(params.CurrentPlanId, params.CurrentBranch)

	if apiErr != nil {
		outputPromptIfTell()
		term.OutputErrorAndExit("Error getting context: %v", apiErr)
	}

	paths, err := fs.GetProjectPaths(fs.GetBaseDirForContexts(contexts))

	if err != nil {
		outputPromptIfTell()
		term.OutputErrorAndExit("Error getting project paths: %v", err)
	}

	anyOutdated, didUpdate, err := params.CheckOutdatedContext(contexts, paths)

	if err != nil {
		outputPromptIfTell()
		term.OutputErrorAndExit("Error checking outdated context: %v", err)
	}

	if anyOutdated && !didUpdate {
		term.StopSpinner()
		if isUserContinue {
			log.Println("Plan won't continue")
		} else {
			log.Println("Prompt not sent")
		}

		outputPromptIfTell()
		color.New(term.ColorHiRed, color.Bold).Println("🛑 Plan won't continue due to outdated context")

		os.Exit(0)
	}

	var fn func() bool
	fn = func() bool {

		var buildMode shared.BuildMode
		if tellNoBuild || isChatOnly {
			buildMode = shared.BuildModeNone
		} else {
			buildMode = shared.BuildModeAuto
		}

		// if isUserContinue {
		// 	term.StartSpinner("⚡️ Continuing plan...")
		// } else {
		// 	term.StartSpinner("💬 Sending prompt...")
		// }

		term.StartSpinner("")

		var osDetails string
		if execEnabled {
			osDetails = term.GetOsDetails()
		}

		isGitRepo := fs.ProjectRootIsGitRepo()

		apiErr := api.Client.TellPlan(params.CurrentPlanId, params.CurrentBranch, shared.TellPlanRequest{
			Prompt:                 prompt,
			ConnectStream:          !tellBg,
			AutoContinue:           !tellStop,
			ProjectPaths:           paths.ActivePaths,
			BuildMode:              buildMode,
			IsUserContinue:         isUserContinue,
			IsUserDebug:            isDebugCmd,
			IsChatOnly:             isChatOnly,
			AutoContext:            autoContext,
			SmartContext:           smartContext,
			ExecEnabled:            execEnabled,
			OsDetails:              osDetails,
			AuthVars:               params.AuthVars,
			IsImplementationOfChat: isImplementationOfChat,
			IsGitRepo:              isGitRepo,
			SessionId:              os.Getenv("PLANDEX_REPL_SESSION_ID"),
		}, stream.OnStreamPlan)

		term.StopSpinner()

		if apiErr != nil {
			if apiErr.Type == shared.ApiErrorTypeTrialMessagesExceeded {
				fmt.Fprintf(os.Stderr, "\n🚨 You've reached the Plandex Cloud trial limit of %d messages per plan\n", apiErr.TrialMessagesExceededError.MaxReplies)

				res, err := term.ConfirmYesNo("Upgrade now?")

				if err != nil {
					outputPromptIfTell()
					term.OutputErrorAndExit("Error prompting upgrade trial: %v", err)
				}

				if res {
					auth.ConvertTrial()
					// retry action after converting trial
					return fn()
				}

				outputPromptIfTell()
				return false
			}

			outputPromptIfTell()
			term.OutputErrorAndExit("Prompt error: %v", apiErr.Msg)
		} else if apiErr != nil && isUserContinue && apiErr.Type == shared.ApiErrorTypeContinueNoMessages {
			fmt.Println("🤷‍♂️ There's no plan yet to continue")
			fmt.Println()
			term.PrintCmds("", "tell")
			os.Exit(0)
		}

		if !tellBg {
			go func() {
				err := streamtui.StartStreamUI(
					prompt,
					false,
					!(autoApply || autoContext || isApplyDebug || isDebugCmd),
				)

				if err != nil {
					outputPromptIfTell()
					term.OutputErrorAndExit("Error starting stream UI: %v", err)
				}

				if auth.Current.IsCloud && auth.Current.IntegratedModelsMode && auth.Current.OrgIsTrial {
					term.StartSpinner("")
					balance, apiErr := api.Client.GetBalance()
					term.StopSpinner()
					if apiErr != nil {
						term.OutputErrorAndExit("Error getting balance: %v", apiErr.Msg)
						return
					}

					if balance.LessThan(decimal.NewFromInt(CloudTrialBalanceWarningThreshold)) {
						color.New(term.ColorHiYellow, color.Bold).Printf("\n⚠️  Your Plandex Cloud trial has $%s in credits remaining\n\n", balance.StringFixed(2))

						const continueOpt = "Continue"
						const billingSettingsOpt = "Go to billing settings (then continue)"

						opts := []string{continueOpt, billingSettingsOpt}
						choice, err := term.SelectFromList("What do you want to do?", opts)
						if err != nil {
							term.OutputErrorAndExit("Error selecting option: %v", err)
						}

						if choice == billingSettingsOpt {
							ui.OpenAuthenticatedURL("Opening billing settings in your browser.", "/settings/billing")
						}
					}
				}

				if isChatOnly {
					term.StopSpinner()
					if !term.IsRepl {
						term.PrintCmds("", "tell", "convo", "summary", "log")
					}
				} else if autoApply || isDebugCmd || isApplyDebug {
					term.StopSpinner()
					// do nothing, allow auto apply to run
				} else if skipChangesMenu {
					term.StopSpinner()
					// script mode, don't show menu
				} else {
					term.StartSpinner("")
					// sleep a little to prevent lock contention on server
					time.Sleep(500 * time.Millisecond)
					diffs, apiErr := getDiffs(params)
					term.StopSpinner()
					if apiErr != nil {
						term.OutputErrorAndExit("Error getting plan diffs: %v", apiErr.Msg)
						return
					}
					numDiffs := len(diffs)
					hasDiffs := numDiffs > 0

					fmt.Println()

					if tellStop && hasDiffs {
						if hasDiffs {
							// term.PrintCmds("", "continue", "diff", "diff --ui", "apply", "reject", "log")
							showHotkeyMenu(diffs)
							handleHotkey(diffs, params)
						} else {
							term.PrintCmds("", "continue", "log")
						}
					} else if hasDiffs {
						// term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
						showHotkeyMenu(diffs)
						handleHotkey(diffs, params)
					}
				}
				close(done)

			}()
		}

		return true
	}

	shouldContinue := fn()
	if !shouldContinue {
		return
	}

	if tellBg {
		outputPromptIfTell()
		fmt.Println("✅ Plan is active in the background")
		fmt.Println()
		term.PrintCmds("", "ps", "connect", "stop")
	} else {
		<-done
	}
}


================================================
FILE: app/cli/schema/json-schemas/definitions/auto-modes.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/definitions/auto-modes.schema.json",
  "title": "Auto Mode Enum",
  "description": "Reusable enum for auto modes",
  "enum": [
    "full",
    "semi",
    "plus",
    "basic",
    "none",
    "custom"
  ]
}

================================================
FILE: app/cli/schema/json-schemas/definitions/local-providers.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/definitions/local-providers.schema.json",
  "title": "Local Provider Enum",
  "description": "Reusable enum for local providers",
  "enum": [
    "ollama"
  ]
}

================================================
FILE: app/cli/schema/json-schemas/definitions/model-providers.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/definitions/model-providers.schema.json",
  "title": "Model Providers",
  "description": "The built-in model providers that Plandex supports. Use 'custom' for a provider that is not built-in.",
  "enum": [
    "openrouter",
    "openai",
    "anthropic",
    "google-ai-studio",
    "google-vertex",
    "azure-openai",
    "deepseek",
    "perplexity",
    "custom"
  ]
}

================================================
FILE: app/cli/schema/json-schemas/model-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-config.schema.json",
  "title": "Model Config",
  "description": "Config for a model",
  "type": "object",
  "properties": {
    "modelId": {
      "type": "string",
      "description": "Unique identifier for the model on the Plandex side.\n\nIt's distinct from the 'modelName', which is associated with a specific provider. Different modelIds can be used when the same model is called with different settings. Examples: 'openai/o3-high', 'openai/o3-low', 'anthropic/claude-sonnet-4'."
    },
    "publisher": {
      "type": "string",
      "description": "The publisher of the model, e.g. 'OpenAI', 'Anthropic', 'Google', 'DeepSeek', etc.\n\nNot necessarily the same as the provider—for example, the 'google-vertex' provider serves models published by Google, but also models published by Anthropic and others."
    },
    "description": {
      "type": "string",
      "description": "A human-readable description of the model, e.g. 'OpenAI o3'."
    },
    "defaultMaxConvoTokens": {
      "type": "number",
      "description": "The default maximum number of conversation tokens that are allowed before Plandex starts using gradual summarization to shorten the conversation."
    },
    "maxTokens": {
      "type": "number",
      "description": "The maximum number of input tokens the model can be called with."
    },
    "maxOutputTokens": {
      "type": "number",
      "description": "The maximum number of output tokens the model can produce."
    },
    "reservedOutputTokens": {
      "type": "number",
      "description": "How many tokens are set aside in context for the model to use in its output.\n\nIt's more of a realistic output limit than 'maxOutputTokens', since for some models, the hard maximum 'MaxTokens' is actually equal to the input limit, which would leave no room for input. The effective input limit is 'MaxTokens' - 'ReservedOutputTokens'.\n\nFor example, OpenAI o3 models have a MaxTokens of 200k and a MaxOutputTokens of 100k. But in practice, we are very unlikely to use all the output tokens, and we want to leave more space for input. So we set ReservedOutputTokens to 40k, allowing ~25k for reasoning tokens, as well as ~15k for real output tokens, which is enough for most use cases. The new effective input limit is therefore 200k - 40k = 160k.\n\nNote that these are not passed through as hard limits. So if we have a smaller amount of input (under 100k) the model could still use up to the full 100k output tokens if necessary."
    },
    "preferredOutputFormat": {
      "type": "string",
      "description": "The preferred output format for the model—currently either 'xml' or 'tool-call-json'.\n\nOpenAI models like JSON (and benefit from strict JSON schemas), while most other providers are unreliable for JSON generation and do better with XML, even when they claim to support JSON.",
      "enum": [
        "xml",
        "tool-call-json"
      ]
    },
    "systemPromptDisabled": {
      "type": "boolean",
      "description": "Whether the model's system prompt is disabled. This is used to disable the system prompt for the model. Some OpenAI models, for example, don't allow system prompts."
    },
    "roleParamsDisabled": {
      "type": "boolean",
      "description": "Whether the model's role-based parameters (mainly temperature and topP) are disabled. Some OpenAI models, for example, don't allow changes to these parameters."
    },
    "stopDisabled": {
      "type": "boolean",
      "description": "Whether the model's 'stop token' parameter is disabled. Some OpenAI models, for example, don't allow the 'stop token' parameter. When this is true, Plandex uses its own stop token implementation."
    },
    "predictedOutputEnabled": {
      "type": "boolean",
      "description": "Whether the model's 'predicted output' parameter is enabled. This is used to enable predicted output for the model (currently only supported by OpenAI's gpt-4o). Not currently used by Plandex, but could be in the future."
    },
    "includeReasoning": {
      "type": "boolean",
      "description": "For reasoning models, whether the reasoning should be included in the output. If set to false, the reasoning will be hidden from the user."
    },
    "reasoningBudget": {
      "type": "number",
      "description": "For reasoning models, the maximum number of tokens that can be used for reasoning. This is used to limit the reasoning budget for the model.\n\nSome reasoning models use 'reasoningBudget' to control reasoning output (e.g. Anthropic Claude Sonnet 4, Google Gemini 2.5 Pro), while others use 'reasoningEffort' (e.g. OpenAI o3)."
    },
    "hasImageSupport": {
      "type": "boolean",
      "description": "Whether the model is multi-modal and supports images in context."
    },
    "reasoningEffortEnabled": {
      "type": "boolean",
      "description": "For reasoning models, whether the 'reasoningEffort' parameter is enabled. This is used in conjunction with 'reasoningEffort' to control the reasoning budget for the model.\n\nSome reasoning models use 'reasoningEffort' to control reasoning output (e.g. OpenAI o3), while others use 'reasoningBudget' (e.g. Anthropic Claude Sonnet 4, Google Gemini 2.5 Pro)."
    },
    "reasoningEffort": {
      "type": "string",
      "enum": [
        "low",
        "medium",
        "high"
      ],
      "description": "For reasoning models that use 'reasoningEffort' to control reasoning output (e.g. OpenAI o3), this is the reasoning effort to use."
    },
    "supportsCacheControl": {
      "type": "boolean",
      "description": "Whether the model supports cache control breakpoints for caching (e.g. Anthropic models). Models with implicit caching (e.g. OpenAI models) do not support this."
    },
    "singleMessageNoSystemPrompt": {
      "type": "boolean",
      "description": "Whether the model rejects a single message that is a system prompt (e.g. Anthropic models)."
    },
    "tokenEstimatePaddingPct": {
      "type": "number",
      "description": "The percentage of tokens to add to the token estimate, which uses the OpenAI tokenizer. This helps to account for other provider's tokenizers, which may be slightly different."
    },
    "providers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "provider": {
            "description": "The model provider. Use 'custom' for a provider that is not built-in.",
            "$ref": "./definitions/model-providers.schema.json"
          },
          "customProvider": {
            "type": "string",
            "description": "If the provider is 'custom', this is the name of the custom provider."
          },
          "modelName": {
            "type": "string",
            "description": "The name of the model on the provider's side. It must exactly match the model name as it appears on the provider's website or documentation."
          }
        },
        "required": [
          "provider",
          "modelName"
        ],
        "allOf": [
          {
            "if": {
              "properties": {
                "provider": {
                  "const": "custom"
                }
              }
            },
            "then": {
              "required": [
                "customProvider"
              ]
            },
            "else": {
              "not": {
                "required": [
                  "customProvider"
                ]
              }
            }
          }
        ]
      },
      "minItems": 1
    }
  },
  "required": [
    "modelId",
    "defaultMaxConvoTokens",
    "maxTokens",
    "maxOutputTokens",
    "reservedOutputTokens",
    "preferredOutputFormat",
    "providers"
  ],
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/model-pack-base-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-pack-base-config.schema.json",
  "title": "Base Model Pack Config",
  "description": "Base config for a model pack",
  "type": "object",
  "allOf": [
    {
      "$ref": "./model-pack-roles.schema.json"
    }
  ],
  "properties": {
    "$schema": {
      "type": "string"
    },
    "name": {
      "type": "string",
      "description": "The name of the model pack"
    },
    "description": {
      "type": "string",
      "description": "The human-friendly description of the model pack"
    }
  },
  "required": [
    "name",
    "description"
  ]
}

================================================
FILE: app/cli/schema/json-schemas/model-pack-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-pack-config.schema.json",
  "title": "Model Pack Config",
  "allOf": [
    {
      "$ref": "./model-pack-base-config.schema.json"
    }
  ],
  "properties": {
    "$schema": true,
    "name": true,
    "description": true,
    "localProvider": true,
    "planner": true,
    "coder": true,
    "architect": true,
    "summarizer": true,
    "builder": true,
    "wholeFileBuilder": true,
    "names": true,
    "commitMessages": true,
    "autoContinue": true
  },
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/model-pack-inline.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-pack-inline.schema.json",
  "title": "Inline Model Pack Config",
  "description": "Inline model pack config for plan model settings or default model settings",
  "allOf": [
    {
      "$ref": "./model-pack-roles.schema.json"
    }
  ],
  "properties": {
    "$schema": true,
    "name": true,
    "description": true,
    "localProvider": true,
    "planner": true,
    "coder": true,
    "architect": true,
    "summarizer": true,
    "builder": true,
    "wholeFileBuilder": true,
    "names": true,
    "commitMessages": true,
    "autoContinue": true
  },
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/model-pack-roles.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-pack-roles.schema.json",
  "title": "Model Pack Roles",
  "type": "object",
  "description": "Config for a model pack's roles",
  "definitions": {
    "roleRef": {
      "description": "Can be a string like 'openai/o3-high' or an object with model config if you want to defined role properties like temperature/topP, or fallbacks like 'largeContextFallback', 'largeOutputFallback', 'errorFallback', 'strongModel'",
      "oneOf": [
        {
          "type": "string",
          "minLength": 1
        },
        {
          "$ref": "./model-role-config.schema.json"
        }
      ]
    }
  },
  "properties": {
    "$schema": {
      "type": "string"
    },
    "localProvider": {
      "description": "The local provider for the model pack",
      "$ref": "./definitions/local-providers.schema.json"
    },
    "planner": {
      "description": "This is the 'main' role that replies to prompts and makes plans.",
      "$ref": "#/definitions/roleRef"
    },
    "coder": {
      "description": "This role writes code to implement each step of the plan made by the 'planner' role during the planning stage.\n\nInstruction-following is important for this role as it needs to follow specific formatting rules.",
      "$ref": "#/definitions/roleRef"
    },
    "architect": {
      "description": "When auto-context is enabled, this role makes a high-level plan using the project map, then determines what context to provide for the 'planner' role.",
      "$ref": "#/definitions/roleRef"
    },
    "summarizer": {
      "description": "Summarizes conversations to stay under the limit set in the model's 'defaultMaxConvoTokens'.",
      "$ref": "#/definitions/roleRef"
    },
    "builder": {
      "description": "Builds the proposed changes described by the `planner` role into pending file updates.",
      "$ref": "#/definitions/roleRef"
    },
    "wholeFileBuilder": {
      "description": "Builds the proposed changes described by the `planner` role into pending file updates by writing the entire file. Used as a fallback if more targeted edits fail.\n\nThis role is optional. It falls back to the `builder` role if not set.",
      "$ref": "#/definitions/roleRef"
    },
    "names": {
      "description": "Gives automatically-generated names to plans and context.",
      "$ref": "#/definitions/roleRef"
    },
    "commitMessages": {
      "description": "Automatically generates commit messages for a set of pending updates.",
      "$ref": "#/definitions/roleRef"
    },
    "autoContinue": {
      "description": "Determines whether a plan is finished or should automatically continue based on the previous response.",
      "$ref": "#/definitions/roleRef"
    }
  },
  "required": [
    "planner",
    "summarizer",
    "builder",
    "names",
    "commitMessages",
    "autoContinue"
  ]
}

================================================
FILE: app/cli/schema/json-schemas/model-provider-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-provider-config.schema.json",
  "title": "Model Provider Config",
  "description": "Config for a custom model provider",
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "The name of the model provider. This is used to reference the model provider in a model's 'providers' array."
    },
    "baseUrl": {
      "type": "string",
      "description": "The base URL for the model provider. This is used to construct the full URL for the model. For example, 'https://api.openai.com/v1' for OpenAI."
    },
    "skipAuth": {
      "type": "boolean",
      "default": false,
      "description": "Whether to skip authentication for the model provider. If set to true, the model provider will not require an API key or other authentication. Mainly used for local models (ollama, etc.)."
    },
    "apiKeyEnvVar": {
      "type": "string",
      "description": "The environment variable that contains the API key for the model provider. This is used to authenticate the model provider. For example, 'OPENAI_API_KEY' for OpenAI."
    },
    "extraAuthVars": {
      "type": "array",
      "description": "Extra authentication variables for the model provider. In some cases these are used for authentication in place of an API key (e.g. AWS Bedrock). In other cases, they provide additional data on top of the API key (AZURE_API_VERSION, OPENAI_ORG_ID, etc.).",
      "items": {
        "type": "object",
        "properties": {
          "var": {
            "type": "string",
            "description": "The name of the environment variable that contains the authentication variable. For example, 'OPENAI_ORG_ID' for OpenAI."
          },
          "maybeJSONFilePath": {
            "type": "boolean",
            "description": "Whether the variable can be a JSON file path. If set to true, the value can be read from a JSON file path *OR* an environment variable. For example, 'true' for Google Vertex's GOOGLE_APPLICATION_CREDENTIALS."
          },
          "required": {
            "type": "boolean",
            "description": "Whether the variable is required. If set to true, the authentication variable is required. For example, 'true' for OpenAI."
          },
          "default": {
            "type": "string"
          }
        },
        "required": [
          "var"
        ]
      },
      "minItems": 1
    }
  },
  "required": [
    "name",
    "baseUrl"
  ],
  "anyOf": [
    {
      "required": [
        "apiKeyEnvVar"
      ]
    },
    {
      "required": [
        "extraAuthVars"
      ]
    },
    {
      "required": [
        "skipAuth"
      ],
      "properties": {
        "skipAuth": {
          "const": true
        }
      }
    }
  ],
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/model-role-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/model-role-config.schema.json",
  "title": "Model Role Config",
  "description": "Config for a defined model role within a model pack",
  "type": "object",
  "definitions": {
    "roleRef": {
      "oneOf": [
        {
          "type": "string",
          "minLength": 1
        },
        {
          "$ref": "#"
        }
      ]
    }
  },
  "properties": {
    "modelId": {
      "type": "string",
      "description": "The 'modelId' of the built-in or custom model to use for this role."
    },
    "temperature": {
      "type": "number",
      "description": "The temperature to use for the model. This is used to control the randomness of the model's output. A sensible default is used by Plandex depending on the role, but you can override it here."
    },
    "topP": {
      "type": "number",
      "description": "The topP to use for the model. This is used to control the randomness of the model's output. A sensible default is used by Plandex depending on the role, but you can override it here."
    },
    "reservedOutputTokens": {
      "type": "number"
    },
    "maxConvoTokens": {
      "type": "number"
    },
    "largeContextFallback": {
      "$ref": "#/definitions/roleRef"
    },
    "largeOutputFallback": {
      "$ref": "#/definitions/roleRef"
    },
    "errorFallback": {
      "$ref": "#/definitions/roleRef"
    },
    "strongModel": {
      "$ref": "#/definitions/roleRef"
    }
  },
  "required": [
    "modelId"
  ],
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/models-input.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/models-input.schema.json",
  "title": "Models Input",
  "description": "Input schema for custom models, providers, and model packs",
  "type": "object",
  "properties": {
    "$schema": {
      "type": "string"
    },
    "models": {
      "type": "array",
      "description": "Custom models to import into Plandex. They can be referenced by 'modelId' in model packs.",
      "items": {
        "$ref": "./model-config.schema.json"
      }
    },
    "providers": {
      "type": "array",
      "description": "Custom model providers to import into Plandex. They can be referenced in a custom model's 'providers' array.",
      "items": {
        "$ref": "./model-provider-config.schema.json"
      }
    },
    "modelPacks": {
      "type": "array",
      "description": "Model packs to import into Plandex. These define which models to use for each of Plandex's roles.",
      "items": {
        "$ref": "./model-pack-config.schema.json"
      }
    }
  },
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/json-schemas/plan-config.schema.json
================================================
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://plandex.ai/schemas/plan-config.schema.json",
  "title": "Plan Config",
  "description": "Config for a plan",
  "type": "object",
  "properties": {
    "$schema": {
      "type": "string"
    },
    "autoMode": {
      "$ref": "./definitions/auto-modes.schema.json"
    }
  },
  "additionalProperties": false
}

================================================
FILE: app/cli/schema/schemas.go
================================================
package schema

import (
	"bytes"
	"embed"
	"encoding/json"
	"errors"
	"fmt"
	"path"
	"strings"

	shared "plandex-shared"

	gojsonreference "github.com/xeipuuv/gojsonreference"
	"github.com/xeipuuv/gojsonschema"
)

const scheme = "embed://"

type SchemaPath string

const (
	SchemaPathInputConfig     SchemaPath = "json-schemas/models-input.schema.json"
	SchemaPathPlanConfig      SchemaPath = "json-schemas/plan-config.schema.json"
	SchemaPathModelPackInline SchemaPath = "json-schemas/model-pack-inline.schema.json"
)

//go:embed json-schemas/*.schema.json json-schemas/definitions/*.schema.json
var schemaFS embed.FS

type embeddedSchemaLoader struct {
	source string
	fs     embed.FS
}

func ValidateModelsInputJSON(jsonData []byte) (shared.ClientModelsInput, error) {
	return validateJSON[shared.ClientModelsInput](jsonData, SchemaPathInputConfig)
}

func ValidateModelPackInlineJSON(jsonData []byte) (shared.ClientModelPackSchemaRoles, error) {
	return validateJSON[shared.ClientModelPackSchemaRoles](jsonData, SchemaPathModelPackInline)
}

func validateJSON[T any](jsonData []byte, schemaPath SchemaPath) (T, error) {
	var zero T

	// strip meta-keywords that break additionalProperties ──
	var tmp interface{}
	if err := json.Unmarshal(jsonData, &tmp); err != nil {
		return zero, fmt.Errorf("invalid json: %w", err)
	}
	if obj, ok := tmp.(map[string]interface{}); ok {
		delete(obj, "$schema") // ignore top-level $schema
		var err error
		jsonData, err = json.Marshal(obj)
		if err != nil {
			return zero, fmt.Errorf("error marshalling json: %w", err)
		}
	}

	schemaLoader := newEmbeddedSchemaLoader(schemaPath)
	documentLoader := gojsonschema.NewBytesLoader(jsonData)

	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
	if err != nil {
		return zero, err
	}
	if !result.Valid() {
		var msgs []string
		for _, d := range result.Errors() {
			msgs = append(msgs, "• "+d.String())
		}
		return zero, errors.New(strings.Join(msgs, "\n"))
	}

	var v T
	if err := json.Unmarshal(jsonData, &v); err != nil {
		return zero, fmt.Errorf("unmarshal error: %w", err)
	}
	return v, nil
}

func newEmbeddedSchemaLoader(source SchemaPath) *embeddedSchemaLoader {
	return &embeddedSchemaLoader{
		source: string(source),
		fs:     schemaFS,
	}
}

func (l *embeddedSchemaLoader) JsonSource() interface{} {
	return l.source
}

func (l *embeddedSchemaLoader) LoadJSON() (interface{}, error) {
	// remove both "./" and the scheme prefix
	source := strings.TrimPrefix(l.source, "./")
	source = strings.TrimPrefix(source, scheme)

	// convert absolute Plandex URLs to our embed path
	const webPrefix = "https://plandex.ai/schemas/"
	if strings.HasPrefix(source, webPrefix) {
		source = path.Join("json-schemas", strings.TrimPrefix(source, webPrefix))
	}

	if strings.HasSuffix(source, ".schema.json") {
		schemaPath := source
		// for schemas with relative path references, add the json-schemas prefix
		if !strings.HasPrefix(schemaPath, "json-schemas/") {
			schemaPath = path.Join("json-schemas", schemaPath)
		}
		data, err := l.fs.ReadFile(schemaPath)
		if err != nil {
			return nil, fmt.Errorf("error reading embedded schema %s: %v", schemaPath, err)
		}
		var v interface{}
		dec := json.NewDecoder(bytes.NewReader(data))
		dec.UseNumber() // use numbers instead of floats
		if err := dec.Decode(&v); err != nil {
			return nil, fmt.Errorf("error parsing embedded schema %s: %v", source, err)
		}
		return v, nil
	}

	var v interface{}
	dec := json.NewDecoder(bytes.NewReader([]byte(source)))
	dec.UseNumber() // use numbers instead of floats
	if err := dec.Decode(&v); err != nil {
		return nil, fmt.Errorf("error parsing schema JSON: %v", err)
	}
	return v, nil
}

func (l *embeddedSchemaLoader) JsonReference() (gojsonreference.JsonReference, error) {
	return gojsonreference.NewJsonReference(scheme + l.source)
}

type embeddedLoaderFactory struct{}

func (embeddedLoaderFactory) New(source string) gojsonschema.JSONLoader {
	source = strings.TrimPrefix(source, scheme)
	return newEmbeddedSchemaLoader(SchemaPath(source))
}

func (l *embeddedSchemaLoader) LoaderFactory() gojsonschema.JSONLoaderFactory {
	return embeddedLoaderFactory{}
}


================================================
FILE: app/cli/stream/stream.go
================================================
package stream

import (
	"log"
	"plandex-cli/api"
	"plandex-cli/lib"
	streamtui "plandex-cli/stream_tui"
	"plandex-cli/term"
	"plandex-cli/types"
	"strings"

	shared "plandex-shared"
)

var OnStreamPlan types.OnStreamPlan

func init() {
	OnStreamPlan = func(params types.OnStreamPlanParams) {
		if params.Err != nil {
			if strings.Contains(params.Err.Error(), "missing heartbeats") || strings.Contains(strings.ToLower(params.Err.Error()), "eof") {
				log.Println("Error in stream:", params.Err)
				streamtui.Send(shared.StreamMessage{
					Type: shared.StreamMessageError,
					Error: &shared.ApiError{
						Msg: "Stream error: " + params.Err.Error(),
					},
				})

				// try to reconnect
				term.StartSpinner("Reconnecting...")
				apiErr := api.Client.ConnectPlan(lib.CurrentPlanId, lib.CurrentBranch, OnStreamPlan)
				term.StopSpinner()

				if apiErr != nil {
					log.Println("Error reconnecting to stream:", apiErr)
				}
			}

			return
		}

		if params.Msg.Type == shared.StreamMessageStart {
			log.Println("Stream started")
			return
		}

		// log.Println("Stream message:")
		// log.Println(spew.Sdump(*params.Msg))

		streamtui.Send(*params.Msg)
	}
}


================================================
FILE: app/cli/stream_tui/debouncer.go
================================================
package streamtui

import (
	"sync"
	"time"
)

// UpdateDebouncer helps prevent visual glitches from rapid updates
type UpdateDebouncer struct {
	mu          sync.Mutex
	lastUpdate  time.Time
	minInterval time.Duration
	pending     bool
}

func NewUpdateDebouncer(minInterval time.Duration) *UpdateDebouncer {
	return &UpdateDebouncer{
		minInterval: minInterval,
	}
}

// ShouldUpdate returns true if enough time has passed since the last update
func (d *UpdateDebouncer) ShouldUpdate() bool {
	d.mu.Lock()
	defer d.mu.Unlock()

	now := time.Now()
	if now.Sub(d.lastUpdate) < d.minInterval {
		d.pending = true
		return false
	}

	d.lastUpdate = now
	d.pending = false
	return true
}


================================================
FILE: app/cli/stream_tui/model.go
================================================
package streamtui

import (
	"context"
	"log"
	"sync"
	"time"

	shared "plandex-shared"

	bubbleKey "github.com/charmbracelet/bubbles/key"
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/bubbles/viewport"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
)

const (
	MissingFileLoadLabel      = "Load the file into context"
	MissingFileSkipLabel      = "Skip generating this file"
	MissingFileOverwriteLabel = "Allow Plandex to overwrite this file"
)

var promptChoices = []shared.RespondMissingFileChoice{
	shared.RespondMissingFileChoiceLoad,
	shared.RespondMissingFileChoiceSkip,
	shared.RespondMissingFileChoiceOverwrite,
}

var missingFileSelectOpts = []string{
	MissingFileLoadLabel,
	MissingFileSkipLabel,
	MissingFileOverwriteLabel,
}

var stateMu sync.RWMutex

type streamUIModel struct {
	buildOnly   bool
	canSendToBg bool
	keymap      keymap

	reply       string
	mainDisplay string

	mainViewport viewport.Model

	processing   bool
	starting     bool
	spinner      spinner.Model
	buildSpinner spinner.Model
	sharedTicker *time.Ticker

	building       bool
	tokensByPath   map[string]int
	finishedByPath map[string]bool
	removedByPath  map[string]bool

	ready  bool
	width  int
	height int

	atScrollBottom bool

	promptingMissingFile   bool
	missingFilePath        string
	missingFileSelectedIdx int
	promptedMissingFile    bool
	autoLoadedMissingFile  bool
	missingFileContent     string
	missingFileTokens      int

	prompt string

	stopped    bool
	background bool
	finished   bool

	err    error
	apiErr *shared.ApiError

	updateDebouncer *UpdateDebouncer

	autoLoadContextCancelFn context.CancelFunc

	buildViewCollapsed bool
	userToggledBuild   bool
}

type keymap = struct {
	stop,
	scrollUp,
	scrollDown,
	pageUp,
	pageDown,
	start,
	end,
	up,
	down,
	quit,
	background,
	enter bubbleKey.Binding
}

func (m streamUIModel) Init() tea.Cmd {
	log.Println("Model Init start")
	m.mainViewport.MouseWheelEnabled = true
	return tea.Batch(
		m.Tick(),
		m.pollBuildStatus(),
	)
}

type buildStatusPollMsg time.Time

func (m streamUIModel) pollBuildStatus() tea.Cmd {
	return tea.Every(5*time.Second, func(t time.Time) tea.Msg {
		return buildStatusPollMsg(t)
	})
}

func initialModel(prestartReply, prompt string, buildOnly bool, canSendToBg bool) *streamUIModel {
	sharedTicker := time.NewTicker(100 * time.Millisecond)

	s := spinner.New()
	s.Spinner = spinner.Points
	s.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("205"))

	buildSpinner := spinner.New()
	buildSpinner.Spinner = spinner.MiniDot

	initialState := streamUIModel{
		buildOnly:          buildOnly,
		canSendToBg:        canSendToBg,
		buildViewCollapsed: false,
		prompt:             prompt,
		reply:              prestartReply,
		keymap: keymap{
			quit: bubbleKey.NewBinding(
				bubbleKey.WithKeys("ctrl+c"),
				bubbleKey.WithHelp("ctrl+c", "quit"),
			),

			background: bubbleKey.NewBinding(
				bubbleKey.WithKeys("b"),
				bubbleKey.WithHelp("b", "background"),
			),

			stop: bubbleKey.NewBinding(
				bubbleKey.WithKeys("s"),
				bubbleKey.WithHelp("s", "stop"),
			),

			scrollDown: bubbleKey.NewBinding(
				bubbleKey.WithKeys("j"),
				bubbleKey.WithHelp("j", "scroll down"),
			),

			scrollUp: bubbleKey.NewBinding(
				bubbleKey.WithKeys("k"),
				bubbleKey.WithHelp("k", "scroll up"),
			),

			pageDown: bubbleKey.NewBinding(
				bubbleKey.WithKeys("d", "pageDown"),
				bubbleKey.WithHelp("d", "page down"),
			),

			pageUp: bubbleKey.NewBinding(
				bubbleKey.WithKeys("u", "pageUp"),
				bubbleKey.WithHelp("u", "page up"),
			),

			up: bubbleKey.NewBinding(
				bubbleKey.WithKeys("up"),
				bubbleKey.WithHelp("up", "prev"),
			),

			down: bubbleKey.NewBinding(
				bubbleKey.WithKeys("down"),
				bubbleKey.WithHelp("down", "next"),
			),

			enter: bubbleKey.NewBinding(
				bubbleKey.WithKeys("enter"),
				bubbleKey.WithHelp("enter", "select"),
			),

			start: bubbleKey.NewBinding(
				bubbleKey.WithKeys("g", "home"),
				bubbleKey.WithHelp("g", "start"),
			),

			end: bubbleKey.NewBinding(
				bubbleKey.WithKeys("G", "end"),
				bubbleKey.WithHelp("G", "end"),
			),
		},

		tokensByPath:    make(map[string]int),
		finishedByPath:  make(map[string]bool),
		removedByPath:   make(map[string]bool),
		spinner:         s,
		buildSpinner:    buildSpinner,
		sharedTicker:    sharedTicker,
		atScrollBottom:  true,
		starting:        true,
		updateDebouncer: NewUpdateDebouncer(8 * time.Millisecond),
	}

	return &initialState
}

func (m streamUIModel) Tick() tea.Cmd {
	return func() tea.Msg {
		<-m.sharedTicker.C
		return spinner.TickMsg{}
	}
}

func (m *streamUIModel) cleanup() {
	log.Println("Cleaning up stream UI model")
	m.updateState(func() {
		m.sharedTicker.Stop()
	})
}

func (m *streamUIModel) readState() streamUIModel {
	stateMu.RLock()
	defer stateMu.RUnlock()
	return *m
}

func (m *streamUIModel) updateState(updateFn func()) {
	stateMu.Lock()
	defer stateMu.Unlock()
	updateFn()
}


================================================
FILE: app/cli/stream_tui/run.go
================================================
package streamtui

import (
	"fmt"
	"log"
	"os"
	"plandex-cli/term"
	"sync"

	shared "plandex-shared"

	tea "github.com/charmbracelet/bubbletea"
	"github.com/fatih/color"
)

var ui *tea.Program
var mu sync.Mutex
var wg sync.WaitGroup

var prestartReply string
var prestartErr *shared.ApiError
var prestartAbort bool

func StartStreamUI(prompt string, buildOnly, canSendToBg bool) error {
	if prestartErr != nil {
		log.Println("stream UI - prestart error: ", prestartErr)
		term.HandleApiError(prestartErr)
	}

	if prestartAbort {
		fmt.Println("🛑 Stopped early")
		os.Exit(0)
	}

	log.Println("Starting stream UI")

	initial := initialModel(prestartReply, prompt, buildOnly, canSendToBg)

	mu.Lock()
	ui = tea.NewProgram(initial, tea.WithAltScreen())
	mu.Unlock()

	log.Println("Running bubbletea program")
	wg.Add(1)
	m, err := ui.Run()
	log.Println("Bubbletea program finished")
	wg.Done()

	log.Println("Stream UI finished")

	if err != nil {
		return fmt.Errorf("error running stream UI: %v", err)
	}

	var mod *streamUIModel
	c, ok := m.(*streamUIModel)
	if ok {
		mod = c
	} else {
		c := m.(streamUIModel)
		mod = &c
	}

	fmt.Println()

	if !mod.buildOnly {
		fmt.Println(mod.mainDisplay)
	}

	if len(mod.finishedByPath) > 0 || len(mod.tokensByPath) > 0 {
		fmt.Println(mod.renderStaticBuild())
	}

	if mod.err != nil {
		log.Println("stream UI - error: ", mod.err)

		fmt.Println()
		term.OutputErrorAndExit(mod.err.Error())
	}

	if mod.apiErr != nil {
		log.Println("stream UI - api error: ", mod.apiErr)

		fmt.Println()
		term.HandleApiError(mod.apiErr)
	}

	if mod.stopped {
		fmt.Println()
		color.New(color.BgBlack, color.Bold, color.FgHiRed).Println(" 🛑 Stopped early ")
		fmt.Println()
		term.PrintCmds("", "log", "rewind", "tell")
		os.Exit(0)
	} else if mod.background {
		fmt.Println()
		color.New(color.BgBlack, color.Bold, color.FgHiGreen).Println(" ✅ Plan is active in the background ")
		fmt.Println()
		term.PrintCmds("", "ps", "connect", "stop")
		os.Exit(0)
	}

	if os.Getenv("PLANDEX_REPL") != "" && os.Getenv("PLANDEX_REPL_OUTPUT_FILE") != "" {
		// write output to file
		err := os.WriteFile(os.Getenv("PLANDEX_REPL_OUTPUT_FILE"), []byte(mod.reply), 0644)
		if err != nil {
			log.Println("stream UI - error writing output to repl temp file: ", err)
		}
	}

	return nil
}

func Quit() {
	if ui == nil {
		log.Println("stream UI is nil, can't quit")
		return
	}
	mu.Lock()
	if ui != nil {
		ui.Quit()
	}
	mu.Unlock()

	wg.Wait() // Wait for the UI to fully terminate
}

func Send(msg shared.StreamMessage) {
	if ui == nil {
		log.Println("stream ui is nil")

		if msg.Type == shared.StreamMessageError {
			prestartErr = msg.Error
		} else if msg.Type == shared.StreamMessageAborted {

		} else if msg.Type == shared.StreamMessageReply {
			prestartReply += msg.ReplyChunk
		}
		return
	}
	mu.Lock()
	defer mu.Unlock()
	ui.Send(msg)
}

func ToggleVisibility(hide bool) {
	if ui == nil {
		return
	}
	mu.Lock()
	defer mu.Unlock()

	if hide {
		ui.Send(tea.ExitAltScreen())
	} else {
		ui.Send(tea.EnterAltScreen())
	}
}


================================================
FILE: app/cli/stream_tui/update.go
================================================
package streamtui

import (
	"context"
	"fmt"
	"log"
	"os"
	"plandex-cli/api"
	"plandex-cli/lib"
	"plandex-cli/term"
	"strings"
	"time"

	shared "plandex-shared"

	bubbleKey "github.com/charmbracelet/bubbles/key"
	"github.com/charmbracelet/bubbles/spinner"
	"github.com/charmbracelet/bubbles/viewport"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"github.com/davecgh/go-spew/spew"
	"github.com/fatih/color"
)

func (m streamUIModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	// log.Println("Stream TUI - Update received message:", spew.Sdump(msg))

	switch msg := msg.(type) {

	case spinner.TickMsg:
		state := m.readState()

		if state.processing || state.starting {
			m.updateState(func() {
				spinnerModel, _ := m.spinner.Update(msg)
				m.spinner = spinnerModel
			})
		}
		if state.building {
			m.updateState(func() {
				buildSpinnerModel, _ := m.buildSpinner.Update(msg)
				m.buildSpinner = buildSpinnerModel
			})
		}
		return m, m.Tick()

	case tea.WindowSizeMsg:
		m.windowResized(msg.Width, msg.Height)

	case shared.StreamMessage:
		return m.streamUpdate(&msg, false)

	case contextLoadDoneMsg:
		if msg.err != nil {
			log.Println("failed to auto load context files:", msg.err)
			m.updateState(func() {
				m.err = msg.err
				m.processing = false
			})
			return m, tea.Quit
		}

		// We have the loaded content in msg.text
		m.updateState(func() {
			if msg.text != "" {
				m.reply += "\n\n" + msg.text + "\n\n"
			}
			// and keep processing
			m.processing = true
		})
		m.updateReplyDisplay()
		return m, m.Tick()

	case delayFileRestartMsg:
		m.updateState(func() {
			m.finishedByPath[msg.path] = false
		})

	// Scroll wheel doesn't seem to work--not sure why
	// case tea.MouseMsg:
	// 	if !m.promptingMissingFile {
	// 		if msg.Type == tea.MouseWheelUp {
	// 			m.mainViewport.LineUp(3)
	// 		} else if msg.Type == tea.MouseWheelDown {
	// 			m.mainViewport.LineDown(3)
	// 		}
	// 	}

	case tea.KeyMsg:
		switch {
		case bubbleKey.Matches(msg, m.keymap.stop) || bubbleKey.Matches(msg, m.keymap.quit):
			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
			defer cancel()
			apiErr := api.Client.StopPlan(ctx, lib.CurrentPlanId, lib.CurrentBranch)
			if apiErr != nil {
				log.Println("stop plan api error:", apiErr)
				m.updateState(func() {
					m.apiErr = apiErr
				})
			}
			m.updateState(func() {
				m.stopped = true
			})
			return m, tea.Quit

		case bubbleKey.Matches(msg, m.keymap.background):
			state := m.readState()
			if state.canSendToBg {
				m.updateState(func() {
					m.background = true
				})
				return m, tea.Quit
			}

		case bubbleKey.Matches(msg, m.keymap.scrollDown) && !m.promptingMissingFile:
			m.scrollDown()
		case bubbleKey.Matches(msg, m.keymap.scrollUp) && !m.promptingMissingFile:
			m.scrollUp()
		case bubbleKey.Matches(msg, m.keymap.pageDown) && !m.promptingMissingFile:
			m.pageDown()
		case bubbleKey.Matches(msg, m.keymap.pageUp) && !m.promptingMissingFile:
			m.pageUp()
		case bubbleKey.Matches(msg, m.keymap.up) && m.building:
			m.up()
		case bubbleKey.Matches(msg, m.keymap.down) && m.building:
			m.down()
		case bubbleKey.Matches(msg, m.keymap.start) && !m.promptingMissingFile:
			m.scrollStart()
		case bubbleKey.Matches(msg, m.keymap.end) && !m.promptingMissingFile:
			m.scrollEnd()
		case m.promptingMissingFile && bubbleKey.Matches(msg, m.keymap.enter):
			return m.selectedMissingFileOpt()

		default:
			m.resolveEscapeSequence(msg.String())
		}

	case buildStatusPollMsg:
		state := m.readState()

		numPaths := len(m.tokensByPath)
		numFinished := 0

		for _, isBuilt := range m.finishedByPath {
			if isBuilt {
				numFinished++
			}
		}

		if !state.finished && !state.stopped && !state.background && numPaths > 0 && numPaths != numFinished {
			status, apiErr := api.Client.GetBuildStatus(lib.CurrentPlanId, lib.CurrentBranch)
			if apiErr != nil {
				return m, m.pollBuildStatus()
			}

			m.updateState(func() {
				for path, isBuilt := range status.BuiltFiles {
					isBuilding := status.IsBuildingByPath[path]
					if isBuilt && !isBuilding {
						m.finishedByPath[path] = true
					}
				}
			})
		}
		return m, m.pollBuildStatus()
	}

	return m, nil
}

func (m *streamUIModel) windowResized(w, h int) {
	m.updateState(func() {
		m.width = w
		m.height = h
	})

	state := m.readState()

	_, viewportHeight := state.getViewportDimensions()

	if state.ready {
		m.updateViewportDimensions()
	} else {
		m.updateState(func() {
			m.mainViewport = viewport.New(w, viewportHeight)
			m.mainViewport.Style = lipgloss.NewStyle().Padding(0, 1, 0, 1)
		})

		m.updateReplyDisplay()

		m.updateState(func() {
			m.ready = true
		})
	}
}

func (m *streamUIModel) updateReplyDisplay() {
	state := m.readState()

	if state.buildOnly {
		return
	}

	s := ""

	if state.prompt != "" {
		promptTxt := term.GetPlain(state.prompt)

		s += color.New(color.BgGreen, color.Bold, color.FgHiWhite).Sprintf(" 💬 User prompt 👇 ")
		s += "\n\n" + strings.TrimSpace(promptTxt) + "\n"
	}

	if state.reply != "" {
		replyMd, _ := term.GetMarkdown(state.reply)
		s += "\n" + color.New(color.BgBlue, color.Bold, color.FgHiWhite).Sprintf(" 🤖 Plandex reply 👇 ")
		s += "\n\n" + strings.TrimSpace(replyMd)
	} else {
		s += "\n"
	}

	m.updateState(func() {
		m.mainDisplay = s
		m.mainViewport.SetContent(s)
	})

	m.updateViewportDimensions()

	if state.atScrollBottom {
		m.updateState(func() {
			m.mainViewport.GotoBottom()
		})
	}
}

func (m *streamUIModel) updateViewportDimensions() {
	state := m.readState()
	w, h := state.getViewportDimensions()

	m.updateState(func() {
		m.mainViewport.Width = w
		m.mainViewport.Height = h
	})
}

func (m *streamUIModel) getViewportDimensions() (int, int) {
	w := m.width
	h := m.height

	helpHeight := lipgloss.Height(m.renderHelp())

	var buildHeight int
	if m.building {
		if m.buildViewCollapsed {
			buildHeight = 3
		} else {
			buildHeight = len(m.getRows(false))
		}
	}

	var processingHeight int
	if m.starting || m.processing {
		processingHeight = lipgloss.Height(m.renderProcessing())
	}

	maxViewportHeight := h - (helpHeight + processingHeight + buildHeight)
	if maxViewportHeight < 0 {
		maxViewportHeight = 0
	}
	viewportHeight := min(maxViewportHeight, lipgloss.Height(m.mainDisplay))
	viewportWidth := w

	return viewportWidth, viewportHeight
}

func (m streamUIModel) replyScrollable() bool {
	return m.mainViewport.TotalLineCount() > m.mainViewport.VisibleLineCount()
}

func (m *streamUIModel) scrollDown() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.LineDown(1)
		})
	}

	state = m.readState()

	m.updateState(func() {
		m.atScrollBottom = !state.replyScrollable() || state.mainViewport.AtBottom()
	})
}

func (m *streamUIModel) scrollUp() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.LineUp(1)
			m.atScrollBottom = false
		})
	}
}

func (m *streamUIModel) pageDown() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.ViewDown()
		})
	}

	state = m.readState()

	m.updateState(func() {
		m.atScrollBottom = !state.replyScrollable() || state.mainViewport.AtBottom()
	})
}

func (m *streamUIModel) pageUp() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.ViewUp()
			m.atScrollBottom = false
		})
	}
}

func (m *streamUIModel) scrollStart() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.GotoTop()
			m.atScrollBottom = false
		})
	}
}

func (m *streamUIModel) scrollEnd() {
	state := m.readState()

	if state.replyScrollable() {
		m.updateState(func() {
			m.mainViewport.GotoBottom()
			m.atScrollBottom = true
		})
	}
}

func (m *streamUIModel) streamUpdate(msg *shared.StreamMessage, deferUIUpdate bool) (tea.Model, tea.Cmd) {
	switch msg.Type {

	case shared.StreamMessageMulti:
		cmds := []tea.Cmd{}
		for _, subMsg := range msg.StreamMessages {
			teaModel, cmd := m.streamUpdate(&subMsg, true)
			m = teaModel.(*streamUIModel)
			if cmd != nil {
				cmds = append(cmds, cmd)
			}
		}

		m.updateReplyDisplay()
		m.updateViewportDimensions()

		return m, tea.Batch(cmds...)

	case shared.StreamMessageConnectActive:
		if msg.InitPrompt != "" {
			m.updateState(func() {
				m.prompt = msg.InitPrompt
			})
		}
		if msg.InitBuildOnly {
			m.updateState(func() {
				m.buildOnly = true
			})
		}
		if len(msg.InitReplies) > 0 {
			m.updateState(func() {
				m.reply = strings.Join(msg.InitReplies, "\n\n👇\n\n")
			})
		}
		m.updateReplyDisplay()
		return m.checkMissingFile(msg)

	case shared.StreamMessagePromptMissingFile:
		return m.checkMissingFile(msg)

	case shared.StreamMessageReply:
		// ignore empty reply messages
		if msg.ReplyChunk == "" {
			return m, nil
		}

		state := m.readState()

		if state.starting {
			m.updateState(func() {
				m.starting = false
			})
		}

		if state.processing {
			log.Println("Non-empty message reply, setting processing to false")
			m.updateState(func() {
				m.processing = false
				if state.promptedMissingFile || state.autoLoadedMissingFile {
					log.Println("Prompted missing file or auto loaded missing file, resetting (and skipping 👇 marker)")
					m.promptedMissingFile = false
					m.autoLoadedMissingFile = false
				} else {
					log.Println("Not prompted missing file or auto loaded missing file, adding 👇 marker")
					m.reply += "\n\n👇\n\n"
				}
			})
		}

		m.updateState(func() {
			m.reply += msg.ReplyChunk
		})

		if !deferUIUpdate {
			m.updateReplyDisplay()
		}

	case shared.StreamMessageBuildInfo:
		state := m.readState()

		if state.starting {
			m.updateState(func() {
				m.starting = false
			})
		}

		m.updateState(func() {
			m.building = true
		})
		wasFinished := state.finishedByPath[msg.BuildInfo.Path]
		nowFinished := msg.BuildInfo.Finished

		m.updateState(func() {
			if msg.BuildInfo.Removed {
				m.removedByPath[msg.BuildInfo.Path] = true
			} else {
				m.removedByPath[msg.BuildInfo.Path] = false
			}
		})

		if msg.BuildInfo.Finished {
			m.updateState(func() {
				m.tokensByPath[msg.BuildInfo.Path] = 0
				m.finishedByPath[msg.BuildInfo.Path] = true
			})
		} else {
			if wasFinished && !nowFinished {
				// delay for a second before marking not finished again (so check flashes green prior to restarting build)
				log.Println("Stream message build info - delaying for 1 second before marking not finished again")
				return m, startDelay(msg.BuildInfo.Path, time.Second*1)
			} else {
				m.updateState(func() {
					m.finishedByPath[msg.BuildInfo.Path] = false
				})
			}

			m.updateState(func() {
				m.tokensByPath[msg.BuildInfo.Path] += msg.BuildInfo.NumTokens
			})
		}

		// Auto-collapse if build info takes up too much space
		state = m.readState()
		if !state.userToggledBuild && state.building {
			rows := len(m.getRows(false))
			m.updateState(func() {
				m.buildViewCollapsed = rows > 3
			})
		}

		if !deferUIUpdate {
			m.updateViewportDimensions()
		}

		return m, m.Tick()

	case shared.StreamMessageDescribing:
		log.Println("Message describing, setting processing to true")
		m.updateState(func() {
			m.processing = true
		})
		return m, m.Tick()

		// Instead of blocking here, we'll spawn a command
	case shared.StreamMessageLoadContext:
		m.updateState(func() {
			m.processing = true
		})
		return m, tea.Batch(
			loadContextCmd(msg.LoadContextFiles),
			tea.Tick(time.Second/10, func(t time.Time) tea.Msg {
				return spinner.TickMsg{}
			}),
		)

	case shared.StreamMessageError:
		log.Println("Stream message error:", spew.Sdump(msg))

		state := m.readState()
		if state.autoLoadContextCancelFn != nil {
			state.autoLoadContextCancelFn()
		}

		m.updateState(func() {
			m.apiErr = msg.Error
		})
		return m, tea.Quit

	case shared.StreamMessageFinished:
		m.updateState(func() {
			m.finished = true
		})
		return m, tea.Quit

	case shared.StreamMessageAborted:
		m.updateState(func() {
			m.stopped = true
		})
		return m, tea.Quit

	case shared.StreamMessageRepliesFinished:
		log.Println("Replies finished, setting processing to false")
		state := m.readState()

		m.updateState(func() {
			m.processing = false
		})

		if state.building {
			return m, m.Tick()
		}
	}

	return m, nil
}

type delayFileRestartMsg struct {
	path string
}

func startDelay(path string, delay time.Duration) tea.Cmd {
	return func() tea.Msg {
		time.Sleep(delay)
		return delayFileRestartMsg{path: path}
	}
}

var escReceivedAt time.Time
var escSeq string

func (m *streamUIModel) resolveEscapeSequence(val string) {
	if val == "esc" || val == "alt+[" {
		escReceivedAt = time.Now()
		go func() {
			time.Sleep(51 * time.Millisecond)
			escReceivedAt = time.Time{}
			escSeq = ""
		}()
	}

	if !escReceivedAt.IsZero() {
		elapsed := time.Since(escReceivedAt)

		if elapsed < 50*time.Millisecond {
			escSeq += val

			if escSeq == "esc[A" || escSeq == "alt+[A" {
				m.up()
				escReceivedAt = time.Time{}
				escSeq = ""
			} else if escSeq == "esc[B" || escSeq == "alt+[B" {
				m.down()
				escReceivedAt = time.Time{}
				escSeq = ""
			}
		}
	}
}

func (m *streamUIModel) up() {
	state := m.readState()
	if state.promptingMissingFile {
		m.updateState(func() {
			m.missingFileSelectedIdx = max(m.missingFileSelectedIdx-1, 0)
		})
	} else {
		m.updateState(func() {
			m.buildViewCollapsed = false
			m.userToggledBuild = true
		})
	}
}

func (m *streamUIModel) down() {
	state := m.readState()
	if state.promptingMissingFile {
		m.updateState(func() {
			m.missingFileSelectedIdx = min(m.missingFileSelectedIdx+1, len(missingFileSelectOpts)-1)
		})
	} else {
		m.updateState(func() {
			m.buildViewCollapsed = true
			m.userToggledBuild = true
		})
	}
}

func (m *streamUIModel) selectedMissingFileOpt() (tea.Model, tea.Cmd) {
	state := m.readState()
	choice := promptChoices[state.missingFileSelectedIdx]

	if choice == "" {
		return m, nil
	}

	apiErr := api.Client.RespondMissingFile(lib.CurrentPlanId, lib.CurrentBranch, shared.RespondMissingFileRequest{
		Choice:   choice,
		FilePath: m.missingFilePath,
		Body:     m.missingFileContent,
	})

	if apiErr != nil {
		log.Println("missing file prompt api error:", apiErr)
		m.updateState(func() {
			m.apiErr = apiErr
		})
		return m, nil
	}

	if choice == shared.RespondMissingFileChoiceSkip {
		replyLines := strings.Split(state.reply, "\n")
		m.updateState(func() {
			m.reply = strings.Join(replyLines[:len(replyLines)-3], "\n")
		})
		m.updateReplyDisplay()
	}

	m.updateState(func() {
		m.promptingMissingFile = false
		m.missingFilePath = ""
		m.missingFileSelectedIdx = 0
		m.missingFileContent = ""
		m.missingFileTokens = 0
		m.promptedMissingFile = true
		m.processing = true
	})

	return m, func() tea.Msg {
		<-m.sharedTicker.C
		return spinner.TickMsg{}
	}
}

func (m *streamUIModel) checkMissingFile(msg *shared.StreamMessage) (tea.Model, tea.Cmd) {
	if msg.MissingFilePath != "" {
		log.Println("checkMissingFile - received missing file message | path:", msg.MissingFilePath)

		if msg.MissingFileAutoContext {
			log.Println("checkMissingFile - received missing file message | auto context")
			m.updateState(func() {
				m.processing = true
				m.autoLoadedMissingFile = true
			})

			return m, tea.Batch(
				func() tea.Msg {
					<-m.sharedTicker.C
					return spinner.TickMsg{}
				},
				func() tea.Msg {
					bytes, err := os.ReadFile(msg.MissingFilePath)
					if err != nil {
						log.Println("failed to read file:", err)
						m.err = fmt.Errorf("failed to read file: %w", err)
						return tea.Quit
					}
					content := string(shared.NormalizeEOL(bytes))

					log.Println("checkMissingFile - calling RespondMissingFile")
					apiErr := api.Client.RespondMissingFile(lib.CurrentPlanId, lib.CurrentBranch, shared.RespondMissingFileRequest{
						Choice:   shared.RespondMissingFileChoiceLoad,
						FilePath: msg.MissingFilePath,
						Body:     content,
					})

					if apiErr != nil {
						log.Println("missing file prompt api error:", apiErr)
						m.updateState(func() {
							m.apiErr = apiErr
						})
						return tea.Quit
					}

					log.Println("checkMissingFile - RespondMissingFile success")

					return nil
				},
			)
		}

		m.updateState(func() {
			m.promptingMissingFile = true
			m.missingFilePath = msg.MissingFilePath
		})

		bytes, err := os.ReadFile(m.missingFilePath)
		if err != nil {
			log.Println("failed to read file:", err)
			m.updateState(func() {
				m.err = fmt.Errorf("failed to read file: %w", err)
			})
			return m, nil
		}

		missingFileContent := string(bytes)
		m.updateState(func() {
			m.missingFileContent = missingFileContent
		})

		numTokens := shared.GetNumTokensEstimate(missingFileContent)
		m.updateState(func() {
			m.missingFileTokens = numTokens
		})
	}

	return m, nil
}

// contextLoadDoneMsg is sent when the long-running AutoLoadContextFiles completes
type contextLoadDoneMsg struct {
	text string
	err  error
}

func loadContextCmd(loadContextFiles []string) tea.Cmd {
	return func() tea.Msg {
		ctx, cancel := context.WithCancel(context.Background())
		defer cancel()

		// Run the long operation directly
		text, err := lib.AutoLoadContextFiles(ctx, loadContextFiles)

		// Return the result as a message
		return contextLoadDoneMsg{
			text: text,
			err:  err,
		}
	}
}


================================================
FILE: app/cli/stream_tui/view.go
================================================
package streamtui

import (
	"fmt"
	"sort"
	"strings"

	"plandex-cli/term"

	"github.com/charmbracelet/lipgloss"
	"github.com/fatih/color"
)

var borderColor = lipgloss.Color("#444")
var helpTextColor = lipgloss.Color("#ddd")

func (m streamUIModel) View() string {

	if m.promptingMissingFile {
		return m.renderMissingFilePrompt()
	}

	views := []string{}
	if !m.buildOnly {
		views = append(views, m.renderMainView())
	}
	if m.processing || m.starting {
		views = append(views, m.renderProcessing())
	}
	if m.building {
		views = append(views, m.renderBuild())
	}
	views = append(views, m.renderHelp())

	return lipgloss.JoinVertical(lipgloss.Left, views...)
}

func (m streamUIModel) renderMainView() string {
	return m.mainViewport.View()
}

func (m streamUIModel) renderHelp() string {
	style := lipgloss.NewStyle().Width(m.width).Foreground(lipgloss.Color(helpTextColor)).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))

	if m.buildOnly {
		s := " (s)top"
		if m.canSendToBg {
			s += " • (b)ackground"
		}
		return style.Render(s)
	} else {
		s := " (s)top"
		if m.canSendToBg {
			s += " • (b)ackground"
		}
		s += " • (j/k) scroll • (d/u) page • (g/G) start/end"
		return style.Render(s)
	}
}

func (m streamUIModel) renderProcessing() string {
	if m.starting || m.processing {
		return "\n " + m.spinner.View()
	} else {
		return ""
	}
}

func (m streamUIModel) renderBuild() string {
	return m.doRenderBuild(false)
}

func (m streamUIModel) renderStaticBuild() string {
	return m.doRenderBuild(true)
}

func (m streamUIModel) doRenderBuild(outputStatic bool) string {
	if !m.building && !outputStatic {
		return ""
	}

	if outputStatic && len(m.finishedByPath) == 0 && len(m.tokensByPath) == 0 {
		return ""
	}

	var style lipgloss.Style
	if m.buildOnly {
		style = lipgloss.NewStyle().Width(m.width)
	} else {
		style = lipgloss.NewStyle().Width(m.width).BorderStyle(lipgloss.NormalBorder()).BorderTop(true).BorderForeground(lipgloss.Color(borderColor))
	}

	if !outputStatic && m.buildViewCollapsed {
		// Render collapsed view
		inProgress := 0
		total := len(m.tokensByPath)
		for path := range m.tokensByPath {
			if path == "_apply.sh" {
				total--
				continue
			}
			if !m.finishedByPath[path] {
				inProgress++
			}
		}

		_, hasApplyScript := m.tokensByPath["_apply.sh"]
		applyScriptFinished := m.finishedByPath["_apply.sh"]

		lbl := "file"
		if total > 1 {
			lbl = "files"
		}

		var summary string
		if total > 0 {
			summary = fmt.Sprintf(" 📄 %d %s", total, lbl)
		}
		if inProgress > 0 {
			summary += fmt.Sprintf(" • 📝 editing %d %s", inProgress, m.buildSpinner.View())
		}
		if hasApplyScript {
			if total > 0 {
				summary += " •"
			}
			if applyScriptFinished {
				summary += " 🚀 wrote commands"
			} else {
				summary += fmt.Sprintf(" 🚀 editing commands %s", m.buildSpinner.View())
			}
		}
		head := m.getBuildHeader(outputStatic)
		return style.Render(lipgloss.JoinVertical(lipgloss.Left, head, summary))
	}

	resRows := m.getRows(outputStatic)

	res := style.Render(strings.Join(resRows, "\n"))

	return res
}

func (m streamUIModel) didBuild() bool {
	return !(m.stopped || m.err != nil || m.apiErr != nil)
}

func (m streamUIModel) getBuildHeader(static bool) string {
	lbl := "Building plan "
	bgColor := color.BgGreen
	if static {
		if !m.didBuild() {
			lbl = "Build incomplete "
			bgColor = color.BgRed
		} else {
			lbl = "Built plan "
		}
	}

	head := color.New(bgColor, color.FgHiWhite, color.Bold).Sprint(" 🏗  ") + color.New(bgColor, color.FgHiWhite).Sprint(lbl)

	// Add collapse/expand hint
	var hint string
	if !static {
		hint = "(↓) collapse"
		if m.buildViewCollapsed {
			hint = "(↑) expand"
		}
	}
	padding := m.width - lipgloss.Width(head) - lipgloss.Width(hint) - 1 // 1 for space
	if padding > 0 {
		head += strings.Repeat(" ", padding) + hint
	}

	return head
}

func (m streamUIModel) getRows(static bool) []string {
	built := m.didBuild() && static
	head := m.getBuildHeader(static)

	// Gather file paths, _apply.sh last
	filePaths := make([]string, 0, len(m.tokensByPath))
	for filePath := range m.tokensByPath {
		if filePath == "_apply.sh" {
			continue
		}
		filePaths = append(filePaths, filePath)
	}
	sort.Strings(filePaths)
	if _, ok := m.tokensByPath["_apply.sh"]; ok {
		filePaths = append(filePaths, "_apply.sh")
	}

	var rows [][]string
	lineWidth := 0
	lineNum := -1
	rowIdx := 0

	for _, filePath := range filePaths {
		tokens := m.tokensByPath[filePath]
		finished := m.finished || m.finishedByPath[filePath] || built
		removed := m.removedByPath[filePath]

		// Basic block label
		icon := "📄"
		label := filePath
		if filePath == "_apply.sh" {
			icon = "🚀"
			label = "commands"
		}
		block := fmt.Sprintf("%s %s", icon, label)

		// Mark removed/finished/tokens
		switch {
		case removed:
			block += " ❌"
		case finished:
			block += " ✅"
		case tokens > 0:
			block += fmt.Sprintf(" %d 🪙", tokens)
		default:
			block += " " + m.buildSpinner.View()
		}

		// Truncate if needed
		blockWidth := lipgloss.Width(block)
		if blockWidth > m.width {
			maxWidth := m.width - lipgloss.Width("⋯")
			if maxWidth < 4 {
				block = string([]rune(block)[0:1]) + "⋯"
			} else {
				half := maxWidth / 2
				runes := []rune(block)
				block = string(runes[:half]) + "⋯" + string(runes[len(runes)-half:])
			}
		}

		// Build the "prefix + block" text tentatively:
		prefix := ""
		if rowIdx > 0 {
			prefix = " | "
		}
		candidate := prefix + block
		candidateWidth := lipgloss.Width(candidate)

		// Check if we have no row or it won't fit with the prefix
		if lineNum == -1 || lineWidth+candidateWidth > m.width {
			// Start a new row
			rows = append(rows, []string{})
			lineNum++
			rowIdx = 0
			lineWidth = 0

			// In a new row, there's no prefix
			candidate = block
			candidateWidth = lipgloss.Width(candidate)
		}

		rows[lineNum] = append(rows[lineNum], candidate)
		lineWidth += candidateWidth
		rowIdx++
	}

	// If empty row left at the end, strip it
	if len(rows) > 0 && len(rows[len(rows)-1]) == 0 {
		rows = rows[:len(rows)-1]
	}

	// Final output lines
	resRows := make([]string, len(rows)+1)
	resRows[0] = head
	for i, row := range rows {
		resRows[i+1] = lipgloss.JoinHorizontal(lipgloss.Left, row...)
	}

	return resRows
}

func (m streamUIModel) renderMissingFilePrompt() string {
	style := lipgloss.NewStyle().Padding(1).BorderStyle(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color(borderColor)).Width(m.width - 2).Height(m.height - 2)

	prompt := "📄 " + color.New(color.Bold, term.ColorHiYellow).Sprint(m.missingFilePath) + " isn't in context."

	prompt += "\n\n"

	desc := "This file exists in your project, but isn't loaded into context. Unless you load it into context or skip generating it, Plandex will fully overwrite the existing file rather than applying updates."

	words := strings.Split(desc, " ")
	for i, word := range words {
		words[i] = color.New(color.FgWhite).Sprint(word)
	}

	prompt += strings.Join(words, " ")

	prompt += "\n\n" + color.New(term.ColorHiMagenta, color.Bold).Sprintln("🧐 What do you want to do?")

	for i, opt := range missingFileSelectOpts {
		if i == m.missingFileSelectedIdx {
			prompt += color.New(term.ColorHiCyan, color.Bold).Sprint(" > " + opt)
		} else {
			prompt += "   " + opt
		}

		if opt == MissingFileLoadLabel {
			prompt += fmt.Sprintf(" | %d 🪙", m.missingFileTokens)
		}

		prompt += "\n"
	}

	return style.Render(prompt)
}


================================================
FILE: app/cli/term/color.go
================================================
package term

import (
	"github.com/fatih/color"
	"github.com/muesli/termenv"
)

var IsDarkBg = termenv.HasDarkBackground()

var ColorHiGreen color.Attribute
var ColorHiMagenta color.Attribute
var ColorHiRed color.Attribute
var ColorHiYellow color.Attribute
var ColorHiCyan color.Attribute
var ColorHiBlue color.Attribute

func init() {

	if IsDarkBg {
		ColorHiGreen = color.FgHiGreen
		ColorHiMagenta = color.FgHiMagenta
		ColorHiRed = color.FgHiRed
		ColorHiYellow = color.FgHiYellow
		ColorHiCyan = color.FgHiCyan
		ColorHiBlue = color.FgHiBlue
	} else {
		ColorHiGreen = color.FgGreen
		ColorHiMagenta = color.FgMagenta
		ColorHiRed = color.FgRed
		ColorHiYellow = color.FgYellow
		ColorHiCyan = color.FgCyan
		ColorHiBlue = color.FgBlue
	}
}


================================================
FILE: app/cli/term/errors.go
================================================
package term

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"

	shared "plandex-shared"

	"github.com/fatih/color"
)

var openUnauthenticatedCloudURL func(msg, path string)
var openAuthenticatedURL func(msg, path string)
var convertTrial func()

func SetOpenUnauthenticatedCloudURLFn(fn func(msg, path string)) {
	openUnauthenticatedCloudURL = fn
}
func SetOpenAuthenticatedURLFn(fn func(msg, path string)) {
	openAuthenticatedURL = fn
}
func SetConvertTrialFn(fn func()) {
	convertTrial = fn
}

func OutputSimpleError(msg string, args ...interface{}) {
	msg = fmt.Sprintf(msg, args...)
	fmt.Fprintln(os.Stderr, color.New(ColorHiRed, color.Bold).Sprint("🚨 "+shared.Capitalize(msg)))
}

func OutputErrorAndExit(msg string, args ...interface{}) {
	StopSpinner()

	msg = fmt.Sprintf(msg, args...)

	msg = strings.ReplaceAll(msg, "status code:", "status code")
	msg = strings.ReplaceAll(msg, ", body:", ":")

	displayMsg := ""
	errorParts := strings.Split(msg, ": ")

	addedErrors := map[string]bool{}

	if len(errorParts) > 1 {
		var lastPart string
		i := 0
		for idx, part := range errorParts {
			// don't repeat the same error message
			if _, ok := addedErrors[strings.ToLower(part)]; ok {
				continue
			}

			tail := strings.Join(errorParts[idx:], ": ")
			if maybeJSON(tail) {
				prettyJSON := prettyJSON(tail)
				indent := strings.Repeat("  ", i)

				// prepend indent to **each** line in the pretty JSON
				indentedJSON := strings.ReplaceAll(prettyJSON, "\n", "\n"+indent+"  ")

				// now write the block
				displayMsg += "\n" + indent + "→ " + indentedJSON
				break
			}

			if len(lastPart) < 10 && i > 0 {
				lastPart = lastPart + ": " + part
				displayMsg += ": " + part
				addedErrors[strings.ToLower(lastPart)] = true
				addedErrors[strings.ToLower(part)] = true
				continue
			}

			if i != 0 {
				displayMsg += "\n"
			}

			// indent the error message
			for n := 0; n < i; n++ {
				displayMsg += "  "
			}
			if i > 0 {
				displayMsg += "→ "
			}

			s := shared.Capitalize(part)
			if i == 0 {
				s = color.New(ColorHiRed, color.Bold).Sprint("🚨 " + s)
			}

			displayMsg += s

			addedErrors[strings.ToLower(part)] = true
			lastPart = part
			i++
		}
	} else {
		displayMsg = color.New(ColorHiRed, color.Bold).Sprint("🚨 " + msg)
	}

	fmt.Fprintln(os.Stderr, color.New(ColorHiRed, color.Bold).Sprint(displayMsg))
	os.Exit(1)
}

func OutputUnformattedErrorAndExit(msg string) {
	StopSpinner()
	fmt.Fprintln(os.Stderr, msg)
	os.Exit(1)
}

func OutputNoCurrentPlanErrorAndExit() {
	fmt.Println("🤷‍♂️ No current plan")
	fmt.Println()
	PrintCmds("", "new", "cd")
	os.Exit(1)
}

func HandleApiError(apiError *shared.ApiError) {
	if apiError.Type == shared.ApiErrorTypeCloudSubscriptionPaused {
		if apiError.BillingError.HasBillingPermission {
			StopSpinner()
			fmt.Println("Your org's Plandex Cloud subscription is paused.")
			res, err := ConfirmYesNo("Go to billing settings?")
			if err != nil {
				OutputErrorAndExit("error getting confirmation")
			}
			if res {
				openAuthenticatedURL("Opening billing settings in your browser.", "/settings/billing")
				os.Exit(0)
			} else {
				os.Exit(0)
			}
		} else {
			OutputErrorAndExit("Your org's subscription is paused. Please contact an org owner to continue.")
		}
	}

	if apiError.Type == shared.ApiErrorTypeCloudSubscriptionOverdue {
		if apiError.BillingError.HasBillingPermission {
			StopSpinner()
			OutputSimpleError("Your org's Plandex Cloud subscription is overdue.")
			res, err := ConfirmYesNo("Go to billing settings?")
			if err != nil {
				OutputErrorAndExit("error getting confirmation")
			}
			if res {
				openAuthenticatedURL("Opening billing settings in your browser.", "/settings/billing")
				os.Exit(0)
			} else {
				os.Exit(0)
			}
		} else {
			OutputErrorAndExit("Your org's subscription is overdue. Please contact an org owner to continue.")
		}
	}

	if apiError.Type == shared.ApiErrorTypeCloudMonthlyMaxReached {
		if apiError.BillingError.HasBillingPermission {
			StopSpinner()
			OutputSimpleError("Your org has reached its monthly limit for Plandex Cloud.")
			res, err := ConfirmYesNo("Go to billing settings?")
			if err != nil {
				OutputErrorAndExit("error getting confirmation")
			}
			if res {
				openAuthenticatedURL("Opening billing settings in your browser.", "/settings/billing")
				os.Exit(0)
			} else {
				os.Exit(0)
			}
		} else {
			OutputErrorAndExit("Your org has reached its monthly limit for Plandex Cloud.")
		}
	}

	if apiError.Type == shared.ApiErrorTypeCloudInsufficientCredits {
		if apiError.BillingError.HasBillingPermission {
			StopSpinner()
			OutputSimpleError("Insufficient credits")
			res, err := ConfirmYesNo("Go to billing settings?")
			if err != nil {
				OutputErrorAndExit("error getting confirmation")
			}
			if res {
				openAuthenticatedURL("Opening billing settings in your browser.", "/settings/billing")
				os.Exit(0)
			} else {
				os.Exit(0)
			}
		} else {
			OutputErrorAndExit("Insufficient credits")
		}
	}

	if apiError.Type == shared.ApiErrorTypeTrialMessagesExceeded {
		StopSpinner()
		fmt.Fprintf(os.Stderr, "\n🚨 You've reached the Plandex Cloud trial limit of %d messages per plan\n", apiError.TrialMessagesExceededError.MaxReplies)

		res, err := ConfirmYesNo("Upgrade now?")

		if err != nil {
			OutputErrorAndExit("Error prompting upgrade trial: %v", err)
		}

		if res {
			convertTrial()
			PrintCmds("", "continue")
			os.Exit(0)
		}
	}

	StopSpinner()
	OutputErrorAndExit(apiError.Msg)
}

func maybeJSON(s string) bool {
	s = strings.TrimSpace(s)
	if strings.HasPrefix(s, "{") && strings.HasSuffix(s, "}") {
		return true
	}
	if strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") {
		return true
	}
	return false
}

func prettyJSON(s string) string {
	var v any
	if err := json.Unmarshal([]byte(s), &v); err != nil {
		return s // not JSON
	}
	out, _ := json.MarshalIndent(v, "", "  ")
	return string(out)
}


================================================
FILE: app/cli/term/format.go
================================================
package term

import (
	"fmt"
	"os"
	"strings"

	"github.com/charmbracelet/glamour"
	"github.com/charmbracelet/glow/utils"
	"github.com/muesli/reflow/wordwrap"
	"github.com/muesli/termenv"
)

func init() {
	// pre-cache the glamour renderer
	getGlamourRenderer()
}

var (
	cachedGlamourRenderer      *glamour.TermRenderer
	cachedGlamourRendererWidth int
)

func getGlamourRenderer() (*glamour.TermRenderer, error) {
	width := GetTerminalWidth()

	if cachedGlamourRenderer != nil && cachedGlamourRendererWidth == width {
		return cachedGlamourRenderer, nil
	}

	// Build the renderer options.
	var opts []glamour.TermRendererOption

	// Check for a GLAMOUR_STYLE env variable.
	if style, ok := os.LookupEnv("GLAMOUR_STYLE"); ok && style != "" {
		opts = append(opts, glamour.WithStandardStyle(style))
	} else {
		// Fallback to auto style detection.
		opts = append(opts, glamour.WithAutoStyle())
	}

	// Always set word wrap and preserved newlines.
	opts = append(opts,
		glamour.WithWordWrap(min(width, 80)),
		glamour.WithPreservedNewLines(),
	)

	r, err := glamour.NewTermRenderer(opts...)
	if err != nil {
		return nil, fmt.Errorf("failed to create glamour renderer: %w", err)
	}

	cachedGlamourRenderer = r
	cachedGlamourRendererWidth = width
	return r, nil
}

func GetMarkdown(input string) (string, error) {
	inputBytes := utils.RemoveFrontmatter([]byte(input))

	r, err := getGlamourRenderer()
	if err != nil {
		return "", err
	}

	out, err := r.RenderBytes(inputBytes)
	if err != nil {
		return "", err
	}

	return string(out), nil
}

func GetPlain(input string) string {
	width := GetTerminalWidth()

	s := wordwrap.String(input, min(width-2, 80))
	// add padding
	lines := strings.Split(s, "\n")
	// for i := range lines {
	// 	lines[i] = "  " + lines[i]
	// }
	s = strings.Join(lines, "\n")

	s = termenv.String(s).Foreground(GetStreamForegroundColor()).String()

	return s
}


================================================
FILE: app/cli/term/help.go
================================================
package term

import (
	"fmt"
	"io"
	"os"
	"strings"

	"github.com/fatih/color"
)

type CmdConfig struct {
	Cmd   string
	Alias string
	Desc  string
	Repl  bool
}

var CliCommands = []CmdConfig{
	{"", "", "start the Plandex REPL", false},

	// {"--full", "", fmt.Sprintf("start the Plandex REPL with auto-mode %s", "'full'"), false},
	// {"--semi", "", fmt.Sprintf("start the Plandex REPL with auto-mode %s", "'semi'"), false},
	// {"--plus", "", fmt.Sprintf("start the Plandex REPL with auto-mode %s", "'plus'"), false},
	// {"--basic", "", fmt.Sprintf("start the Plandex REPL with auto-mode %s", "'basic'"), false},
	// {"--none", "", fmt.Sprintf("start the Plandex REPL with auto-mode %s", "'none'"), false},

	// {"--daily", "", fmt.Sprintf("start the Plandex REPL with %s model pack", "'daily-driver'"), false},
	// {"--strong", "", fmt.Sprintf("start the Plandex REPL with %s model pack", "'strong'"), false},
	// {"--cheap", "", fmt.Sprintf("start the Plandex REPL with %s model pack", "'cheap'"), false},
	// {"--oss", "", fmt.Sprintf("start the Plandex REPL with %s model pack", "'oss'"), false},

	{"new", "", "start a new plan", true},

	{"new --full", "", fmt.Sprintf("start a new plan with auto-mode %s", "'full'"), true},
	{"new --semi", "", fmt.Sprintf("start a new plan with auto-mode %s", "'semi'"), true},
	{"new --plus", "", fmt.Sprintf("start a new plan with auto-mode %s", "'plus'"), true},
	{"new --basic", "", fmt.Sprintf("start a new plan with auto-mode %s", "'basic'"), true},
	{"new --none", "", fmt.Sprintf("start a new plan with auto-mode %s", "'none'"), true},

	{"new --daily", "", fmt.Sprintf("start a new plan with %s model pack", "'daily-driver'"), true},
	{"new --reasoning", "", fmt.Sprintf("start a new plan with %s model pack", "'reasoning'"), true},
	{"new --strong", "", fmt.Sprintf("start a new plan with %s model pack", "'strong'"), true},
	{"new --cheap", "", fmt.Sprintf("start a new plan with %s model pack", "'cheap'"), true},
	{"new --oss", "", fmt.Sprintf("start a new plan with %s model pack", "'oss'"), true},
	{"new --gemini-planner", "", fmt.Sprintf("start a new plan with %s model pack", "'gemini-planner'"), true},
	{"new --o3-planner", "", fmt.Sprintf("start a new plan with %s model pack", "'o3-planner'"), true},
	{"new --r1-planner", "", fmt.Sprintf("start a new plan with %s model pack", "'r1-planner'"), true},
	{"new --perplexity-planner", "", fmt.Sprintf("start a new plan with %s model pack", "'perplexity-planner'"), true},
	{"new --opus-planner", "", fmt.Sprintf("start a new plan with %s model pack", "'opus-planner'"), true},

	{"plans", "pl", "list plans", true},
	{"cd", "", "set current plan by name or index", true},
	{"current", "cu", "show current plan", true},
	{"rename", "", "rename the current plan", true},
	{"delete-plan", "dp", "delete plan by name or index", true},

	{"config", "", "show current plan config", true},
	{"set-config", "", "update current plan config", true},
	{"config default", "", "show the default config for new plans", true},
	{"set-config default", "", "update the default config for new plans", true},

	{"set-auto", "", "update auto-mode (autonomy level) for current plan", true},
	{"set-auto none", "", fmt.Sprintf("set auto-mode to %s", "'none'"), true},
	{"set-auto basic", "", fmt.Sprintf("set auto-mode to %s", "'basic'"), true},
	{"set-auto plus", "", fmt.Sprintf("set auto-mode to %s", "'plus'"), true},
	{"set-auto semi", "", fmt.Sprintf("set auto-mode to %s", "'semi'"), true},
	{"set-auto full", "", fmt.Sprintf("set auto-mode to %s", "'full'"), true},

	{"set-auto default", "", "set the default auto-mode for new plans", true},

	{"tell", "t", "describe a task to complete", false},
	{"chat", "ch", "ask a question or chat", false},

	{"load", "l", "load files/dirs/urls/notes/images or pipe data into context", true},
	{"ls", "", "list everything in context", true},
	{"rm", "", "remove context by index, range, name, or glob", true},
	{"clear", "", "remove all context", true},
	{"update", "u", "update outdated context", true},
	{"show", "", "show current context by name or index", true},

	{"diff --ui", "", "review pending changes in a browser UI", true},
	{"diff", "", "review pending changes in 'git diff' format", true},
	{"diff --plain", "", "review pending changes in 'git diff' format with no color formatting", false},
	{"summary", "", "show the latest summary of the current plan", true},

	{"apply", "ap", "apply pending changes to project files", true},
	{"reject", "rj", "reject pending changes to one or more project files", true},

	{"log", "", "show log of plan updates", true},
	{"rewind", "rw", "rewind to a previous state", true},

	{"continue", "c", "continue the plan", true},
	{"debug", "db", "repeatedly run a command and auto-apply fixes until it succeeds", true},
	{"build", "b", "build any pending changes", true},

	{"convo", "", "show plan conversation", true},
	{"convo 1", "", "show a specific message in the conversation", false},
	{"convo 2-5", "", "show a range of messages in the conversation", false},
	{"convo --plain", "", "show conversation in plain text", false},

	{"branches", "br", "list plan branches", true},
	{"checkout", "co", "checkout or create a branch", true},
	{"delete-branch", "dlb", "delete a branch by name or index", true},

	{"plans --archived", "", "list archived plans", true},
	{"archive", "arc", "archive a plan", true},
	{"unarchive", "unarc", "unarchive a plan", true},

	{"models", "", "show current plan model settings", true},
	{"models default", "", "show the default model settings for new plans", true},

	{"models available", "", "show all available models", true},
	{"models available --custom", "", "show available custom models only", true},

	{"models custom", "", "manage custom models, providers, and model packs", true},

	{"providers", "", "show all available model providers", true},
	{"providers --custom", "", "show available custom model providers only", true},

	{"model-packs", "", "show all available model packs", true},

	{"model-packs --custom", "", "show custom model packs only", true},
	{"model-packs show", "", "show a built-in or custom model pack's settings", true},

	{"set-model", "", "update current plan model settings", true},
	{"set-model default", "", "update the default model settings for new plans", true},

	{"set-model daily", "", fmt.Sprintf("Use %s model pack", "'daily-driver'"), true},
	{"set-model reasoning", "", fmt.Sprintf("Use %s model pack", "'reasoning'"), true},
	{"set-model strong", "", fmt.Sprintf("Use %s model pack", "'strong'"), true},
	{"set-model cheap", "", fmt.Sprintf("Use %s model pack", "'cheap'"), true},
	{"set-model oss", "", fmt.Sprintf("Use %s model pack", "'oss'"), true},
	{"set-model gemini-planner", "", fmt.Sprintf("Use %s model pack", "'gemini-planner'"), true},
	{"set-model o3-planner", "", fmt.Sprintf("Use %s model pack", "'o3-planner'"), true},
	{"set-model r1-planner", "", fmt.Sprintf("Use %s model pack", "'r1-planner'"), true},
	{"set-model perplexity-planner", "", fmt.Sprintf("Use %s model pack", "'perplexity-planner'"), true},
	{"set-model opus-planner", "", fmt.Sprintf("Use %s model pack", "'opus-planner'"), true},

	{"ps", "", "list active and recently finished plan streams", true},
	{"stop", "", "stop an active plan stream", true},
	{"connect", "conn", "connect to an active plan stream", true},

	{"sign-in", "", "sign in, accept an invite, or create an account", true},
	{"invite", "", "invite a user to join your org", true},
	{"revoke", "", "revoke an invite or remove a user from your org", true},
	{"users", "", "list users and pending invites in your org", true},

	{"connect-claude", "", "connect your Claude Pro or Max subscription", true},
	{"disconnect-claude", "", "disconnect your Claude Pro or Max subscription", true},
	{"claude-status", "", "status of your Claude Pro or Max subscription connection", true},

	{"usage", "", "show Plandex Cloud current balance and usage report", true},
	{"usage --today", "", "show Plandex Cloud usage for the day so far", true},
	{"usage --month", "", "show Plandex Cloud usage for the current billing month", true},
	{"usage --plan", "", "show Plandex Cloud usage for the current plan", true},

	{"usage --log", "", "show Plandex Cloud transaction log", true},

	{"billing", "", "show Plandex Cloud billing settings", true},
}

var CmdDesc = map[string]CmdConfig{}

func init() {
	for _, cmd := range CliCommands {
		CmdDesc[cmd.Cmd] = cmd
	}
}

func PrintCmds(prefix string, cmds ...string) {
	printCmds(os.Stderr, prefix, []color.Attribute{color.Bold, color.FgHiWhite, color.BgCyan, color.FgHiWhite}, cmds...)
}

func PrintCmdsWithColors(prefix string, colors []color.Attribute, cmds ...string) {
	printCmds(os.Stderr, prefix, colors, cmds...)
}

func printCmds(w io.Writer, prefix string, colors []color.Attribute, cmds ...string) {
	if os.Getenv("PLANDEX_DISABLE_SUGGESTIONS") != "" {
		return
	}

	for _, cmd := range cmds {
		config, ok := CmdDesc[cmd]
		if !ok {
			continue
		}

		if IsRepl && !config.Repl {
			continue
		}

		alias := config.Alias
		desc := config.Desc

		if alias != "" {
			if IsRepl {
				cmd = fmt.Sprintf("%s (\\%s)", cmd, alias)
			} else {
				containsFull := strings.Contains(cmd, alias)

				if containsFull {
					cmd = strings.Replace(cmd, alias, fmt.Sprintf("(%s)", alias), 1)
				} else {
					cmd = fmt.Sprintf("%s (%s)", cmd, alias)
				}
			}

			// desc += color.New(color.FgWhite).Sprintf(" • alias → %s", fmt.Sprint(a'lias'))
		}

		var styled string
		if IsRepl {
			styled = color.New(colors...).Sprintf(" \\%s ", cmd)
		} else if cmd == "" { // special case for the repl
			styled = color.New(colors...).Sprintf(" plandex ")
		} else {
			styled = color.New(colors...).Sprintf(" plandex %s ", cmd)
		}

		fmt.Fprintf(w, "%s%s 👉 %s\n", prefix, styled, desc)
	}

}

func PrintCustomCmd(prefix, cmd, alias, desc string) {
	cmd = strings.Replace(cmd, alias, fmt.Sprintf("(%s)", alias), 1)
	// desc += color.New(color.FgWhite).Sprintf(" • alias → %s", fmt.Sprint(a'lias'))
	styled := color.New(color.Bold, color.FgHiWhite, color.BgCyan, color.FgHiWhite).Sprintf(" plandex %s ", cmd)
	fmt.Printf("%s%s 👉 %s\n", prefix, styled, desc)
}

// PrintCustomHelp prints the custom help output for the Plandex CLI
func PrintCustomHelp(all bool) {
	builder := &strings.Builder{}

	color.New(color.Bold, color.BgGreen, color.FgHiWhite).Fprintln(builder, " Usage ")
	color.New(color.Bold).Fprintln(builder, "  plandex [command] [flags]")
	color.New(color.Bold).Fprintln(builder, "  pdx [command] [flags]")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgGreen, color.FgHiWhite).Fprintln(builder, " Help ")
	color.New(color.Bold).Fprintln(builder, "  plandex help # show basic usage")
	color.New(color.Bold).Fprintln(builder, "  plandex help --all # show all commands")
	color.New(color.Bold).Fprintln(builder, "  plandex [command] --help")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgMagenta, color.FgHiWhite).Fprintln(builder, " Getting Started ")
	fmt.Fprintln(builder)
	fmt.Fprintf(builder, " 🚀 Start the Plandex REPL in a project directory with %s or %s\n", color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprint(" plandex "), color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprint(" pdx "))
	fmt.Fprintln(builder)
	fmt.Fprintf(builder, " 💻 You can also use any command outside the REPL with %s or %s\n", color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprint(" plandex [command] "), color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprint(" pdx [command] "))
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgMagenta, color.FgHiWhite).Fprintln(builder, " REPL Options ")
	fmt.Fprintln(builder)
	// Add REPL startup flags
	fmt.Fprintln(builder, color.New(color.Bold, color.FgHiBlue).Sprint("  Mode "))
	fmt.Fprintln(builder, "    --chat, -c     Start in chat mode (for conversation without making changes)")
	fmt.Fprintln(builder, "    --tell, -t     Start in tell mode (for implementation)")
	fmt.Fprintln(builder)

	fmt.Fprintln(builder, color.New(color.Bold, color.FgHiBlue).Sprint("  Autonomy "))
	fmt.Fprintln(builder, "    --no-auto      None → step-by-step, no automation")
	fmt.Fprintln(builder, "    --basic        Basic → auto-continue plans")
	fmt.Fprintln(builder, "    --plus         Plus → auto-update context, smart context, auto-commit changes")
	fmt.Fprintln(builder, "    --semi         Semi-Auto → auto-load context")
	fmt.Fprintln(builder, "    --full         Full-Auto → auto-apply, auto-exec, auto-debug")
	fmt.Fprintln(builder)

	fmt.Fprintln(builder, color.New(color.Bold, color.FgHiBlue).Sprint("  Models "))
	fmt.Fprintln(builder, "    --daily        Daily driver pack")
	fmt.Fprintln(builder, "    --reasoning    Reasoning pack")
	fmt.Fprintln(builder, "    --strong       Strong pack")
	fmt.Fprintln(builder, "    --cheap        Cheap pack")
	fmt.Fprintln(builder, "    --oss          Open source pack")

	fmt.Fprintln(builder)

	if all {
		fmt.Print(builder.String())
		PrintHelpAllCommands()
	} else {
		fmt.Print(builder.String())
		// in the same style as 'getting started' section, output See All Commands

		color.New(color.Bold, color.BgHiBlue, color.FgHiWhite).Fprintln(builder, " Use 'plandex help --all' or 'plandex help -a' for a list of all commands ")
		fmt.Fprintln(builder)

		fmt.Print(builder.String())
	}

}

func PrintHelpAllCommands() {
	builder := &strings.Builder{}

	color.New(color.Bold, color.BgMagenta, color.FgHiWhite).Fprintln(builder, " Key Commands ")
	printCmds(builder, " ", []color.Attribute{color.Bold, color.FgHiMagenta}, "new", "load", "tell", "diff", "diff --ui", "apply", "reject", "debug", "chat")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Plans ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "new", "plans", "cd", "current", "delete-plan", "rename", "archive", "plans --archived", "unarchive")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Changes ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "diff", "diff --ui", "diff --plain", "apply", "reject")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Context ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "load", "ls", "rm", "update", "clear")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Branches ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "branches", "checkout", "delete-branch")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " History ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "log", "rewind", "convo", "convo 1", "convo 2-5", "convo --plain", "summary")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Control ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "tell", "continue", "build", "debug", "chat")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Streams ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "ps", "connect", "stop")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Config ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "config", "set-config", "config default", "set-config default")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Autonomy ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "set-auto", "set-auto default", "set-auto full", "set-auto semi", "set-auto plus", "set-auto basic", "set-auto none")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " AI Models ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "models", "models default", "model-packs", "set-model", "set-model daily", "set-model reasoning", "set-model strong", "set-model cheap", "set-model oss", "set-model default")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Custom Models ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan},
		"models custom", "models available", "models available --custom", "providers", "providers --custom", "model-packs", "model-packs --custom", "model-packs show")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Accounts ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "sign-in", "invite", "revoke", "users")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Integrations ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "connect-claude", "disconnect-claude", "claude-status")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " Cloud ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "usage", "usage --today", "usage --month", "usage --plan", "usage --log", "billing")
	fmt.Fprintln(builder)

	color.New(color.Bold, color.BgCyan, color.FgHiWhite).Fprintln(builder, " New Plan Shortcuts ")
	printCmds(builder, " ", []color.Attribute{color.Bold, ColorHiCyan}, "new --full", "new --semi", "new --plus", "new --basic", "new --none", "new --daily", "new --reasoning", "new --strong", "new --cheap", "new --oss", "new --gemini-planner", "new --o3-planner", "new --r1-planner", "new --perplexity-planner", "new --opus-planner")
	fmt.Fprintln(builder)

	fmt.Print(builder.String())
}

func ShowCmd(cmd string) string {
	if IsRepl {
		cmd = fmt.Sprintf("\\%s", cmd)
	} else {
		cmd = fmt.Sprintf("plandex %s", cmd)
	}

	return color.New(color.Bold, color.BgCyan, color.FgHiWhite).Sprintf(" %s ", cmd)
}


================================================
FILE: app/cli/term/os.go
================================================
package term

import (
	"fmt"
	"os"
	"runtime"
)

func GetOsDetails() string {
	return fmt.Sprintf(
		"OS: %s\nArchitecture: %s\nCPUs: %d\nShell: %s",
		runtime.GOOS,
		runtime.GOARCH,
		runtime.NumCPU(),
		os.Getenv("SHELL"),
	)
}


================================================
FILE: app/cli/term/prompt.go
================================================
package term

import (
	"fmt"
	"os"

	"github.com/cqroot/prompt"
	"github.com/cqroot/prompt/input"
	"github.com/eiannone/keyboard"
	"github.com/fatih/color"
)

func GetRequiredUserStringInput(msg string) (string, error) {
	res, err := GetUserStringInput(msg)
	if err != nil {
		return "", fmt.Errorf("failed to get user input: %s", err)
	}

	if res == "" {
		color.New(color.Bold, ColorHiRed).Println("🚨 This input is required")
		return GetRequiredUserStringInput(msg)
	}

	return res, nil
}

func GetUserStringInput(msg string) (string, error) {
	return GetUserStringInputWithDefault(msg, "")
}

func GetUserStringInputWithDefault(msg, def string) (string, error) {
	disableBracketedPaste()
	defer enableBracketedPaste()

	res, err := prompt.New().Ask(msg).Input(def)

	if err != nil && err.Error() == "user quit prompt" {
		os.Exit(0)
	}

	return res, err
}

func GetRequiredUserStringInputWithDefault(msg, def string) (string, error) {
	res, err := GetUserStringInputWithDefault(msg, def)
	if err != nil {
		return "", fmt.Errorf("failed to get user input: %s", err)
	}

	if res == "" {
		color.New(color.Bold, ColorHiRed).Println("🚨 This input is required")
		return GetRequiredUserStringInputWithDefault(msg, def)
	}

	return res, nil
}

func GetUserPasswordInput(msg string) (string, error) {
	disableBracketedPaste()
	defer enableBracketedPaste()

	res, err := prompt.New().Ask(msg).Input("", input.WithEchoMode(input.EchoPassword))

	if err != nil && err.Error() == "user quit prompt" {
		os.Exit(0)
	}

	return res, err
}

func GetUserKeyInput() (rune, keyboard.Key, error) {
	if err := keyboard.Open(); err != nil {
		return 0, 0, fmt.Errorf("failed to open keyboard: %s", err)
	}
	defer func() {
		_ = keyboard.Close()
	}()

	char, key, err := keyboard.GetKey()
	if err != nil {
		return 0, 0, fmt.Errorf("failed to read keypress: %s", err)
	}

	return char, key, nil
}

func ConfirmYesNo(fmtStr string, fmtArgs ...interface{}) (bool, error) {
	color.New(ColorHiMagenta, color.Bold).Printf(fmtStr+" (y)es | (n)o", fmtArgs...)
	color.New(ColorHiMagenta, color.Bold).Print("> ")

	char, key, err := GetUserKeyInput()
	if err != nil {
		return false, fmt.Errorf("failed to get user input: %s", err)
	}

	// ctrl+c == no
	if key == keyboard.KeyCtrlC {
		return false, nil
	}

	fmt.Println(string(char))
	if char == 'y' || char == 'Y' {
		return true, nil
	} else if char == 'n' || char == 'N' {
		return false, nil
	} else {
		fmt.Println()
		color.New(ColorHiRed, color.Bold).Print("Invalid input.\nEnter 'y' for yes or 'n' for no.\n\n")
		return ConfirmYesNo(fmtStr, fmtArgs...)
	}
}

func ConfirmYesNoCancel(fmtStr string, fmtArgs ...interface{}) (bool, bool, error) {
	color.New(ColorHiMagenta, color.Bold).Printf(fmtStr+" (y)es | (n)o | (c)ancel", fmtArgs...)
	color.New(ColorHiMagenta, color.Bold).Print("> ")

	char, key, err := GetUserKeyInput()
	if err != nil {
		return false, false, fmt.Errorf("failed to get user input: %s", err)
	}

	// ctrl+c == cancel
	if key == keyboard.KeyCtrlC {
		return false, true, nil
	}

	fmt.Println(string(char))
	if char == 'y' || char == 'Y' {
		return true, false, nil
	} else if char == 'n' || char == 'N' {
		return false, false, nil
	} else if char == 'c' || char == 'C' {
		return false, true, nil
	} else {
		fmt.Println()
		color.New(ColorHiRed, color.Bold).Print("Invalid input.\nEnter 'y' for yes, 'n' for no, or 'c' for cancel.\n\n")
		return ConfirmYesNoCancel(fmtStr, fmtArgs...)
	}
}

func disableBracketedPaste() {
	fmt.Print("\033[?2004l")
}

func enableBracketedPaste() {
	fmt.Print("\033[?2004h")
}


================================================
FILE: app/cli/term/repl.go
================================================
package term

import "os"

var IsRepl = os.Getenv("PLANDEX_REPL") != ""

func SetIsRepl(value bool) {
	IsRepl = value
}


================================================
FILE: app/cli/term/select.go
================================================
package term

import (
	"fmt"
	"os"

	"github.com/fatih/color"
	"github.com/plandex-ai/survey/v2"
)

func SelectFromList(msg string, options []string) (string, error) {
	var selected string
	prompt := &survey.Select{
		Message:       color.New(ColorHiMagenta, color.Bold).Sprint(msg),
		Options:       convertToStringSlice(options),
		FilterMessage: "",
	}
	err := survey.AskOne(prompt, &selected)
	if err != nil {
		if err.Error() == "interrupt" {
			os.Exit(0)
		}

		return "", err
	}

	return selected, nil
}

func convertToStringSlice[T any](input []T) []string {
	var result []string
	for _, v := range input {
		result = append(result, fmt.Sprint(v))
	}
	return result
}


================================================
FILE: app/cli/term/spinner.go
================================================
package term

import (
	"sync/atomic"
	"time"

	"github.com/briandowns/spinner"
)

const withMessageMinDuration = 700 * time.Millisecond
const withoutMessageMinDuration = 350 * time.Millisecond

var s = spinner.New(spinner.CharSets[33], 100*time.Millisecond)
var startedAt time.Time

var lastMessage string
var active bool
var currentWarningLoop int32

func StartSpinner(msg string) {
	if active {
		if msg == lastMessage {
			return
		}

		s.Stop()
	}

	startedAt = time.Now()
	s.Prefix = msg + " "
	lastMessage = msg
	s.Start()
	active = true
}

func StopSpinner() {
	elapsed := time.Since(startedAt)

	if lastMessage != "" && elapsed < withMessageMinDuration {
		time.Sleep(withMessageMinDuration - elapsed)
	} else if elapsed < withoutMessageMinDuration {
		time.Sleep(withoutMessageMinDuration - elapsed)
	}

	s.Stop()
	ClearCurrentLine()

	active = false
}

func ResumeSpinner() {
	if !active {
		StartSpinner(lastMessage)
	}
}

func LongSpinnerWithWarning(msg, warning string) {
	atomic.AddInt32(&currentWarningLoop, 1)
	currentLoop := currentWarningLoop

	StartSpinner(msg)

	var flashWarning func()
	flashWarning = func() {
		go func() {
			time.Sleep(3 * time.Second)
			if !active || atomic.LoadInt32(&currentWarningLoop) != currentLoop {
				return
			}
			StartSpinner(warning)

			time.Sleep(2 * time.Second)
			if !active || atomic.LoadInt32(&currentWarningLoop) != currentLoop {
				return
			}
			StartSpinner(msg)
			flashWarning()
		}()
	}
	flashWarning()
}


================================================
FILE: app/cli/term/utils.go
================================================
package term

import (
	"fmt"
	"os"
	"os/exec"
	"strconv"
	"strings"

	"github.com/muesli/termenv"
	"golang.org/x/term"
)

func init() {
	// pre-cache terminal settings
	IsTerminal()
	GetTerminalWidth()
	GetStreamForegroundColor()
	HasDarkBackground()
}

func AlternateScreen() {
	// Switch to alternate screen and hide the cursor
	fmt.Print("\x1b[?1049h\x1b[?25l")
}

func ClearScreen() {
	fmt.Print("\x1b[2J")
}

func MoveCursorToTopLeft() {
	fmt.Print("\x1b[H")
}

func ClearCurrentLine() {
	fmt.Print("\033[2K")
}

func MoveUpLines(numLines int) {
	fmt.Printf("\033[%dA", numLines)
}

func BackToMain() {
	// Switch back to main screen and show the cursor on exit
	fmt.Print("\x1b[?1049l\x1b[?25h")
}

func PageOutput(output string) {
	cmd := exec.Command("less", "-R")
	cmd.Env = append(os.Environ(), "LESS=FRX", "LESSCHARSET=utf-8")
	cmd.Stdin = strings.NewReader(output)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	if err := cmd.Run(); err != nil {
		OutputErrorAndExit("Failed to page output: %v", err)
	}
}

func PageOutputReverse(output string) {
	cmd := exec.Command("less", "-RX", "+G")
	cmd.Stdin = strings.NewReader(output)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	// Set the environment variables specifically for the less command
	cmd.Env = append(os.Environ(), "LESS=FRX", "LESSCHARSET=utf-8")

	if err := cmd.Run(); err != nil {
		OutputErrorAndExit("Failed to page output: %v", err)
	}
}

func GetDivisionLine() string {
	// Get the terminal width
	terminalWidth := GetTerminalWidth()
	return strings.Repeat("─", terminalWidth)
}

var envReplCols int
var envDefaultCols int

func GetTerminalWidth() int {
	if envReplCols != 0 {
		return envReplCols
	}

	if os.Getenv("PLANDEX_COLUMNS") != "" {
		w, err := strconv.Atoi(os.Getenv("PLANDEX_COLUMNS"))
		if err == nil {
			envReplCols = w
			return w
		}
	}

	if IsTerminal() {
		// Try to get terminal size
		if w, _, err := term.GetSize(int(os.Stdout.Fd())); err == nil {
			return w
		}
	}

	if envDefaultCols != 0 {
		return envDefaultCols
	}

	// Not running in a TTY or GetSize failed; use a default.
	// Try to get width from environment variable
	if w, err := strconv.Atoi(os.Getenv("COLUMNS")); err == nil {
		envDefaultCols = w
		return w
	}

	// Fallback to default width
	return 80
}

var envStreamForegroundColor termenv.Color

func GetStreamForegroundColor() termenv.Color {
	if envStreamForegroundColor != nil {
		return envStreamForegroundColor
	}

	if os.Getenv("PLANDEX_STREAM_FOREGROUND_COLOR") != "" {
		envStreamForegroundColor = termenv.ANSI256.Color(os.Getenv("PLANDEX_STREAM_FOREGROUND_COLOR"))
		return envStreamForegroundColor
	}

	c := "234"
	if HasDarkBackground() {
		c = "251"
	}
	envStreamForegroundColor = termenv.ANSI256.Color(c)
	return envStreamForegroundColor
}

var envHasDarkBackground bool
var cachedHasDarkBackground bool

func HasDarkBackground() bool {
	if cachedHasDarkBackground {
		return envHasDarkBackground
	}
	envHasDarkBackground = termenv.HasDarkBackground()
	cachedHasDarkBackground = true
	return envHasDarkBackground
}

var envIsTerminal bool
var cachedIsTerminal bool

func IsTerminal() bool {
	if cachedIsTerminal {
		return envIsTerminal
	}
	envIsTerminal = term.IsTerminal(int(os.Stdout.Fd()))
	cachedIsTerminal = true
	return envIsTerminal
}


================================================
FILE: app/cli/types/api.go
================================================
package types

import (
	"context"
	shared "plandex-shared"

	"github.com/shopspring/decimal"
)

type OnStreamPlanParams struct {
	Msg *shared.StreamMessage
	Err error
}

type OnStreamPlan func(params OnStreamPlanParams)

type ApiClient interface {
	CreateCliTrialSession() (string, *shared.ApiError)
	GetCliTrialSession(token string) (*shared.SessionResponse, *shared.ApiError)

	CreateEmailVerification(email, customHost, userId string) (*shared.CreateEmailVerificationResponse, *shared.ApiError)

	CreateSignInCode() (string, *shared.ApiError)

	CreateAccount(req shared.CreateAccountRequest, customHost string) (*shared.SessionResponse, *shared.ApiError)
	SignIn(req shared.SignInRequest, customHost string) (*shared.SessionResponse, *shared.ApiError)

	SignOut() *shared.ApiError

	GetOrgSession() (*shared.Org, *shared.ApiError)
	ListOrgs() ([]*shared.Org, *shared.ApiError)
	CreateOrg(req shared.CreateOrgRequest) (*shared.CreateOrgResponse, *shared.ApiError)

	GetOrgUserConfig() (*shared.OrgUserConfig, *shared.ApiError)
	UpdateOrgUserConfig(req shared.OrgUserConfig) *shared.ApiError

	ListUsers() (*shared.ListUsersResponse, *shared.ApiError)
	DeleteUser(userId string) *shared.ApiError

	ListOrgRoles() ([]*shared.OrgRole, *shared.ApiError)

	InviteUser(req shared.InviteRequest) *shared.ApiError
	ListPendingInvites() ([]*shared.Invite, *shared.ApiError)
	ListAcceptedInvites() ([]*shared.Invite, *shared.ApiError)
	ListAllInvites() ([]*shared.Invite, *shared.ApiError)
	DeleteInvite(inviteId string) *shared.ApiError

	CreateProject(req shared.CreateProjectRequest) (*shared.CreateProjectResponse, *shared.ApiError)
	ListProjects() ([]*shared.Project, *shared.ApiError)
	SetProjectPlan(projectId string, req shared.SetProjectPlanRequest) *shared.ApiError
	RenameProject(projectId string, req shared.RenameProjectRequest) *shared.ApiError

	ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)
	ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError)
	ListPlansRunning(projectIds []string, includeRecent bool) (*shared.ListPlansRunningResponse, *shared.ApiError)

	GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError)

	GetPlan(planId string) (*shared.Plan, *shared.ApiError)
	CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError)

	TellPlan(planId, branch string, req shared.TellPlanRequest, onStreamPlan OnStreamPlan) *shared.ApiError
	BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStreamPlan OnStreamPlan) *shared.ApiError
	RespondMissingFile(planId, branch string, req shared.RespondMissingFileRequest) *shared.ApiError

	DeletePlan(planId string) *shared.ApiError
	DeleteAllPlans(projectId string) *shared.ApiError
	ConnectPlan(planId, branch string, onStreamPlan OnStreamPlan) *shared.ApiError
	StopPlan(ctx context.Context, planId, branch string) *shared.ApiError

	ArchivePlan(planId string) *shared.ApiError
	UnarchivePlan(planId string) *shared.ApiError
	RenamePlan(planId string, name string) *shared.ApiError

	GetCurrentPlanState(planId, branch string) (*shared.CurrentPlanState, *shared.ApiError)
	GetCurrentPlanStateAtSha(planId, sha string) (*shared.CurrentPlanState, *shared.ApiError)
	ApplyPlan(planId, branch string, req shared.ApplyPlanRequest) (string, *shared.ApiError)
	RejectAllChanges(planId, branch string) *shared.ApiError
	RejectFile(planId, branch, filePath string) *shared.ApiError
	RejectFiles(planId, branch string, paths []string) *shared.ApiError
	GetPlanDiffs(planId, branch string, plain bool) (string, *shared.ApiError)

	LoadContext(planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError)
	UpdateContext(planId, branch string, req shared.UpdateContextRequest) (*shared.UpdateContextResponse, *shared.ApiError)
	DeleteContext(planId, branch string, req shared.DeleteContextRequest) (*shared.DeleteContextResponse, *shared.ApiError)
	ListContext(planId, branch string) ([]*shared.Context, *shared.ApiError)
	LoadCachedFileMap(planId, branch string, req shared.LoadCachedFileMapRequest) (*shared.LoadCachedFileMapResponse, *shared.ApiError)

	ListConvo(planId, branch string) ([]*shared.ConvoMessage, *shared.ApiError)
	GetPlanStatus(planId, branch string) (string, *shared.ApiError)
	ListLogs(planId, branch string) (*shared.LogResponse, *shared.ApiError)
	RewindPlan(planId, branch string, req shared.RewindPlanRequest) (*shared.RewindPlanResponse, *shared.ApiError)

	ListBranches(planId string) ([]*shared.Branch, *shared.ApiError)
	DeleteBranch(planId, branch string) *shared.ApiError
	CreateBranch(planId, branch string, req shared.CreateBranchRequest) *shared.ApiError

	GetSettings(planId, branch string) (*shared.PlanSettings, *shared.ApiError)
	UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError)

	GetOrgDefaultSettings() (*shared.PlanSettings, *shared.ApiError)
	UpdateOrgDefaultSettings(req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError)

	GetPlanConfig(planId string) (*shared.PlanConfig, *shared.ApiError)
	UpdatePlanConfig(planId string, req shared.UpdatePlanConfigRequest) *shared.ApiError
	GetDefaultPlanConfig() (*shared.PlanConfig, *shared.ApiError)
	UpdateDefaultPlanConfig(req shared.UpdateDefaultPlanConfigRequest) *shared.ApiError

	CreateCustomModels(input *shared.ModelsInput) *shared.ApiError
	ListCustomModels() ([]*shared.CustomModel, *shared.ApiError)

	ListCustomProviders() ([]*shared.CustomProvider, *shared.ApiError)

	ListModelPacks() ([]*shared.ModelPack, *shared.ApiError)

	GetCreditsTransactions(pageSize, pageNum int, req shared.CreditsLogRequest) (*shared.CreditsLogResponse, *shared.ApiError)
	GetCreditsSummary(req shared.CreditsLogRequest) (*shared.CreditsSummaryResponse, *shared.ApiError)
	GetBalance() (decimal.Decimal, *shared.ApiError)

	GetFileMap(req shared.GetFileMapRequest) (*shared.GetFileMapResponse, *shared.ApiError)
	GetContextBody(planId, branch, contextId string) (*shared.GetContextBodyResponse, *shared.ApiError)
	AutoLoadContext(ctx context.Context, planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError)
	GetBuildStatus(planId, branch string) (*shared.GetBuildStatusResponse, *shared.ApiError)
}


================================================
FILE: app/cli/types/apply.go
================================================
package types

import (
	"os"
)

type ApplyFlags struct {
	AutoConfirm bool
	AutoCommit  bool
	NoCommit    bool
	AutoExec    bool
	NoExec      bool
	AutoDebug   int
}

type ApplyRollbackOption string

const (
	ApplyRollbackOptionKeep     ApplyRollbackOption = "Apply file changes"
	ApplyRollbackOptionRollback ApplyRollbackOption = "Roll back file changes"
)

type OnApplyExecFailFn func(status int, output string, attempt int, toRollback *ApplyRollbackPlan, onErr OnErrFn, onSuccess func())

type ApplyReversion struct {
	Content string
	Mode    os.FileMode
}

type ApplyRollbackPlan struct {
	ToRevert             map[string]ApplyReversion
	ToRemove             []string
	PreviousProjectPaths *ProjectPaths
}

func (r *ApplyRollbackPlan) HasChanges() bool {
	return len(r.ToRevert) > 0 || len(r.ToRemove) > 0
}


================================================
FILE: app/cli/types/exec.go
================================================
package types

type TellFlags struct {
	TellBg                 bool
	TellStop               bool
	TellNoBuild            bool
	IsUserContinue         bool
	IsUserDebug            bool
	IsApplyDebug           bool
	IsChatOnly             bool
	AutoContext            bool
	SmartContext           bool
	ContinuedAfterAction   bool
	ExecEnabled            bool
	AutoApply              bool
	IsImplementationOfChat bool
	SkipChangesMenu        bool
}
type BuildFlags struct {
	BuildBg   bool
	AutoApply bool
}


================================================
FILE: app/cli/types/fs.go
================================================
package types

import ignore "github.com/sabhiram/go-gitignore"

type ProjectPaths struct {
	ActivePaths    map[string]bool
	AllPaths       map[string]bool
	ActiveDirs     map[string]bool
	AllDirs        map[string]bool
	PlandexIgnored *ignore.GitIgnore
	IgnoredPaths   map[string]string
	GitIgnoredDirs map[string]bool
}


================================================
FILE: app/cli/types/types.go
================================================
package types

import (
	shared "plandex-shared"
	"time"

	"github.com/sashabaranov/go-openai"
)

type LoadContextParams struct {
	Note              string
	Recursive         bool
	NamesOnly         bool
	ForceSkipIgnore   bool
	ImageDetail       openai.ImageURLDetail
	DefsOnly          bool
	SkipIgnoreWarning bool
	AutoLoaded        bool
	SessionId         string
}

type ContextOutdatedResult struct {
	Msg             string
	UpdatedContexts []*shared.Context
	RemovedContexts []*shared.Context
	TokenDiffsById  map[string]int
	NumFiles        int
	NumUrls         int
	NumTrees        int
	NumMaps         int
	NumFilesRemoved int
	NumTreesRemoved int
	ReqFn           func() (map[string]*shared.UpdateContextParams, error)
}

const (
	PlanOutdatedStrategyOverwrite        string = "Clear the modifications and then apply"
	PlanOutdatedStrategyApplyUnmodified  string = "Apply only new and unmodified files"
	PlanOutdatedStrategyApplyNoConflicts string = "Apply anyway since there are no conflicts"
	PlanOutdatedStrategyRebuild          string = "Rebuild the plan with updated context"
	PlanOutdatedStrategyCancel           string = "Cancel"
)

type CurrentPlanSettings struct {
	Id string `json:"id"`
}

type PlanSettings struct {
	Branch string `json:"branch"`
}

type CurrentProjectSettings struct {
	Id string `json:"id"`
}

type CurrentPlanSettingsByAccount map[string]*CurrentPlanSettings
type PlanSettingsByAccount map[string]*PlanSettings
type CurrentProjectSettingsByAccount map[string]*CurrentProjectSettings

type ChangesUIScrollReplacement struct {
	OldContent        string
	NewContent        string
	NumLinesPrepended int
}

type ChangesUIViewportsUpdate struct {
	ScrollReplacement *ChangesUIScrollReplacement
}

type OnErrFn func(errMsg string, errArgs ...interface{})

type OauthResponse struct {
	AccessToken  string `json:"access_token"`
	RefreshToken string `json:"refresh_token"`
	ExpiresIn    int    `json:"expires_in"`
}

type OauthCreds struct {
	OauthResponse
	ExpiresAt time.Time `json:"expires_at"`
}

type AccountCredentials struct {
	ClaudeMax *OauthCreds `json:"claudeMax"`
}


================================================
FILE: app/cli/ui/ui.go
================================================
package ui

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"plandex-cli/api"
	"plandex-cli/term"
	"strings"

	"github.com/fatih/color"
	"github.com/pkg/browser"

	shared "plandex-shared"
)

func OpenAuthenticatedURL(msg, path string) {
	signInCode, apiErr := api.Client.CreateSignInCode()
	if apiErr != nil {
		log.Fatalf("Error creating sign in code: %v", apiErr)
	}

	apiHost := api.GetApiHost()
	appHost := strings.Replace(apiHost, "api-v2.", "app.", 1)
	appHost = strings.Replace(appHost, "api.", "app.", 1)

	token := shared.UiSignInToken{
		Pin:        signInCode,
		RedirectTo: path,
	}

	jsonToken, err := json.Marshal(token)
	if err != nil {
		log.Fatalf("Error marshalling token: %v", err)
	}

	encodedToken := base64.URLEncoding.EncodeToString(jsonToken)

	url := fmt.Sprintf("%s/auth/%s", appHost, encodedToken)

	OpenURL(msg, url)
}

func OpenUnauthenticatedCloudURL(msg, path string) {
	apiHost := api.GetApiHost()
	appHost := strings.Replace(apiHost, "api-v2.", "app.", 1)

	url := fmt.Sprintf("%s%s", appHost, path)

	OpenURL(msg, url)
}

func OpenURL(msg, url string) {

	fmt.Printf(
		"%s\n\nIf it doesn't open automatically, use this URL:\n%s\n",
		color.New(term.ColorHiGreen).Sprintf(msg),
		url,
	)

	err := browser.OpenURL(url)
	if err != nil {
		fmt.Printf("Failed to open URL automatically: %v\n", err)
		fmt.Println("Please open the URL manually in your browser.")
	}
}


================================================
FILE: app/cli/upgrade.go
================================================
package main

import (
	"archive/tar"
	"compress/gzip"
	"context"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"plandex-cli/term"
	"plandex-cli/version"
	"runtime"
	"strings"
	"time"

	"github.com/Masterminds/semver"
	"github.com/fatih/color"
	"github.com/inconshreveable/go-update"
)

func checkForUpgrade() {
	if os.Getenv("PLANDEX_SKIP_UPGRADE") != "" {
		return
	}

	if version.Version == "development" {
		return
	}

	term.StartSpinner("")
	defer term.StopSpinner()
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	latestVersionURL := "https://plandex.ai/v2/cli-version.txt"
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, latestVersionURL, nil)
	if err != nil {
		log.Println("Error creating request:", err)
		return
	}
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Println("Error checking latest version:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Println("Error reading response body:", err)
		return
	}

	versionStr := string(body)
	versionStr = strings.TrimSpace(versionStr)

	latestVersion, err := semver.NewVersion(versionStr)
	if err != nil {
		log.Println("Error parsing latest version:", err)
		return
	}

	currentVersion, err := semver.NewVersion(version.Version)
	if err != nil {
		log.Println("Error parsing current version:", err)
		return
	}

	if latestVersion.GreaterThan(currentVersion) {
		term.StopSpinner()
		fmt.Println("A new version of Plandex is available:", color.New(color.Bold, term.ColorHiGreen).Sprint(versionStr))
		fmt.Printf("Current version: %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint(version.Version))
		confirmed, err := term.ConfirmYesNo("Upgrade to the latest version?")
		if err != nil {
			log.Println("Error reading input:", err)
			return
		}

		if confirmed {
			term.ResumeSpinner()
			err := doUpgrade(latestVersion.String())
			if err != nil {
				term.OutputErrorAndExit("Failed to upgrade: %v", err)
				return
			}
			term.StopSpinner()
			restartPlandex()
		} else {
			fmt.Println("Note: set PLANDEX_SKIP_UPGRADE=1 to stop upgrade prompts")
		}
	}
}

func doUpgrade(version string) error {
	tag := fmt.Sprintf("cli/v%s", version)
	escapedTag := url.QueryEscape(tag)

	downloadURL := fmt.Sprintf("https://github.com/plandex-ai/plandex/releases/download/%s/plandex_%s_%s_%s.tar.gz", escapedTag, version, runtime.GOOS, runtime.GOARCH)
	resp, err := http.Get(downloadURL)
	if err != nil {
		return fmt.Errorf("failed to download the update: %w", err)
	}
	defer resp.Body.Close()

	// Create a temporary file to save the downloaded archive
	tempFile, err := os.CreateTemp("", "*.tar.gz")
	if err != nil {
		return fmt.Errorf("failed to create temporary file: %w", err)
	}
	defer os.Remove(tempFile.Name()) // Clean up file afterwards

	// Copy the response body to the temporary file
	_, err = io.Copy(tempFile, resp.Body)
	if err != nil {
		return fmt.Errorf("failed to save the downloaded archive: %w", err)
	}

	_, err = tempFile.Seek(0, 0)
	if err != nil {
		return fmt.Errorf("failed to seek in temporary file: %w", err)
	}

	// Now, extract the binary from the tempFile
	gzr, err := gzip.NewReader(tempFile)
	if err != nil {
		return fmt.Errorf("failed to create gzip reader: %w", err)
	}
	defer gzr.Close()

	tarReader := tar.NewReader(gzr)
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break // End of archive
		}
		if err != nil {
			return fmt.Errorf("failed to read tar header: %w", err)
		}

		// Check if the current file is the binary
		if header.Typeflag == tar.TypeReg && (header.Name == "plandex" || header.Name == "plandex.exe") {
			err = update.Apply(tarReader, update.Options{})
			if err != nil {
				if errors.Is(err, fs.ErrPermission) {
					return fmt.Errorf("failed to apply update due to permission error; please try running your command again with 'sudo': %w", err)
				}
				return fmt.Errorf("failed to apply update: %w", err)
			}
			break
		}
	}

	return nil
}

func restartPlandex() {
	exe, err := os.Executable()
	if err != nil {
		term.OutputErrorAndExit("Failed to determine executable path: %v", err)
	}

	cmd := exec.Command(exe, os.Args[1:]...)
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err = cmd.Start()
	if err != nil {
		term.OutputErrorAndExit("Failed to restart: %v", err)
	}

	err = cmd.Wait()

	// If the process exited with an error, exit with the same error code
	if exitErr, ok := err.(*exec.ExitError); ok {
		os.Exit(exitErr.ExitCode())
	} else if err != nil {
		term.OutputErrorAndExit("Failed to restart: %v", err)
	}

	os.Exit(0)
}


================================================
FILE: app/cli/url/url.go
================================================
package url

import (
	"errors"
	"io"
	"net/http"
	"net/url"
	"plandex-cli/term"
	"regexp"
	"strings"
	"time"

	"github.com/PuerkitoBio/goquery"
)

const (
	// Constants for fetchURLContent function
	maxRedirections    = 10
	httpTimeout        = 30 * time.Second
	maxContentSizeInMB = 10
)

func FetchURLContent(url string) (string, error) {
	client := &http.Client{
		Timeout: httpTimeout,
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			if len(via) >= maxRedirections {
				return errors.New("stopped after too many redirects")
			}
			return nil
		},
	}

	resp, err := client.Get(url)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return "", errors.New("non-2xx HTTP response status: " + resp.Status)
	}

	// Limit the response reader to a maximum amount
	limitedReader := io.LimitReader(resp.Body, maxContentSizeInMB*1024*1024)

	content, err := io.ReadAll(limitedReader)
	if err != nil {
		return "", err
	}

	contentType := resp.Header.Get("Content-Type")
	if strings.Contains(contentType, "text/html") {
		return ExtractTextualContent(string(content)), nil
	} else {
		return string(content), nil
	}
}

func ExtractTextualContent(htmlContent string) string {
	r := strings.NewReader(htmlContent)
	doc, err := goquery.NewDocumentFromReader(r)
	if err != nil {
		term.OutputErrorAndExit("Failed to parse HTML: %v", err)
	}

	return doc.Text()
}

func SanitizeURL(url string) string {
	// remove protocol portion with a regex
	re := regexp.MustCompile(`^.*?://`)
	url = re.ReplaceAllString(url, "")

	// Replace common invalid filename characters. You can extend this list as needed.
	sanitized := strings.ReplaceAll(url, ":", "_")
	sanitized = strings.ReplaceAll(sanitized, "/", "_")
	sanitized = strings.ReplaceAll(sanitized, "?", "_")
	sanitized = strings.ReplaceAll(sanitized, "&", "_")
	sanitized = strings.ReplaceAll(sanitized, "=", "_")
	sanitized = strings.ReplaceAll(sanitized, "#", "_")
	sanitized = strings.ReplaceAll(sanitized, "%", "_")
	sanitized = strings.ReplaceAll(sanitized, "*", "_")
	sanitized = strings.ReplaceAll(sanitized, " ", "_")
	return sanitized
}

func IsValidURL(str string) bool {
	u, err := url.Parse(str)
	return err == nil && u.Scheme != "" && u.Host != ""
}


================================================
FILE: app/cli/utils/utils.go
================================================
package utils

import (
	"time"
)

func EnsureMinDuration(start time.Time, minDuration time.Duration) {
	elapsed := time.Since(start)
	if elapsed < minDuration {
		time.Sleep(minDuration - elapsed)
	}
}


================================================
FILE: app/cli/version/version.go
================================================
package version

// Version will be set at build time using -ldflags
var Version = "development"


================================================
FILE: app/cli/version.txt
================================================
2.2.1


================================================
FILE: app/docker-compose.yml
================================================
services:
  plandex-postgres:
    image: postgres:latest
    restart: always
    environment:
      POSTGRES_PASSWORD: plandex
      POSTGRES_USER: plandex
      POSTGRES_DB: plandex
    ports:
      - "5432:5432"
    volumes:
      - plandex-db:/var/lib/postgresql/data
    networks:
      - plandex-network
  plandex-server:
    image: plandexai/plandex-server:latest
    # build:
    #   context: .
    #   dockerfile: server/Dockerfile
    volumes:
      - plandex-files:/plandex-server
    ports:
      - "8099:8099"
      - "4000:4000"
    environment:
      DATABASE_URL: "postgres://plandex:plandex@plandex-postgres:5432/plandex?sslmode=disable"
      GOENV: development
      LOCAL_MODE: 1
      PLANDEX_BASE_DIR: /plandex-server
      OLLAMA_BASE_URL: http://host.docker.internal:11434
      
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - plandex-network
    depends_on:
      - plandex-postgres
    command: [ "/bin/sh", "-c", "/scripts/wait-for-it.sh plandex-postgres:5432 -- ./plandex-server" ]

networks:
  plandex-network:
    driver: bridge

volumes:
  plandex-db:
  plandex-files:

================================================
FILE: app/plans/credits-cmd.txt
================================================

Add a cmd/credits.go file with a command that calls GetOrgSession to get the current org and then if IntegratedModelsMode is true, displays the current credit balance formatted in dollars, to 4 decimal places.

If IntegratedModelsMode isn't true, output that the org isn't using integrated models mode and nothing else.

Display the current balance nicely in a table.


================================================
FILE: app/plans/credits-log-cmd.txt
================================================
I want to add a 'plandex credits log' command to the 'cli/cmd' directory. I want it to show all debits and credits from the credits_transactions table in a nicely formated way.

You will need to add an API handler and route for this endpoint in server/cloud/ and also do the CLI side of the endpoint in cli/types/api.go and cli/api/methods.go.

We will also need a client-side version of the CreditsTransaction type in shared/data_models.go that includes appropriate attributes, as well as a ToApi method for the server-side CreditsTransaction type in server/cloud/types/credits.go

Think through anything else we will need to make this work. Also think about the best way to format and display this data for maximum developer-friendliness. 


================================================
FILE: app/plans/json-prompts-to-xml.md
================================================
dI want to update a number of LLM calls to potentially use XML instead of JSON-based tool calls based on their configuration in `AvailableModels` in `shared/ai_models.go`.

Here are the calls I want to update:

- commit message ('genPlanDescription' call)
- exec status ('execStatusShouldContinue' call) 
- naming functions - 'GenPlanName', 'GenPipedDataName', and 'GenNoteName'

Look at 'build_exec.go' for an example of how to extract XML from a response.

For each of the LLM calls:

- Before the call, you'll need to check the model config to see if the 'PreferredOutputFormat' field is set to xml/tool call json. We'll need to branch all the logic and prompts based on this.

- Add new prompting to output the same data using xml tags instead of a JSON function call if the model's 'PreferredOutputFormat' field is set to 'Xml'. do not use XML attributes, just simple tags. if there are multiple results in the json schema for the function call, update the prompt to output multiple tags. keep the rest of the prompts exactly the same. You can refactor shared aspects of the prompts between the xml version and the tool call json version.

- Look at the corresponding prompts for the build (in prompt/build.go) and use similar language for outputting xml tags in the xml versions of prompts.

- Update the post LLM call handling to extract the appropriate data using xml tags instead of json.

- Apart from the updated prompts, do not change other parameters in the LLM calls (like model, temperature, etc.)

- I don't want to have any nesting in the xml. the response should just contain multiple tags at the top level if multiple tags are needed. also, it must be clear in all cases that the output should be the content of the tag and not an attribute... brief examples must be included in every prompt as well for the xml versions.

================================================
FILE: app/plans/plan-config.md
================================================
I want to add a plan config feature. It should be loosely modeled  
on the plan model settings (often referred to also as just plan settings),  
and the 'model packs' feature. I want to store a 'plan_config' JSON field on
the 'plans' table. I also want a 'settings' and a 'set' CLI command.        
  
'settings' shows the current config (like 'models' cmd)  and 'set' allows 
updating the config just like 'set-model'. the server-side updates can also
work similarly to models and model sets. it shouldn't be added to the file  
system or use git at all-it should just be stored in the database.  These are *new* commands separate from the 'models' and 'set-model' commands and should have their own files.

For prompting and user input in the 'set' command, use the same approach as the 'set-model' command. Don't introduce any new dependencies.                                                                              
it should have these properties to start:                                   
                                                                              
AutoApply bool AutoCommit bool AutoContext bool NoExec bool AutoDebug bool AutoDebugTries int         

Apart from the plan config, I also want a default user-level config with the
same properties. similar to how there's 'set-model' and 'set-model default'-
this should also have a 'set default' command. again use model settings as a
guide.

On the server side, to keep things neater, create new files for the API and DB handlers rather than including them in the existing plan settings handlers.

On the client side, update the API interface and implementation for the new api calls.

Also update the CLI 'tell', 'continue', 'build', and 'chat' commands to use config settings by default (they can be overridden with the flags that already exist).

Server-side, it needs api handlers, db handlers, and db up/down migration.

Also add request/response types.

For the 'new' command, show the default settings to the user after the plan is created (in a nicely formatted way, similar to the 'settings' command).

Update the CLI help output accordingly. Also add the appropriate command suggestions to the 'settings' and 'set' commands. Also add suggestions to the 'new' command to demonstrate the new config settings commands.

================================================
FILE: app/reset_local.sh
================================================
#!/usr/bin/env bash

# Get the absolute path to the script's directory, regardless of where it's run from
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

# Change to the app directory if we're not already there
cd "$SCRIPT_DIR"

echo "Clearing local mode..."

./clear_local.sh

echo "Starting local mode..."

./start_local.sh

================================================
FILE: app/scripts/cmd/gen/gen.go
================================================
package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"text/template"
)

func main() {
	if len(os.Args) < 2 {
		log.Fatalf("Usage: %s <path/to/directory>", os.Args[0])
	}

	dirPath := os.Args[1]
	dirName := filepath.Base(dirPath)

	// Create the main directory
	if err := os.MkdirAll(dirPath, 0755); err != nil {
		log.Fatalf("Error creating directory: %s", err)
	}

	f, err := os.Create(fmt.Sprintf("%s/%s", dirPath, "promptfooconfig.yaml"))
	if err != nil {
		log.Fatalf("Error creating file: %s", err)
	}
	f.Close()

	// Create files inside the directory
	files := []string{
		"parameters.json",
		"config.properties",
		"prompt.txt",
	}

	for _, file := range files {
		f, err := os.Create(fmt.Sprintf("%s/%s.%s", dirPath, dirName, file))
		if err != nil {
			log.Fatalf("Error creating file: %s", err)
		}
		f.Close()
	}

	// Create assets and tests directories
	subDirs := []string{"assets", "tests"}

	for _, subDir := range subDirs {
		if err := os.Mkdir(fmt.Sprintf("%s/%s", dirPath, subDir), 0755); err != nil {
			log.Fatalf("Error creating subdirectory: %s", err)
		}
	}

	// Template for promptfooconfig.yaml
	ymlTemplate := `description: "{{ .Name }}"

prompts:
  - file://{{ .Name }}.prompt.txt

providers:
  - file://{{ .Name }}.provider.yml

tests: tests/*.tests.yml
`

	// Populate promptfooconfig.yaml
	promptFooConfigTmpl, err := template.New("yml").Parse(ymlTemplate)
	if err != nil {
		log.Fatalf("Error creating template: %s", err)
	}

	// Template for config.properties
	propertiesTemplate := `provider_id=openai:gpt-4o
temperature=
max_tokens=
top_p=
response_format=
function_name=
tool_type=function
function_param_type=object
tool_choice_type=function
tool_choice_function_name=
nested_parameters_json={{ .Name }}.parameters.json
`

	// Populate config.properties
	configPropertiesTmpl, err := template.New("properties").Parse(propertiesTemplate)
	if err != nil {
		log.Fatalf("Error creating template: %s", err)
	}

	configFile, err := os.Create(fmt.Sprintf("%s/%s.%s", dirPath, dirName, "config.properties"))
	if err != nil {
		log.Fatalf("Error creating config.properties: %s", err)
	}
	defer configFile.Close()

	file, err := os.Create(fmt.Sprintf("%s/promptfooconfig.yaml", dirPath))
	if err != nil {
		log.Fatalf("Error creating promptfooconfig.yaml: %s", err)
	}
	defer file.Close()

	data := struct {
		Name string
	}{
		Name: dirName,
	}

	if err := promptFooConfigTmpl.Execute(file, data); err != nil {
		log.Fatalf("Error executing template: %s", err)
	}

	if err := configPropertiesTmpl.Execute(configFile, data); err != nil {
		log.Fatalf("Error executing template: %s", err)
	}

	fmt.Println("Directory created successfully!")
	fmt.Println("Please check the contents of the directory and proceed with the implementation.")
}


================================================
FILE: app/scripts/cmd/provider/gen_provider.go
================================================
package main

import (
	"encoding/json"
	"log"
	"os"
	"path/filepath"
	"strings"
	"text/template"
)

var testDir = "test/evals/promptfoo-poc"
var templFile = testDir + "/templates/" + "/provider.template.yml"

func main() {

	testAbsPath, _ := filepath.Abs(testDir)
	templAbsPath, _ := filepath.Abs(templFile)

	// Function to walk through directories and find required values
	err := filepath.Walk(testAbsPath, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() && filepath.Ext(path) == ".properties" {
			dirName := filepath.Base(filepath.Dir(path))
			outputFileName := filepath.Join(filepath.Dir(path), dirName+".provider.yml")

			// Read the template file
			templateContent, err := os.ReadFile(templAbsPath)
			if err != nil {
				log.Fatalf("Error reading template file: %v", err)
			}

			// Prepare variables (this assumes properties file is a simple key=value format)
			variables := map[string]interface{}{}
			properties, err := os.ReadFile(path)
			if err != nil {
				log.Fatalf("Error reading properties file: %v", err)
			}
			for _, line := range strings.Split(string(properties), "\n") {
				if len(line) == 0 {
					continue
				}
				parts := strings.SplitN(line, "=", 2)

				if len(parts) > 2 {
					log.Fatalf("Invalid line in properties file: %s", line)
				}

				if len(parts) < 2 {
					log.Fatalf("Invalid line in properties file: %s", line)
				}

				key := strings.TrimSpace(parts[0])
				value := strings.TrimSpace(parts[1])

				if key != "nested_parameters_json" {
					variables[key] = value
					continue
				}

				// Read the file path from the nested_parameters_json key
				parametersJsonFile := filepath.Join(filepath.Dir(path), value)
				jsonParameters, err := os.ReadFile(parametersJsonFile)
				if err != nil {
					log.Fatalf("Error reading nested parameters JSON file: %v", err)
				}
				// Parse the JSON string
				var nestedParameters map[string]interface{}

				// We marshal and unmarshal the JSON to ensure that the nested properties are properly formatted 
				// for the template, and to ensure that the data is correct json

				err = json.Unmarshal(jsonParameters, &nestedParameters)

				if err != nil {
					log.Fatalf("Error un-marshalling nested parameters JSON: %v", err)
				}

				parameters, err := json.Marshal(nestedParameters)
				if err != nil {
					log.Fatalf("Error marshalling nested parameters JSON: %v", err)
				}

				// Add the nested properties to the variables
				variables["parameters"] = string(parameters)
			}

			// Parse and execute the template
			tmpl, err := template.New("yamlTemplate").Parse(string(templateContent))
			if err != nil {
				log.Fatalf("Error parsing template: %v", err)
			}
			outputFile, err := os.Create(outputFileName)
			if err != nil {
				log.Fatalf("Error creating output file: %v", err)
			}
			defer outputFile.Close()

			err = tmpl.Execute(outputFile, variables)
			if err != nil {
				log.Fatalf("Error executing template: %v", err)
			}
			log.Printf("Template rendered and saved to '%s'", outputFileName)
		}
		return nil
	})
	if err != nil {
		log.Fatalf("Error walking the path: %v", err)
	}
}


================================================
FILE: app/scripts/dev.sh
================================================
#!/usr/bin/env bash

# Detect zsh and trigger it if its the shell
if [ -n "$ZSH_VERSION" ]; then
  # shell is zsh
  echo "Detected zsh"
  zsh -c "source ~/.zshrc && $*"
fi

# Get the directory of the script
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Change to the script directory
cd "$SCRIPT_DIR" || exit 1

# Install Python deps
"$SCRIPT_DIR/litellm_deps.sh"

# Update PATH for python venv
export PATH="$SCRIPT_DIR/../litellm-venv/bin:$PATH"

# Detect if reflex is installed and install it if not
if ! [ -x "$(command -v reflex)" ]; then

  # Check if the $GOPATH is empty
  if [ -z "$GOPATH" ]; then
    echo "Error: GOPATH is not set. Please set it to continue..." >&2
    exit 1
  fi

  echo 'Error: reflex is not installed. Installing it now...' >&2
  go install github.com/cespare/reflex@latest
fi

terminate() {
  pkill -f 'plandex-server' # Assuming plandex-server is the name of your process
  kill -TERM "$pid1" 2>/dev/null
  kill -TERM "$pid2" 2>/dev/null
}

trap terminate SIGTERM SIGINT

(cd .. && cd cli && ./dev.sh)

cd ../

export DATABASE_URL=postgres://ds:@localhost/plandex_local?sslmode=disable
export GOENV=development
export LOCAL_MODE=1

reflex -r '^(cli|shared)/.*\.(go|mod|sum)$' -- sh -c 'cd cli && ./dev.sh' &
pid1=$!

reflex -r '^(server|shared)/.*\.(go|mod|sum|py)$' -s -- sh -c 'cd server && go build && ./plandex-server' &
pid2=$!

wait $pid1
wait $pid2


================================================
FILE: app/scripts/litellm_deps.sh
================================================
#!/usr/bin/env bash

set -e

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
VENV_DIR="$SCRIPT_DIR/../litellm-venv"
REQUIRED_PYTHON="python3"
REQUIRED_PACKAGES=("litellm==1.72.6" "fastapi==0.115.12" "uvicorn==0.34.1" "google-cloud-aiplatform==1.96.0" "boto3==1.38.40" "botocore==1.38.40")

if ! command -v "$REQUIRED_PYTHON" &>/dev/null; then
  echo "Python3 not found. Please install it and run this script again."
  exit 1
fi

if [ ! -d "$VENV_DIR" ]; then
  echo "Creating Python virtual environment at $VENV_DIR..."
  "$REQUIRED_PYTHON" -m venv "$VENV_DIR"
fi

source "$VENV_DIR/bin/activate"

is_installed() {
  python -c "import pkg_resources; pkg_resources.require('$1')" &>/dev/null
}

for package in "${REQUIRED_PACKAGES[@]}"; do
  if ! is_installed "$package"; then
    echo "Installing Python package: $package"
    pip install "$package"
  else
    echo "Python package $package already installed"
  fi
done

deactivate


================================================
FILE: app/scripts/wait-for-it.sh
================================================
#!/usr/bin/env bash
# Use this script to test if a given TCP host/port are available

WAITFORIT_cmdname=${0##*/}

echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi }

usage()
{
    cat << USAGE >&2
Usage:
    $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args]
    -h HOST | --host=HOST       Host or IP under test
    -p PORT | --port=PORT       TCP port under test
                                Alternatively, you specify the host and port as host:port
    -s | --strict               Only execute subcommand if the test succeeds
    -q | --quiet                Don't output any status messages
    -t TIMEOUT | --timeout=TIMEOUT
                                Timeout in seconds, zero for no timeout
    -- COMMAND ARGS             Execute command with args after the test finishes
USAGE
    exit 1
}

wait_for()
{
    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
        echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
    else
        echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout"
    fi
    WAITFORIT_start_ts=$(date +%s)
    while :
    do
        if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then
            nc -z $WAITFORIT_HOST $WAITFORIT_PORT
            WAITFORIT_result=$?
        else
            (echo -n > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1
            WAITFORIT_result=$?
        fi
        if [[ $WAITFORIT_result -eq 0 ]]; then
            WAITFORIT_end_ts=$(date +%s)
            echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds"
            break
        fi
        sleep 1
    done
    return $WAITFORIT_result
}

wait_for_wrapper()
{
    # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692
    if [[ $WAITFORIT_QUIET -eq 1 ]]; then
        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
    else
        timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT &
    fi
    WAITFORIT_PID=$!
    trap "kill -INT -$WAITFORIT_PID" INT
    wait $WAITFORIT_PID
    WAITFORIT_RESULT=$?
    if [[ $WAITFORIT_RESULT -ne 0 ]]; then
        echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT"
    fi
    return $WAITFORIT_RESULT
}

# process arguments
while [[ $# -gt 0 ]]
do
    case "$1" in
        *:* )
        WAITFORIT_hostport=(${1//:/ })
        WAITFORIT_HOST=${WAITFORIT_hostport[0]}
        WAITFORIT_PORT=${WAITFORIT_hostport[1]}
        shift 1
        ;;
        --child)
        WAITFORIT_CHILD=1
        shift 1
        ;;
        -q | --quiet)
        WAITFORIT_QUIET=1
        shift 1
        ;;
        -s | --strict)
        WAITFORIT_STRICT=1
        shift 1
        ;;
        -h)
        WAITFORIT_HOST="$2"
        if [[ $WAITFORIT_HOST == "" ]]; then break; fi
        shift 2
        ;;
        --host=*)
        WAITFORIT_HOST="${1#*=}"
        shift 1
        ;;
        -p)
        WAITFORIT_PORT="$2"
        if [[ $WAITFORIT_PORT == "" ]]; then break; fi
        shift 2
        ;;
        --port=*)
        WAITFORIT_PORT="${1#*=}"
        shift 1
        ;;
        -t)
        WAITFORIT_TIMEOUT="$2"
        if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi
        shift 2
        ;;
        --timeout=*)
        WAITFORIT_TIMEOUT="${1#*=}"
        shift 1
        ;;
        --)
        shift
        WAITFORIT_CLI=("$@")
        break
        ;;
        --help)
        usage
        ;;
        *)
        echoerr "Unknown argument: $1"
        usage
        ;;
    esac
done

if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then
    echoerr "Error: you need to provide a host and port to test."
    usage
fi

WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15}
WAITFORIT_STRICT=${WAITFORIT_STRICT:-0}
WAITFORIT_CHILD=${WAITFORIT_CHILD:-0}
WAITFORIT_QUIET=${WAITFORIT_QUIET:-0}

# Check to see if timeout is from busybox?
WAITFORIT_TIMEOUT_PATH=$(type -p timeout)
WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH)

WAITFORIT_BUSYTIMEFLAG=""
if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then
    WAITFORIT_ISBUSY=1
    # Check if busybox timeout uses -t flag
    # (recent Alpine versions don't support -t anymore)
    if timeout &>/dev/stdout | grep -q -e '-t '; then
        WAITFORIT_BUSYTIMEFLAG="-t"
    fi
else
    WAITFORIT_ISBUSY=0
fi

if [[ $WAITFORIT_CHILD -gt 0 ]]; then
    wait_for
    WAITFORIT_RESULT=$?
    exit $WAITFORIT_RESULT
else
    if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then
        wait_for_wrapper
        WAITFORIT_RESULT=$?
    else
        wait_for
        WAITFORIT_RESULT=$?
    fi
fi

if [[ $WAITFORIT_CLI != "" ]]; then
    if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then
        echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess"
        exit $WAITFORIT_RESULT
    fi
    exec "${WAITFORIT_CLI[@]}"
else
    exit $WAITFORIT_RESULT
fi


================================================
FILE: app/server/.gitignore
================================================
cloud/

================================================
FILE: app/server/Dockerfile
================================================
FROM golang:1.23.3

# Update and install necessary packages including build tools for Tree-sitter
RUN apt-get update && \
  apt-get install -y git gcc g++ make python3 python3-venv

# Install Python and create a virtual environment for litellm passthrough
RUN python3 -m venv /opt/venv
    
# Activate the virtual environment for all following RUN commands
ENV PATH="/opt/venv/bin:$PATH"

# Now install litellm passthrough dependencies in the virtual environment
RUN pip install --no-cache-dir "litellm==1.72.6" "fastapi==0.115.12" "uvicorn==0.34.1" "google-cloud-aiplatform==1.96.0" "boto3==1.38.40" "botocore==1.38.40"

WORKDIR /app

# Copy go.mod and go.sum for shared and server, and install dependencies
COPY ./shared/go.mod ./shared/go.sum ./shared/
RUN cd shared && go mod download

COPY ./server/go.mod ./server/go.sum ./server/
RUN cd server && go mod download

# Copy the actual source code
COPY ./server ./server
COPY ./shared ./shared
COPY ./scripts /scripts

# Set working directory to server
WORKDIR /app/server

# Build the application
RUN rm -f plandex-server && go build -o plandex-server .

# Set the port and expose it
ENV PORT=8099
EXPOSE 8099

# Command to run the executable
CMD ["./plandex-server"]


================================================
FILE: app/server/db/account_helpers.go
================================================
package db

import (
	"fmt"
	"os"

	"github.com/jmoiron/sqlx"
)

type CreateAccountResult struct {
	User  *User
	OrgId string
	Token string
}

func CreateAccount(name, email, emailVerificationId string, tx *sqlx.Tx) (*CreateAccountResult, error) {
	isLocalMode := (os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1")
	// create user
	user, err := CreateUser(name, email, tx)

	if err != nil {
		return nil, fmt.Errorf("error creating user: %v", err)
	}

	userId := user.Id
	domain := user.Domain

	// create auth token
	token, authTokenId, err := CreateAuthToken(userId, tx)

	if err != nil {
		return nil, fmt.Errorf("error creating auth token: %v", err)
	}

	// skipping email verification in local mode
	if !isLocalMode {
		// update email verification with user and auth token ids
		_, err = tx.Exec("UPDATE email_verifications SET user_id = $1, auth_token_id = $2 WHERE id = $3", userId, authTokenId, emailVerificationId)

		if err != nil {
			return nil, fmt.Errorf("error updating email verification: %v", err)
		}
	}

	// add to org matching domain if one exists and auto add domain users is true for that org
	orgId, err := AddToOrgForDomain(domain, userId, tx)

	if err != nil {
		return nil, fmt.Errorf("error adding user to org for domain: %v", err)
	}

	return &CreateAccountResult{
		User:  user,
		OrgId: orgId,
		Token: token,
	}, nil
}


================================================
FILE: app/server/db/ai_model_helpers.go
================================================
package db


================================================
FILE: app/server/db/auth_helpers.go
================================================
package db

import (
	"crypto/sha256"
	"database/sql"
	"encoding/hex"
	"fmt"
	"log"
	"time"

	"github.com/google/uuid"
	"github.com/jmoiron/sqlx"
	"github.com/pkg/errors"
)

const tokenExpirationDays = 90 // (trial tokens don't expire)

func CreateAuthToken(userId string, tx *sqlx.Tx) (token, id string, err error) {
	uid := uuid.New()
	bytes := uid[:]
	hashBytes := sha256.Sum256(bytes)
	hash := hex.EncodeToString(hashBytes[:])

	err = tx.QueryRow("INSERT INTO auth_tokens (user_id, token_hash) VALUES ($1, $2) RETURNING id", userId, hash).Scan(&id)

	if err != nil {
		return "", "", fmt.Errorf("error creating auth token: %v", err)
	}

	return uid.String(), id, nil
}

func ValidateAuthToken(token string) (*AuthToken, error) {
	uid, err := uuid.Parse(token)

	if err != nil {
		log.Println("error parsing token", err)
		return nil, errors.New("invalid token")
	}

	bytes := uid[:]
	hashBytes := sha256.Sum256(bytes)
	tokenHash := hex.EncodeToString(hashBytes[:])

	var authToken AuthToken
	err = Conn.Get(&authToken, "SELECT * FROM auth_tokens WHERE token_hash = $1 AND created_at > $2 AND deleted_at IS NULL", tokenHash, time.Now().AddDate(0, 0, -tokenExpirationDays))

	if err != nil {
		if err == sql.ErrNoRows {
			log.Println("auth token error - no rows found")
			return nil, errors.New("invalid token")
		}

		return nil, fmt.Errorf("error validating token: %v", err)
	}

	return &authToken, nil
}

func CreateEmailVerification(email string, userId, pinHash string) error {
	var err error
	if userId == "" {
		_, err = Conn.Exec("INSERT INTO email_verifications (email, pin_hash) VALUES ($1, $2)", email, pinHash)
	} else {
		_, err = Conn.Exec("INSERT INTO email_verifications (email, pin_hash, user_id) VALUES ($1, $2, $3)", email, pinHash, userId)
	}

	if err != nil {
		return fmt.Errorf("error creating email verification: %v", err)
	}

	return nil
}

// email verifications expire in 5 minutes
const emailVerificationExpirationMinutes = 5

const InvalidOrExpiredPinError = "invalid or expired pin"

func ValidateEmailVerification(email, pin string) (id string, err error) {
	return validateEmailVerification(email, pin, true, true)
}

func ValidateEmailPreviouslyVerified(email, pin string) (id string, err error) {
	return validateEmailVerification(email, pin, false, false)
}

func validateEmailVerification(email, pin string, enforceExpiration bool, errOnAlreadyVerified bool) (id string, err error) {
	pinHashBytes := sha256.Sum256([]byte(pin))
	pinHash := hex.EncodeToString(pinHashBytes[:])

	var authTokenId *string

	query := `SELECT id, auth_token_id 
              FROM email_verifications
              WHERE pin_hash = $1 
							AND email = $2`

	if enforceExpiration {
		query += ` AND created_at > $3`
		err = Conn.QueryRow(query, pinHash, email, time.Now().Add(-emailVerificationExpirationMinutes*time.Minute)).Scan(&id, &authTokenId)
	} else {
		err = Conn.QueryRow(query, pinHash, email).Scan(&id, &authTokenId)
	}

	if err != nil {
		if err == sql.ErrNoRows {
			return "", errors.New(InvalidOrExpiredPinError)
		}
		return "", fmt.Errorf("error validating email verification: %v", err)
	}

	if authTokenId != nil && errOnAlreadyVerified {
		return "", errors.New("pin already verified")
	} else if authTokenId == nil && !errOnAlreadyVerified {
		return "", errors.New("pin not previously verified")
	}

	return id, nil
}

func CreateSignInCode(userId, orgId, pinHash string) error {
	_, err := Conn.Exec("INSERT INTO sign_in_codes (user_id, org_id, pin_hash) VALUES ($1, $2, $3)", userId, orgId, pinHash)

	if err != nil {
		return fmt.Errorf("error creating sign in code: %v", err)
	}

	return nil
}

const signInCodeExpirationMinutes = 5

type ValidateSignInCodeRes struct {
	Id     string
	OrgId  string
	UserId string
}

func ValidateSignInCode(pin string) (*ValidateSignInCodeRes, error) {
	pinHashBytes := sha256.Sum256([]byte(pin))
	pinHash := hex.EncodeToString(pinHashBytes[:])

	res := &ValidateSignInCodeRes{}
	var authTokenId *string
	query := `SELECT id, org_id, user_id, auth_token_id FROM sign_in_codes WHERE pin_hash = $1 AND created_at > $2`
	err := Conn.QueryRow(query, pinHash, time.Now().Add(-signInCodeExpirationMinutes*time.Minute)).Scan(&res.Id, &res.OrgId, &res.UserId, &authTokenId)

	if err != nil {
		return nil, fmt.Errorf("error validating sign in code: %v", err)
	}

	if authTokenId != nil {
		return nil, errors.New("sign in code already used")
	}

	return res, nil
}

func GetUserPermissions(userId, orgId string) ([]string, error) {
	var permissions []string

	query := `
    SELECT p.name, p.resource_id 
    FROM permissions p
    JOIN org_roles_permissions orp ON p.id = orp.permission_id
    JOIN orgs_users ou ON orp.org_role_id = ou.org_role_id
    WHERE ou.user_id = $1 AND ou.org_id = $2
    `

	rows, err := Conn.Query(query, userId, orgId)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	for rows.Next() {
		var permission string
		var resourceId sql.NullString
		if err := rows.Scan(&permission, &resourceId); err != nil {
			return nil, err
		}

		toAdd := permission
		if resourceId.Valid {
			toAdd = toAdd + "|" + resourceId.String
		}

		permissions = append(permissions, toAdd)
	}

	// Check for errors from iterating over rows.
	if err = rows.Err(); err != nil {
		return nil, err
	}

	return permissions, nil
}


================================================
FILE: app/server/db/branch_helpers.go
================================================
package db

import (
	"context"
	"database/sql"
	"fmt"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

func CreateBranch(repo *GitRepo, plan *Plan, parentBranch *Branch, name string, tx *sqlx.Tx) (*Branch, error) {

	query := `INSERT INTO branches (org_id, owner_id, plan_id, parent_branch_id, name, status, context_tokens, convo_tokens) 
	VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
	RETURNING id, created_at, updated_at`

	var (
		contextTokens  int
		convoTokens    int
		parentBranchId *string
	)

	if parentBranch != nil {
		parentBranchId = &parentBranch.Id

		contextTokens = parentBranch.ContextTokens
		convoTokens = parentBranch.ConvoTokens
	}

	branch := &Branch{
		OrgId:          plan.OrgId,
		OwnerId:        plan.OwnerId,
		PlanId:         plan.Id,
		ParentBranchId: parentBranchId,
		Name:           name,
		Status:         shared.PlanStatusDraft,
	}

	var err error

	if tx == nil {
		err = Conn.QueryRow(
			query,
			branch.OrgId,
			branch.OwnerId,
			branch.PlanId,
			branch.ParentBranchId,
			branch.Name,
			branch.Status,
			contextTokens,
			convoTokens,
		).Scan(
			&branch.Id,
			&branch.CreatedAt,
			&branch.UpdatedAt,
		)
	} else {
		err = tx.QueryRow(
			query,
			branch.OrgId,
			branch.OwnerId,
			branch.PlanId,
			branch.ParentBranchId,
			branch.Name,
			branch.Status,
			contextTokens,
			convoTokens,
		).Scan(
			&branch.Id,
			&branch.CreatedAt,
			&branch.UpdatedAt,
		)
	}

	if err != nil {
		return nil, fmt.Errorf("error creating branch: %v", err)
	}

	// Create the git branch (except for main, which is created by default on repo init)
	if name != "main" {
		// parentBranchName := "main"
		// if parentBranch != nil {
		// 	parentBranchName = parentBranch.Name
		// }

		err = repo.GitCreateBranch(name)

		if err != nil {
			return nil, fmt.Errorf("error creating git branch: %v", err)
		}
	}

	err = IncActiveBranches(plan.Id, 1, tx)

	if err != nil {
		return nil, fmt.Errorf("error incrementing active branches: %v", err)
	}

	return branch, nil
}

func GetDbBranch(planId, name string) (*Branch, error) {
	var branch Branch
	err := Conn.Get(&branch, "SELECT * FROM branches WHERE plan_id = $1 AND name = $2", planId, name)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting branch: %v", err)
	}

	return &branch, nil
}

func ListPlanBranches(repo *GitRepo, planId string) ([]*Branch, error) {
	var branches []*Branch
	err := Conn.Select(&branches, "SELECT * FROM branches WHERE plan_id = $1 ORDER BY created_at", planId)

	if err != nil {
		return nil, fmt.Errorf("error listing branches: %v", err)
	}

	// log.Println("branches: ", spew.Sdump(branches))

	gitBranches, err := repo.GitListBranches()

	if err != nil {
		return nil, fmt.Errorf("error listing git branches: %v", err)
	}

	// log.Println("gitBranches: ", spew.Sdump(gitBranches))

	var nameSet = make(map[string]bool)
	for _, name := range gitBranches {
		nameSet[name] = true
	}

	var res []*Branch
	for _, branch := range branches {
		if nameSet[branch.Name] {
			res = append(res, branch)
		}
	}

	return res, nil
}

func ListBranchesForPlans(orgId string, planIds []string) ([]*Branch, error) {
	var branches []*Branch
	err := Conn.Select(&branches, "SELECT * FROM branches WHERE plan_id = ANY($1) ORDER BY created_at", pq.Array(planIds))

	if err != nil {
		return nil, fmt.Errorf("error listing branches: %v", err)
	}

	return branches, nil
}

func DeleteBranch(ctx context.Context, repo *GitRepo, planId, branch string) error {
	return WithTx(ctx, "delete branch", func(tx *sqlx.Tx) error {

		_, err := tx.Exec("DELETE FROM branches WHERE plan_id = $1 AND name = $2", planId, branch)

		if err != nil {
			return fmt.Errorf("error deleting branch: %v", err)
		}

		err = IncActiveBranches(planId, -1, tx)

		if err != nil {
			return fmt.Errorf("error decrementing active branches: %v", err)
		}

		err = repo.GitDeleteBranch(branch)

		if err != nil {
			return fmt.Errorf("error deleting branch dir: %v", err)
		}

		return err
	})
}


================================================
FILE: app/server/db/build_helpers.go
================================================
package db

import (
	"fmt"
	"time"
)

func StorePlanBuild(build *PlanBuild) error {

	query := `INSERT INTO plan_builds (org_id, plan_id, convo_message_id, file_path) VALUES (:org_id, :plan_id, :convo_message_id, :file_path) RETURNING id, created_at, updated_at`

	args := map[string]interface{}{
		"org_id":           build.OrgId,
		"plan_id":          build.PlanId,
		"convo_message_id": build.ConvoMessageId,
		"file_path":        build.FilePath,
	}

	row, err := Conn.NamedQuery(query, args)
	if err != nil {
		return fmt.Errorf("error storing plan build: %v", err)
	}
	defer row.Close()

	if row.Next() {
		var createdAt, updatedAt time.Time
		var id string
		if err := row.Scan(&id, &createdAt, &updatedAt); err != nil {
			return fmt.Errorf("error storing plan build: %v", err)
		}

		build.Id = id
		build.CreatedAt = createdAt
		build.UpdatedAt = updatedAt
	}

	return nil
}

func SetBuildError(build *PlanBuild) error {
	_, err := Conn.Exec("UPDATE plan_builds SET error = $1 WHERE id = $2", build.Error, build.Id)

	if err != nil {
		return fmt.Errorf("error setting build error: %v", err)
	}

	return nil
}


================================================
FILE: app/server/db/context_helpers_conflicts.go
================================================
package db

import (
	"fmt"
	"log"
	shared "plandex-shared"
	"runtime"
	"runtime/debug"
)

type invalidateConflictedResultsParams struct {
	orgId         string
	planId        string
	filesToUpdate map[string]string
	descriptions  []*ConvoMessageDescription
	currentPlan   *shared.CurrentPlanState
}

func invalidateConflictedResults(params invalidateConflictedResultsParams) error {
	orgId := params.orgId
	planId := params.planId
	filesToUpdate := params.filesToUpdate

	var descriptions []*ConvoMessageDescription

	if params.descriptions == nil {
		var err error
		descriptions, err = GetConvoMessageDescriptions(orgId, planId)
		if err != nil {
			return fmt.Errorf("error getting pending build descriptions: %v", err)
		}
	} else {
		descriptions = params.descriptions
	}

	var currentPlan *shared.CurrentPlanState

	if params.currentPlan == nil {
		var err error
		currentPlan, err = GetCurrentPlanState(CurrentPlanStateParams{
			OrgId:                    orgId,
			PlanId:                   planId,
			ConvoMessageDescriptions: descriptions,
		})
		if err != nil {
			return fmt.Errorf("error getting current plan state: %v", err)
		}
	} else {
		currentPlan = params.currentPlan
	}

	conflictPaths := currentPlan.PlanResult.FileResultsByPath.ConflictedPaths(filesToUpdate)

	// log.Println("invalidateConflictedResults - Conflicted paths:", conflictPaths)

	if len(conflictPaths) > 0 {
		toUpdateDescs := []*ConvoMessageDescription{}

		for _, desc := range descriptions {
			if !desc.DidBuild || desc.AppliedAt != nil {
				continue
			}

			for _, op := range desc.Operations {
				if _, found := conflictPaths[op.Path]; found {
					if desc.BuildPathsInvalidated == nil {
						desc.BuildPathsInvalidated = make(map[string]bool)
					}
					desc.BuildPathsInvalidated[op.Path] = true
					toUpdateDescs = append(toUpdateDescs, desc)
				}
			}
		}

		numRoutines := len(toUpdateDescs) + 1
		errCh := make(chan error, numRoutines)

		for _, desc := range toUpdateDescs {
			go func(desc *ConvoMessageDescription) {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in StoreDescription: %v\n%s", r, debug.Stack())
						errCh <- fmt.Errorf("panic in StoreDescription: %v\n%s", r, debug.Stack())
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()

				err := StoreDescription(desc)

				if err != nil {
					errCh <- fmt.Errorf("error storing description: %v", err)
					return
				}

				errCh <- nil
			}(desc)
		}

		go func() {
			err := DeletePendingResultsForPaths(orgId, planId, conflictPaths)

			if err != nil {
				errCh <- fmt.Errorf("error deleting pending results: %v", err)
				return
			}

			errCh <- nil
		}()

		for i := 0; i < numRoutines; i++ {
			err := <-errCh
			if err != nil {
				return fmt.Errorf("error storing description: %v", err)
			}
		}
	}

	return nil
}


================================================
FILE: app/server/db/context_helpers_get.go
================================================
package db

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"runtime/debug"
	"sort"
	"strings"
	"sync"
)

func GetPlanContexts(orgId, planId string, includeBody, includeMapParts bool) ([]*Context, error) {
	var contexts []*Context
	contextDir := getPlanContextDir(orgId, planId)

	// get all context files
	files, err := os.ReadDir(contextDir)
	if err != nil {
		if os.IsNotExist(err) {
			return contexts, nil
		}

		return nil, fmt.Errorf("error reading context dir: %v", err)
	}

	errCh := make(chan error, len(files))
	var mu sync.Mutex

	// read each context file
	for _, file := range files {
		if strings.HasSuffix(file.Name(), ".meta") {
			go func(file os.DirEntry) {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in GetPlanContexts: %v\n%s", r, debug.Stack())
						errCh <- fmt.Errorf("panic in GetPlanContexts: %v\n%s", r, debug.Stack())
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()
				context, err := GetContext(orgId, planId, strings.TrimSuffix(file.Name(), ".meta"), includeBody, includeMapParts)

				mu.Lock()
				defer mu.Unlock()
				contexts = append(contexts, context)

				if err != nil {
					errCh <- fmt.Errorf("error reading context file: %v", err)
					return
				}

				errCh <- nil
			}(file)
		} else {
			// only processing meta files here, so just send nil for accurate count
			errCh <- nil
		}
	}

	for i := 0; i < len(files); i++ {
		err := <-errCh
		if err != nil {
			return nil, fmt.Errorf("error reading context files: %v", err)
		}
	}

	// sort contexts by CreatedAt
	sort.Slice(contexts, func(i, j int) bool {
		return contexts[i].CreatedAt.Before(contexts[j].CreatedAt)
	})

	return contexts, nil
}

func GetContext(orgId, planId, contextId string, includeBody, includeMapParts bool) (*Context, error) {
	contextDir := getPlanContextDir(orgId, planId)

	// read the meta file
	metaPath := filepath.Join(contextDir, contextId+".meta")

	metaBytes, err := os.ReadFile(metaPath)
	if err != nil {
		return nil, fmt.Errorf("error reading context meta file: %v", err)
	}

	var context Context
	err = json.Unmarshal(metaBytes, &context)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling context meta file: %v", err)
	}

	if includeBody {
		// read the body file
		bodyPath := filepath.Join(contextDir, strings.TrimSuffix(contextId, ".meta")+".body")
		bodyBytes, err := os.ReadFile(bodyPath)

		if err != nil {
			return nil, fmt.Errorf("error reading context body file: %v", err)
		}

		context.Body = string(bodyBytes)
	}

	if includeMapParts {
		// read the map parts file
		mapPartsPath := filepath.Join(contextDir, strings.TrimSuffix(contextId, ".meta")+".map-parts")
		mapPartsBytes, err := os.ReadFile(mapPartsPath)
		if !os.IsNotExist(err) {
			if err != nil {
				return nil, fmt.Errorf("error reading context map parts file: %v", err)
			}

			err = json.Unmarshal(mapPartsBytes, &context.MapParts)
			if err != nil {
				return nil, fmt.Errorf("error unmarshalling context map parts file: %v", err)
			}
		}
	}

	return &context, nil
}


================================================
FILE: app/server/db/context_helpers_load.go
================================================
package db

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"log"
	shared "plandex-shared"
	"runtime"
	"runtime/debug"
	"strings"
	"sync"

	"github.com/google/uuid"
)

// Ctx is a context.Context - to avoid confusion with Plandex contexts
type Ctx context.Context

type LoadContextsParams struct {
	Req                      *shared.LoadContextRequest
	OrgId                    string
	Plan                     *Plan
	BranchName               string
	UserId                   string
	SkipConflictInvalidation bool
	CachedMapsByPath         map[string]*CachedMap
	AutoLoaded               bool
}

func LoadContexts(ctx Ctx, params LoadContextsParams) (*shared.LoadContextResponse, []*Context, error) {
	// startTime := time.Now()
	// showElapsed := func(msg string) {
	// 	elapsed := time.Since(startTime)
	// 	log.Println("LoadContexts", msg, "elapsed: %s\n", elapsed)
	// }

	// log.Println("LoadContexts - params", spew.Sdump(params))

	req := params.Req
	orgId := params.OrgId
	plan := params.Plan
	planId := plan.Id
	branchName := params.BranchName
	userId := params.UserId
	autoLoaded := params.AutoLoaded

	filesToLoad := map[string]string{}
	for _, context := range *req {
		if context.ContextType == shared.ContextFileType {
			filesToLoad[context.FilePath] = context.Body
		}
	}

	if !params.SkipConflictInvalidation {
		err := invalidateConflictedResults(invalidateConflictedResultsParams{
			orgId:         orgId,
			planId:        planId,
			filesToUpdate: filesToLoad,
		})
		if err != nil {
			return nil, nil, fmt.Errorf("error invalidating conflicted results: %v", err)
		}
	}

	tokensAdded := 0
	basicTokensAdded := 0

	paramsByTempId := make(map[string]*shared.LoadContextParams)
	numTokensByTempId := make(map[string]int)

	branch, err := GetDbBranch(planId, branchName)
	if err != nil {
		return nil, nil, fmt.Errorf("error getting branch: %v", err)
	}
	totalTokens := branch.ContextTokens
	totalPlannerTokens := totalTokens
	totalBasicPlannerTokens := 0
	totalMapTokens := 0

	settings, err := GetPlanSettings(plan)
	if err != nil {
		return nil, nil, fmt.Errorf("error getting settings: %v", err)
	}

	planConfig, err := GetPlanConfig(planId)
	if err != nil {
		return nil, nil, fmt.Errorf("error getting plan config: %v", err)
	}

	plannerMaxTokens := settings.GetPlannerEffectiveMaxTokens()
	contextLoaderMaxTokens := settings.GetArchitectEffectiveMaxTokens()

	mapContextsByFilePath := make(map[string]Context)

	existingContexts, err := GetPlanContexts(orgId, planId, false, false)
	if err != nil {
		return nil, nil, fmt.Errorf("error getting existing contexts: %v", err)
	}

	// check overall context limits - these should be getting enforced by the client, so just error out if exceeded
	numExistingContexts := len(existingContexts)
	if numExistingContexts+len(*req) > shared.MaxContextCount {
		return nil, nil, fmt.Errorf("too many contexts: %d", numExistingContexts+len(*req))
	}

	var totalContextSize int64
	for _, context := range existingContexts {
		totalContextSize += context.BodySize
	}
	for _, context := range *req {
		size := int64(len(context.Body))
		totalContextSize += size
		if size > shared.MaxContextBodySize {
			return nil, nil, fmt.Errorf("context body is too large: %d", size)
		}
	}

	if totalContextSize > shared.MaxTotalContextSize {
		return nil, nil, fmt.Errorf("total context size is too large: %d", totalContextSize)
	}

	existingContextsByName := make(map[string]bool)
	for _, context := range existingContexts {
		composite := strings.Join([]string{context.Name, string(context.ContextType)}, "|")
		existingContextsByName[composite] = true

		if planConfig.AutoLoadContext && context.ContextType == shared.ContextMapType {
			totalMapTokens += context.NumTokens
			totalPlannerTokens -= context.NumTokens
		}

		if !context.AutoLoaded && context.ContextType != shared.ContextMapType {
			totalBasicPlannerTokens += context.NumTokens
		}
	}

	var filteredReq []*shared.LoadContextParams
	for _, context := range *req {
		composite := strings.Join([]string{context.Name, string(context.ContextType)}, "|")
		if !existingContextsByName[composite] {
			filteredReq = append(filteredReq, context)
		}
	}

	*req = filteredReq

	for _, contextParams := range *req {
		tempId := uuid.New().String()

		var numTokens int
		var err error

		var isMap bool

		if contextParams.ContextType == shared.ContextMapType && (len(contextParams.MapBodies) > 0 || params.CachedMapsByPath != nil) {
			isMap = true
			var mappedFiles shared.FileMapBodies
			if params.CachedMapsByPath != nil && params.CachedMapsByPath[contextParams.FilePath] != nil {
				log.Println("Using cached map for", contextParams.FilePath)
				mappedFiles = params.CachedMapsByPath[contextParams.FilePath].MapParts
			} else {
				log.Println("Using map bodies for", contextParams.FilePath)
				mappedFiles = contextParams.MapBodies

				// check size and num path limits - these should be getting enforced by the client, so just error out if exceeded
				if len(mappedFiles) > shared.MaxContextMapPaths {
					return nil, nil, fmt.Errorf("map has too many paths: %d", len(mappedFiles))
				}

				totalMapSize := 0
				for _, body := range mappedFiles {
					numBytes := len(body)
					totalMapSize += numBytes
					if numBytes > shared.MaxContextMapSingleInputSize {
						return nil, nil, fmt.Errorf("map input %s is too large: %d", contextParams.FilePath, numBytes)
					}
				}
				if totalMapSize > shared.MaxContextBodySize {
					return nil, nil, fmt.Errorf("map is too large: %d", totalMapSize)
				}

			}

			var mapShas map[string]string
			var mapTokens map[string]int
			var mapSizes map[string]int64

			if params.CachedMapsByPath != nil && params.CachedMapsByPath[contextParams.FilePath] != nil {
				mapShas = params.CachedMapsByPath[contextParams.FilePath].MapShas
				mapTokens = params.CachedMapsByPath[contextParams.FilePath].MapTokens
				mapSizes = params.CachedMapsByPath[contextParams.FilePath].MapSizes
			} else {
				mapShas = contextParams.InputShas
				mapTokens = contextParams.InputTokens
				mapSizes = contextParams.InputSizes
			}

			combinedBody := mappedFiles.CombinedMap(mapTokens)
			numTokens = shared.GetNumTokensEstimate(combinedBody)

			autoLoaded = autoLoaded || contextParams.AutoLoaded

			log.Println("LoadContexts - map - autoLoaded", autoLoaded)

			newContext := Context{
				// Id generated by db layer
				OrgId:       orgId,
				OwnerId:     userId,
				PlanId:      planId,
				ProjectId:   plan.ProjectId,
				ContextType: shared.ContextMapType,
				Name:        contextParams.Name,
				Url:         contextParams.Url,
				FilePath:    contextParams.FilePath,
				NumTokens:   numTokens,
				Body:        combinedBody,
				MapParts:    mappedFiles,
				MapShas:     mapShas,
				MapTokens:   mapTokens,
				MapSizes:    mapSizes,
				AutoLoaded:  autoLoaded || contextParams.AutoLoaded,
			}

			mapContextsByFilePath[contextParams.FilePath] = newContext

		} else if contextParams.ContextType == shared.ContextImageType {
			numTokens, err = shared.GetImageTokens(contextParams.Body, contextParams.ImageDetail)
			if err != nil {
				return nil, nil, fmt.Errorf("error getting image num tokens: %v", err)
			}
		} else {
			numTokens = shared.GetNumTokensEstimate(contextParams.Body)
		}

		paramsByTempId[tempId] = contextParams
		numTokensByTempId[tempId] = numTokens
		totalTokens += numTokens

		// maps don't count toward the token limit if auto-loading
		if planConfig.AutoLoadContext && isMap {
			tokensAdded += numTokens
			totalMapTokens += numTokens
		} else if autoLoaded {
			tokensAdded += numTokens
			totalPlannerTokens += numTokens
		} else {
			tokensAdded += numTokens
			totalPlannerTokens += numTokens
			totalBasicPlannerTokens += numTokens
			basicTokensAdded += numTokens
		}
	}

	// showElapsed("Loaded reqs")
	if planConfig.AutoLoadContext {
		if totalMapTokens > contextLoaderMaxTokens {
			return &shared.LoadContextResponse{
				TokensAdded:       tokensAdded,
				TotalTokens:       totalMapTokens,
				MaxTokens:         contextLoaderMaxTokens,
				MaxTokensExceeded: true,
			}, nil, nil
		}

		if totalBasicPlannerTokens > plannerMaxTokens {
			return &shared.LoadContextResponse{
				TokensAdded:       basicTokensAdded,
				TotalTokens:       totalBasicPlannerTokens,
				MaxTokens:         plannerMaxTokens,
				MaxTokensExceeded: true,
			}, nil, nil
		}
	} else {
		if totalTokens > plannerMaxTokens {
			return &shared.LoadContextResponse{
				TokensAdded:       tokensAdded,
				TotalTokens:       totalTokens,
				MaxTokens:         plannerMaxTokens,
				MaxTokensExceeded: true,
			}, nil, nil
		}
	}

	var dbContexts []*Context
	var apiContexts []*shared.Context
	var mu sync.Mutex

	errCh := make(chan error, len(paramsByTempId))
	for tempId, loadParams := range paramsByTempId {

		go func(tempId string, loadParams *shared.LoadContextParams) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in LoadContexts: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in LoadContexts: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			hash := sha256.Sum256([]byte(loadParams.Body))
			sha := hex.EncodeToString(hash[:])

			var context Context
			if mapContext, ok := mapContextsByFilePath[loadParams.FilePath]; ok {
				context = mapContext
			} else {
				// log.Println("tempId", tempId, "params.FilePath", params.FilePath, "sha", sha)
				// log.Println("params.Body", params.Body)

				context = Context{
					// Id generated by db layer
					OrgId:           orgId,
					OwnerId:         userId,
					PlanId:          planId,
					ProjectId:       plan.ProjectId,
					ContextType:     loadParams.ContextType,
					Name:            loadParams.Name,
					Url:             loadParams.Url,
					FilePath:        loadParams.FilePath,
					NumTokens:       numTokensByTempId[tempId],
					Sha:             sha,
					Body:            loadParams.Body,
					ForceSkipIgnore: loadParams.ForceSkipIgnore,
					ImageDetail:     loadParams.ImageDetail,
					AutoLoaded:      autoLoaded || loadParams.AutoLoaded,
				}
			}

			err := StoreContext(&context, params.CachedMapsByPath != nil)

			if err != nil {
				errCh <- fmt.Errorf("error storing context: %v", err)
				return
			}

			mu.Lock()
			dbContexts = append(dbContexts, &context)
			apiContext := context.ToApi()
			apiContext.Body = ""
			apiContexts = append(apiContexts, apiContext)
			mu.Unlock()

			errCh <- nil
		}(tempId, loadParams)
	}

	for i := 0; i < len(paramsByTempId); i++ {
		err := <-errCh
		if err != nil {
			return nil, nil, fmt.Errorf("error storing context: %v", err)
		}
	}

	err = AddPlanContextTokens(planId, branchName, tokensAdded)
	if err != nil {
		return nil, nil, fmt.Errorf("error adding plan context tokens: %v", err)
	}

	commitMsg := shared.SummaryForLoadContext(apiContexts, tokensAdded, totalTokens)

	if len(apiContexts) > 0 {
		commitMsg += "\n\n" + shared.TableForLoadContext(apiContexts, false)
	}

	return &shared.LoadContextResponse{
		TokensAdded: tokensAdded,
		TotalTokens: totalTokens,
		Msg:         commitMsg,
	}, dbContexts, nil
}


================================================
FILE: app/server/db/context_helpers_map.go
================================================
package db

import (
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	shared "plandex-shared"
)

func GetCachedMap(orgId, projectId, filePath string) (*Context, error) {
	mapCacheDir := getProjectMapCacheDir(orgId, projectId)

	filePathHash := md5.Sum([]byte(filePath))
	filePathHashStr := hex.EncodeToString(filePathHash[:])

	mapCachePath := filepath.Join(mapCacheDir, filePathHashStr+".json")

	log.Println("GetCachedMap - mapCachePath", mapCachePath)

	mapCacheBytes, err := os.ReadFile(mapCachePath)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}

		return nil, fmt.Errorf("error reading cached map: %v", err)
	}

	var context Context
	err = json.Unmarshal(mapCacheBytes, &context)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling cached map: %v", err)
	}

	return &context, nil
}

type CachedMap struct {
	MapParts  shared.FileMapBodies
	MapShas   map[string]string
	MapTokens map[string]int
	MapSizes  map[string]int64
}


================================================
FILE: app/server/db/context_helpers_remove.go
================================================
package db

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	shared "plandex-shared"
	"runtime"
	"runtime/debug"
)

func ContextRemove(orgId, planId string, contexts []*Context) error {
	return contextRemove(contextRemoveParams{
		orgId:    orgId,
		planId:   planId,
		contexts: contexts,
	})
}

type contextRemoveParams struct {
	orgId        string
	planId       string
	contexts     []*Context
	descriptions []*ConvoMessageDescription
	currentPlan  *shared.CurrentPlanState
}

func contextRemove(params contextRemoveParams) error {
	orgId := params.orgId
	planId := params.planId
	contexts := params.contexts

	// remove files
	numFiles := 0

	filesToUpdate := make(map[string]string)

	errCh := make(chan error, numFiles)
	for _, context := range contexts {
		filesToUpdate[context.FilePath] = ""
		contextDir := getPlanContextDir(orgId, planId)
		for _, ext := range []string{".meta", ".body", ".map-parts"} {
			numFiles++
			go func(context *Context, dir, ext string) {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in contextRemove: %v\n%s", r, debug.Stack())
						errCh <- fmt.Errorf("panic in contextRemove: %v\n%s", r, debug.Stack())
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()
				errCh <- os.Remove(filepath.Join(dir, context.Id+ext))
			}(context, contextDir, ext)
		}
	}

	for i := 0; i < numFiles; i++ {
		err := <-errCh
		if err != nil && !os.IsNotExist(err) {
			return fmt.Errorf("error removing context file: %v", err)
		}
	}

	err := invalidateConflictedResults(invalidateConflictedResultsParams{
		orgId:         orgId,
		planId:        planId,
		filesToUpdate: filesToUpdate,
		descriptions:  params.descriptions,
		currentPlan:   params.currentPlan,
	})
	if err != nil {
		return fmt.Errorf("error invalidating conflicted results: %v", err)
	}

	return nil
}

type ClearContextParams struct {
	OrgId       string
	PlanId      string
	SkipMaps    bool
	SkipPending bool
}

func ClearContext(params ClearContextParams) error {
	orgId := params.OrgId
	planId := params.PlanId
	skipMaps := params.SkipMaps
	skipPending := params.SkipPending

	contexts, err := GetPlanContexts(orgId, planId, false, false)
	if err != nil {
		return fmt.Errorf("error getting plan contexts: %v", err)
	}

	var descriptions []*ConvoMessageDescription
	var currentPlan *shared.CurrentPlanState

	if skipPending {
		var err error
		descriptions, err = GetConvoMessageDescriptions(orgId, planId)
		if err != nil {
			return fmt.Errorf("error getting pending build descriptions: %v", err)
		}

		currentPlan, err = GetCurrentPlanState(CurrentPlanStateParams{
			OrgId:                    orgId,
			PlanId:                   planId,
			ConvoMessageDescriptions: descriptions,
		})

		if err != nil {
			return fmt.Errorf("error getting current plan state: %v", err)
		}
	}

	toRemove := []*Context{}

	for _, context := range contexts {
		shouldSkip := false

		if !(skipMaps && context.ContextType == shared.ContextMapType) {
			shouldSkip = true
		}

		if skipPending && currentPlan.CurrentPlanFiles.Files[context.FilePath] != "" {
			shouldSkip = true
		}

		if !shouldSkip {
			toRemove = append(toRemove, context)
		}
	}

	if len(toRemove) > 0 {
		err := contextRemove(contextRemoveParams{
			orgId:        orgId,
			planId:       planId,
			contexts:     toRemove,
			descriptions: descriptions,
			currentPlan:  currentPlan,
		})
		if err != nil {
			return fmt.Errorf("error removing non-map contexts: %v", err)
		}
	}

	return nil
}


================================================
FILE: app/server/db/context_helpers_store.go
================================================
package db

import (
	"crypto/md5"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/google/uuid"
)

func StoreContext(context *Context, skipMapCache bool) error {
	// log.Println("StoreContext - Storing context", context.Id, context.Name, context.ContextType)
	// log.Println("StoreContext - Num tokens", context.NumTokens)

	contextDir := getPlanContextDir(context.OrgId, context.PlanId)

	err := os.MkdirAll(contextDir, os.ModePerm)
	if err != nil {
		return fmt.Errorf("error creating context dir: %v", err)
	}

	ts := time.Now().UTC()
	if context.Id == "" {
		context.Id = uuid.New().String()
		context.CreatedAt = ts
	}
	context.UpdatedAt = ts
	context.BodySize = int64(len(context.Body))

	metaFilename := context.Id + ".meta"
	metaPath := filepath.Join(contextDir, metaFilename)

	originalBody := context.Body
	originalBody = strings.ReplaceAll(originalBody, "\\`\\`\\`", "\\\\`\\\\`\\\\`")
	originalBody = strings.ReplaceAll(originalBody, "```", "\\`\\`\\`")

	bodyFilename := context.Id + ".body"
	bodyPath := filepath.Join(contextDir, bodyFilename)
	body := []byte(originalBody)
	context.Body = ""

	originalMapParts := context.MapParts
	var mapPath string
	var mapBytes []byte
	if len(context.MapParts) > 0 {
		mapFilename := context.Id + ".map-parts"
		mapPath = filepath.Join(contextDir, mapFilename)
		mapBytes, err = json.MarshalIndent(context.MapParts, "", "  ")
		if err != nil {
			return fmt.Errorf("failed to marshal map parts: %v", err)
		}
		context.MapParts = nil
	}

	// Convert the ModelContextPart to JSON
	data, err := json.MarshalIndent(context, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal context context: %v", err)
	}

	// Write the body to the file
	if err = os.WriteFile(bodyPath, body, 0644); err != nil {
		return fmt.Errorf("failed to write context body to file %s: %v", bodyPath, err)
	}

	// Write the meta data to the file
	if err = os.WriteFile(metaPath, data, 0644); err != nil {
		return fmt.Errorf("failed to write context meta to file %s: %v", metaPath, err)
	}

	if mapPath != "" {
		if err = os.WriteFile(mapPath, mapBytes, 0644); err != nil {
			return fmt.Errorf("failed to write context map to file %s: %v", mapPath, err)
		}
	}

	context.Body = originalBody
	context.MapParts = originalMapParts

	if mapPath != "" && !skipMapCache {
		log.Println("StoreContext - context.MapParts length", len(context.MapParts))

		mapCacheDir := getProjectMapCacheDir(context.OrgId, context.ProjectId)

		// ensure map cache dir exists
		err = os.MkdirAll(mapCacheDir, os.ModePerm)
		if err != nil {
			return fmt.Errorf("error creating map cache dir: %v", err)
		}

		filePathHash := md5.Sum([]byte(context.FilePath))
		filePathHashStr := hex.EncodeToString(filePathHash[:])

		mapCachePath := filepath.Join(mapCacheDir, filePathHashStr+".json")

		log.Println("StoreContext - mapCachePath", mapCachePath)

		cachedContext := Context{
			ContextType: shared.ContextMapType,
			FilePath:    context.FilePath,
			Name:        context.Name,
			Body:        context.Body,
			NumTokens:   context.NumTokens,
			MapParts:    context.MapParts,
			MapShas:     context.MapShas,
			MapTokens:   context.MapTokens,
			MapSizes:    context.MapSizes,
			UpdatedAt:   context.UpdatedAt,
		}

		cachedContextBytes, err := json.MarshalIndent(cachedContext, "", "  ")
		if err != nil {
			return fmt.Errorf("failed to marshal cached context: %v", err)
		}

		err = os.WriteFile(mapCachePath, cachedContextBytes, 0644)
		if err != nil {
			return fmt.Errorf("failed to write context map to file %s: %v", mapCachePath, err)
		}
	}

	return nil
}


================================================
FILE: app/server/db/context_helpers_update.go
================================================
package db

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"log"
	shared "plandex-shared"
	"runtime"
	"runtime/debug"
	"sync"
)

type UpdateContextsParams struct {
	Req                      *shared.UpdateContextRequest
	OrgId                    string
	Plan                     *Plan
	BranchName               string
	ContextsById             map[string]*Context
	SkipConflictInvalidation bool
}

func UpdateContexts(params UpdateContextsParams) (*shared.UpdateContextResponse, error) {
	req := params.Req
	orgId := params.OrgId
	plan := params.Plan
	planId := plan.Id
	branchName := params.BranchName

	branch, err := GetDbBranch(planId, branchName)
	if err != nil {
		return nil, fmt.Errorf("error getting branch: %v", err)
	}

	if branch == nil {
		return nil, fmt.Errorf("branch not found")
	}

	totalTokens := branch.ContextTokens
	totalPlannerTokens := totalTokens

	totalMapTokens := 0

	totalBasicPlannerTokens := 0
	for _, context := range params.ContextsById {
		if context.ContextType != shared.ContextMapType && !context.AutoLoaded {
			totalBasicPlannerTokens += context.NumTokens
		}
	}

	settings, err := GetPlanSettings(plan)
	if err != nil {
		return nil, fmt.Errorf("error getting settings: %v", err)
	}

	planConfig, err := GetPlanConfig(planId)
	if err != nil {
		return nil, fmt.Errorf("error getting plan config: %v", err)
	}

	modelPacks, err := ListModelPacks(orgId)
	if err != nil {
		return nil, fmt.Errorf("error getting model packs: %v", err)
	}

	apiModelPacks := make([]*shared.ModelPack, len(modelPacks))
	for i, modelPack := range modelPacks {
		apiModelPacks[i] = modelPack.ToApi()
	}

	plannerMaxTokens := settings.GetPlannerEffectiveMaxTokens()
	contextLoaderMaxTokens := settings.GetArchitectEffectiveMaxTokens()

	if planConfig.AutoLoadContext {
		existingContexts, err := GetPlanContexts(orgId, planId, false, false)
		if err != nil {
			return nil, fmt.Errorf("error getting existing contexts: %v", err)
		}

		for _, context := range existingContexts {
			if context.ContextType == shared.ContextMapType {
				totalMapTokens += context.NumTokens
				totalPlannerTokens -= context.NumTokens
			}
		}
	}

	aggregateTokensDiff := 0
	aggregateBasicTokensDiff := 0
	tokenDiffsById := make(map[string]int)

	var contextsById map[string]*Context
	if params.ContextsById == nil {
		contextsById = make(map[string]*Context)
	} else {
		contextsById = params.ContextsById
	}

	var totalContextCount int
	var totalBodySize int64

	for _, context := range contextsById {
		totalContextCount++
		totalBodySize += context.BodySize
	}

	for id, params := range *req {
		size := int64(len(params.Body))

		if size > shared.MaxContextBodySize {
			return nil, fmt.Errorf("context body is too large: %d", size)
		}

		if context, ok := contextsById[id]; ok {
			totalBodySize += size - context.BodySize
		} else {
			totalContextCount++
			totalBodySize += size
		}
	}

	if totalContextCount > shared.MaxContextCount {
		return nil, fmt.Errorf("too many contexts to update (found %d, limit is %d)", totalContextCount, shared.MaxContextCount)
	}

	if totalBodySize > shared.MaxContextBodySize {
		return nil, fmt.Errorf("total context body size exceeds limit (size %.2f MB, limit %d MB)", float64(totalBodySize)/1024/1024, int(shared.MaxContextBodySize)/1024/1024)
	}

	var updatedContexts []*shared.Context

	numFiles := 0
	numUrls := 0
	numTrees := 0
	numMaps := 0

	var mu sync.Mutex
	errCh := make(chan error, len(*req))

	for id, params := range *req {
		go func(id string, params *shared.UpdateContextParams) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in UpdateContexts: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in UpdateContexts: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			var context *Context
			if _, ok := contextsById[id]; ok {
				context = contextsById[id]
			} else {
				var err error
				context, err = GetContext(orgId, planId, id, true, true)

				if err != nil {
					errCh <- fmt.Errorf("error getting context: %v", err)
					return
				}
				// log.Println("Got context", context.Id, "numTokens", context.NumTokens)
			}

			mu.Lock()
			defer mu.Unlock()

			contextsById[id] = context
			updatedContexts = append(updatedContexts, context.ToApi())

			if context.ContextType != shared.ContextMapType {
				var updateNumTokens int
				var err error

				if context.ContextType == shared.ContextImageType {
					updateNumTokens, err = shared.GetImageTokens(params.Body, context.ImageDetail)
					if err != nil {
						errCh <- fmt.Errorf("error getting num tokens: %v", err)
						return
					}
				} else {
					updateNumTokens = shared.GetNumTokensEstimate(params.Body)
					// log.Println("len(params.Body)", len(params.Body))
				}

				// log.Println("Updating context", id, "updateNumTokens", updateNumTokens)

				tokenDiff := updateNumTokens - context.NumTokens
				tokenDiffsById[id] = tokenDiff
				aggregateTokensDiff += tokenDiff
				totalTokens += tokenDiff
				totalPlannerTokens += tokenDiff
				if !context.AutoLoaded {
					totalBasicPlannerTokens += tokenDiff
					aggregateBasicTokensDiff += tokenDiff
				}
				context.NumTokens = updateNumTokens
			}

			switch context.ContextType {
			case shared.ContextFileType:
				numFiles++
			case shared.ContextURLType:
				numUrls++
			case shared.ContextDirectoryTreeType:
				numTrees++
			case shared.ContextMapType:
				numMaps++
			}

			errCh <- nil
		}(id, params)
	}

	for i := 0; i < len(*req); i++ {
		err := <-errCh
		if err != nil {
			return nil, fmt.Errorf("error getting context: %v", err)
		}
	}

	if planConfig.AutoLoadContext {
		if totalBasicPlannerTokens > plannerMaxTokens {
			return &shared.UpdateContextResponse{
				TokensAdded:       aggregateTokensDiff,
				TotalTokens:       totalBasicPlannerTokens,
				MaxTokens:         plannerMaxTokens,
				MaxTokensExceeded: true,
			}, nil
		}
	}
	filesToLoad := map[string]string{}
	for _, context := range updatedContexts {
		if context.ContextType == shared.ContextFileType {
			filesToLoad[context.FilePath] = (*req)[context.Id].Body
		}
	}

	if !params.SkipConflictInvalidation {
		err = invalidateConflictedResults(invalidateConflictedResultsParams{
			orgId:         orgId,
			planId:        planId,
			filesToUpdate: filesToLoad,
		})
		if err != nil {
			return nil, fmt.Errorf("error invalidating conflicted results: %v", err)
		}
	}

	errCh = make(chan error, len(*req))

	for id, params := range *req {
		go func(id string, params *shared.UpdateContextParams) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in UpdateContexts: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in UpdateContexts: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			context := contextsById[id]

			if context.ContextType == shared.ContextMapType {
				oldNumTokens := context.NumTokens

				for path, part := range params.MapBodies {
					if len(part) > shared.MaxContextMapSingleInputSize {
						errCh <- fmt.Errorf("map input %s is too large: %d", path, len(part))
						return
					}

					if context.MapParts == nil {
						context.MapParts = make(shared.FileMapBodies)
					}
					if context.MapShas == nil {
						context.MapShas = make(map[string]string)
					}
					if context.MapTokens == nil {
						context.MapTokens = make(map[string]int)
					}
					if context.MapSizes == nil {
						context.MapSizes = make(map[string]int64)
					}

					// prevNumTokens := context.MapTokens[path]

					context.MapParts[path] = part
					context.MapShas[path] = params.InputShas[path]
					context.MapTokens[path] = params.InputTokens[path]
					context.MapSizes[path] = params.InputSizes[path]
				}

				for _, path := range params.RemovedMapPaths {
					delete(context.MapParts, path)
					delete(context.MapShas, path)
					delete(context.MapTokens, path)
					delete(context.MapSizes, path)
				}

				if len(context.MapParts) > shared.MaxContextMapPaths {
					errCh <- fmt.Errorf("map has too many paths: %d", len(context.MapParts))
					return
				}

				totalMapSize := 0
				for _, part := range context.MapParts {
					totalMapSize += len(part)
				}
				if totalMapSize > shared.MaxContextBodySize {
					errCh <- fmt.Errorf("map total size is too large: %d", totalMapSize)
					return
				}

				context.Body = context.MapParts.CombinedMap(context.MapTokens)
				newNumTokens := shared.GetNumTokensEstimate(context.Body)
				tokenDiff := newNumTokens - oldNumTokens

				mu.Lock()
				tokenDiffsById[id] = tokenDiff
				aggregateTokensDiff += tokenDiff
				totalTokens += tokenDiff
				if planConfig.AutoLoadContext {
					totalMapTokens += tokenDiff
				} else {
					totalPlannerTokens += tokenDiff
				}
				mu.Unlock()

				context.NumTokens = newNumTokens
			} else {
				context.Body = params.Body
				hash := sha256.Sum256([]byte(context.Body))
				context.Sha = hex.EncodeToString(hash[:])
			}

			// log.Println("storing context", id)
			// log.Printf("context name: %s, sha: %s\n", context.Name, context.Sha)

			err := StoreContext(context, false)

			if err != nil {
				errCh <- fmt.Errorf("error storing context: %v", err)
				return
			}

			// log.Println("stored context", id)
			// log.Println()

			errCh <- nil
		}(id, params)
	}

	for i := 0; i < len(*req); i++ {
		err := <-errCh
		if err != nil {
			return nil, fmt.Errorf("error storing context: %v", err)
		}
	}

	if planConfig.AutoLoadContext {
		if totalMapTokens > contextLoaderMaxTokens {
			return &shared.UpdateContextResponse{
				TokensAdded:       aggregateTokensDiff,
				TotalTokens:       totalTokens,
				MaxTokens:         contextLoaderMaxTokens,
				MaxTokensExceeded: true,
			}, nil
		}
	}

	updateRes := &shared.ContextUpdateResult{
		UpdatedContexts: updatedContexts,
		TokenDiffsById:  tokenDiffsById,
		TokensDiff:      aggregateTokensDiff,
		TotalTokens:     totalTokens,
		NumFiles:        numFiles,
		NumUrls:         numUrls,
		NumTrees:        numTrees,
		NumMaps:         numMaps,
		MaxTokens:       plannerMaxTokens,
	}

	err = AddPlanContextTokens(planId, branchName, aggregateTokensDiff)
	if err != nil {
		return nil, fmt.Errorf("error adding plan context tokens: %v", err)
	}

	commitMsg := shared.SummaryForUpdateContext(shared.SummaryForUpdateContextParams{
		NumFiles:    numFiles,
		NumTrees:    numTrees,
		NumUrls:     numUrls,
		NumMaps:     numMaps,
		TokensDiff:  aggregateTokensDiff,
		TotalTokens: totalTokens,
	}) + "\n\n" + shared.TableForContextUpdate(updateRes)
	return &shared.LoadContextResponse{
		TokensAdded: aggregateTokensDiff,
		TotalTokens: totalTokens,
		Msg:         commitMsg,
	}, nil
}


================================================
FILE: app/server/db/convo_helpers.go
================================================
package db

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"runtime/debug"
	"sort"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/fatih/color"
	"github.com/google/uuid"
	"github.com/sashabaranov/go-openai"
)

func GetPlanConvo(orgId, planId string) ([]*ConvoMessage, error) {
	var convo []*ConvoMessage
	convoDir := getPlanConversationDir(orgId, planId)

	files, err := os.ReadDir(convoDir)
	if err != nil {
		if os.IsNotExist(err) {
			return convo, nil
		}

		return nil, fmt.Errorf("error reading convo dir: %v", err)
	}

	errCh := make(chan error, len(files))
	convoCh := make(chan *ConvoMessage, len(files))

	for _, file := range files {
		go func(file os.DirEntry) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanConvo: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanConvo: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			bytes, err := os.ReadFile(filepath.Join(convoDir, file.Name()))

			if err != nil {
				errCh <- fmt.Errorf("error reading convo file: %v", err)
				return
			}

			var convoMessage ConvoMessage
			err = json.Unmarshal(bytes, &convoMessage)

			if err != nil {
				errCh <- fmt.Errorf("error unmarshalling convo file: %v", err)
				return
			}

			convoCh <- &convoMessage

		}(file)
	}

	for i := 0; i < len(files); i++ {
		select {
		case err := <-errCh:
			return nil, fmt.Errorf("error reading convo files: %v", err)
		case convoMessage := <-convoCh:
			convo = append(convo, convoMessage)
		}
	}

	sort.Slice(convo, func(i, j int) bool {
		return convo[i].CreatedAt.Before(convo[j].CreatedAt)
	})

	return convo, nil
}

func GetConvoMessage(orgId, planId, messageId string) (*ConvoMessage, error) {
	convoDir := getPlanConversationDir(orgId, planId)

	filePath := filepath.Join(convoDir, messageId+".json")

	bytes, err := os.ReadFile(filePath)
	if err != nil {
		return nil, fmt.Errorf("error reading convo message: %v", err)
	}

	var convoMessage ConvoMessage
	err = json.Unmarshal(bytes, &convoMessage)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling convo message: %v", err)
	}

	return &convoMessage, nil
}

func StoreConvoMessage(repo *GitRepo, message *ConvoMessage, currentUserId, branch string, commit bool) (string, error) {
	convoDir := getPlanConversationDir(message.OrgId, message.PlanId)

	ts := time.Now().UTC()

	if message.Id == "" {
		message.Id = uuid.New().String()
	}

	message.CreatedAt = ts

	bytes, err := json.Marshal(message)

	if err != nil {
		return "", fmt.Errorf("error marshalling convo message: %v", err)
	}

	err = os.MkdirAll(convoDir, os.ModePerm)

	if err != nil {
		return "", fmt.Errorf("error creating convo dir: %v", err)
	}

	err = os.WriteFile(filepath.Join(convoDir, message.Id+".json"), bytes, os.ModePerm)

	if err != nil {
		return "", fmt.Errorf("error writing convo message: %v", err)
	}

	err = AddPlanConvoMessage(message, branch)

	if err != nil {
		return "", fmt.Errorf("error adding convo tokens: %v", err)
	}

	var desc string
	if message.Role == openai.ChatMessageRoleUser {
		desc = "💬 User prompt"
		// TODO: add user name
	} else {
		desc = "🤖 Plandex reply"
		if message.Stopped {
			desc += " | 🛑 " + color.New(color.FgHiRed).Sprint("stopped")
		}
	}

	replyTags := message.Flags.GetReplyTags()

	var msg string
	if len(replyTags) > 0 {
		msg = fmt.Sprintf("Message #%d | %s | %s | %d 🪙", message.Num, desc, strings.Join(replyTags, " | "), message.Tokens)
	} else {
		msg = fmt.Sprintf("Message #%d | %s | %d 🪙", message.Num, desc, message.Tokens)
	}

	if len(message.AddedSubtasks) > 0 {
		msg += "\n\n"
		for _, subtask := range message.AddedSubtasks {
			msg += "\n• " + subtask.Title
		}
	}

	if len(message.RemovedSubtasks) > 0 {
		msg += "\n\n"
		msg += "Removed Tasks"
		for _, subtask := range message.RemovedSubtasks {
			msg += "\n• " + subtask
		}
	}

	log.Println("StoreConvoMessage - message.Flags.CurrentStage.TellStage:", message.Flags.CurrentStage.TellStage)
	log.Println("StoreConvoMessage - message.Subtask:", message.Subtask)

	if message.Flags.CurrentStage.TellStage == shared.TellStageImplementation && message.Subtask != nil {
		msg += "\n\n" + "📋 " + message.Subtask.Title
		if len(message.Subtask.UsesFiles) > 0 {
			for _, file := range message.Subtask.UsesFiles {
				msg += "\n • 📄 " + file
			}
		}
	}

	if message.Flags.DidCompletePlan {
		msg += "\n\n" + "🏁 Completed Plan"
	}

	// Cleaner without the cut off message - maybe need a separate command to show both the log and full messages?
	// cutoff := 140
	// if len(message.Message) > cutoff {
	// 	msg += "\n\n" + message.Message[:cutoff] + "..."
	// } else {
	// 	msg += "\n\n" + message.Message
	// }

	if commit {
		log.Printf("[Git] StoreConvoMessage - committing convo message: %s, branch: %s", msg, branch)
		err = repo.GitAddAndCommit(branch, msg)
		if err != nil {
			return "", fmt.Errorf("error committing convo message: %v", err)
		}
	}

	return msg, nil
}


================================================
FILE: app/server/db/data_models.go
================================================
package db

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"time"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

// The models below should only be used server-side.
// Many of them have corresponding models in shared/api for client-side use.
// This adds some duplication, but helps ensure that server-only data doesn't leak to the client.
// Models used client-side have a ToApi() method to convert it to the corresponding client-side model.

type AuthToken struct {
	Id        string     `db:"id"`
	UserId    string     `db:"user_id"`
	TokenHash string     `db:"token_hash"`
	CreatedAt time.Time  `db:"created_at"`
	DeletedAt *time.Time `db:"deleted_at"`
}

type Org struct {
	Id                 string  `db:"id"`
	Name               string  `db:"name"`
	Domain             *string `db:"domain"`
	AutoAddDomainUsers bool    `db:"auto_add_domain_users"`
	OwnerId            string  `db:"owner_id"`
	IsTrial            bool    `db:"is_trial"`

	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

func (org *Org) ToApi() *shared.Org {
	return &shared.Org{
		Id:                 org.Id,
		Name:               org.Name,
		AutoAddDomainUsers: org.AutoAddDomainUsers,
		IsTrial:            org.IsTrial,
	}
}

type User struct {
	Id                string             `db:"id"`
	Name              string             `db:"name"`
	Email             string             `db:"email"`
	Domain            string             `db:"domain"`
	NumNonDraftPlans  int                `db:"num_non_draft_plans"`
	DefaultPlanConfig *shared.PlanConfig `db:"default_plan_config"`
	CreatedAt         time.Time          `db:"created_at"`
	UpdatedAt         time.Time          `db:"updated_at"`
}

func (user *User) ToApi() *shared.User {
	return &shared.User{
		Id:                user.Id,
		Name:              user.Name,
		Email:             user.Email,
		NumNonDraftPlans:  user.NumNonDraftPlans,
		IsTrial:           false, // legacy field
		DefaultPlanConfig: user.DefaultPlanConfig,
	}
}

type Invite struct {
	Id         string     `db:"id"`
	OrgId      string     `db:"org_id"`
	Email      string     `db:"email"`
	Name       string     `db:"name"`
	InviterId  string     `db:"inviter_id"`
	InviteeId  *string    `db:"invitee_id"`
	OrgRoleId  string     `db:"org_role_id"`
	AcceptedAt *time.Time `db:"accepted_at"`
	CreatedAt  time.Time  `db:"created_at"`
	UpdatedAt  time.Time  `db:"updated_at"`
}

func (invite *Invite) ToApi() *shared.Invite {
	return &shared.Invite{
		Id:         invite.Id,
		OrgId:      invite.OrgId,
		Email:      invite.Email,
		Name:       invite.Name,
		InviterId:  invite.InviterId,
		InviteeId:  invite.InviteeId,
		OrgRoleId:  invite.OrgRoleId,
		AcceptedAt: invite.AcceptedAt,
		CreatedAt:  invite.CreatedAt,
	}
}

type OrgUser struct {
	Id        string                `db:"id"`
	OrgId     string                `db:"org_id"`
	OrgRoleId string                `db:"org_role_id"`
	UserId    string                `db:"user_id"`
	Config    *shared.OrgUserConfig `db:"config"`
	CreatedAt time.Time             `db:"created_at"`
	UpdatedAt time.Time             `db:"updated_at"`
}

func (orgUser *OrgUser) ToApi() *shared.OrgUser {
	return &shared.OrgUser{
		OrgId:     orgUser.OrgId,
		OrgRoleId: orgUser.OrgRoleId,
		UserId:    orgUser.UserId,
		Config:    orgUser.Config,
	}
}

type Project struct {
	Id        string    `db:"id"`
	OrgId     string    `db:"org_id"`
	Name      string    `db:"name"`
	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

func (project *Project) ToApi() *shared.Project {
	return &shared.Project{
		Id:   project.Id,
		Name: project.Name,
	}
}

type Plan struct {
	Id              string             `db:"id"`
	OrgId           string             `db:"org_id"`
	OwnerId         string             `db:"owner_id"`
	ProjectId       string             `db:"project_id"`
	Name            string             `db:"name"`
	SharedWithOrgAt *time.Time         `db:"shared_with_org_at,omitempty"`
	TotalReplies    int                `db:"total_replies"`
	ActiveBranches  int                `db:"active_branches"`
	PlanConfig      *shared.PlanConfig `db:"plan_config"`
	ArchivedAt      *time.Time         `db:"archived_at,omitempty"`
	CreatedAt       time.Time          `db:"created_at"`
	UpdatedAt       time.Time          `db:"updated_at"`
}

func (plan *Plan) ToApi() *shared.Plan {
	return &shared.Plan{
		Id:              plan.Id,
		OwnerId:         plan.OwnerId,
		ProjectId:       plan.ProjectId,
		Name:            plan.Name,
		SharedWithOrgAt: plan.SharedWithOrgAt,
		TotalReplies:    plan.TotalReplies,
		ActiveBranches:  plan.ActiveBranches,
		PlanConfig:      plan.PlanConfig,
		ArchivedAt:      plan.ArchivedAt,
		CreatedAt:       plan.CreatedAt,
		UpdatedAt:       plan.UpdatedAt,
	}
}

type Branch struct {
	Id              string            `db:"id"`
	OrgId           string            `db:"org_id"`
	OwnerId         string            `db:"owner_id"`
	PlanId          string            `db:"plan_id"`
	ParentBranchId  *string           `db:"parent_branch_id"`
	Name            string            `db:"name"`
	Status          shared.PlanStatus `db:"status"`
	Error           *string           `db:"error"`
	ContextTokens   int               `db:"context_tokens"`
	ConvoTokens     int               `db:"convo_tokens"`
	SharedWithOrgAt *time.Time        `db:"shared_with_org_at,omitempty"`
	ArchivedAt      *time.Time        `db:"archived_at,omitempty"`
	CreatedAt       time.Time         `db:"created_at"`
	UpdatedAt       time.Time         `db:"updated_at"`
	DeletedAt       *time.Time        `db:"deleted_at"`
}

func (branch *Branch) ToApi() *shared.Branch {
	return &shared.Branch{
		Id:              branch.Id,
		PlanId:          branch.PlanId,
		OwnerId:         branch.OwnerId,
		ParentBranchId:  branch.ParentBranchId,
		Name:            branch.Name,
		Status:          branch.Status,
		ContextTokens:   branch.ContextTokens,
		ConvoTokens:     branch.ConvoTokens,
		SharedWithOrgAt: branch.SharedWithOrgAt,
		ArchivedAt:      branch.ArchivedAt,
		CreatedAt:       branch.CreatedAt,
		UpdatedAt:       branch.UpdatedAt,
	}
}

type ConvoSummary struct {
	Id                          string    `db:"id"`
	OrgId                       string    `db:"org_id"`
	PlanId                      string    `db:"plan_id"`
	LatestConvoMessageId        string    `db:"latest_convo_message_id"`
	LatestConvoMessageCreatedAt time.Time `db:"latest_convo_message_created_at"`
	Summary                     string    `db:"summary"`
	Tokens                      int       `db:"tokens"`
	NumMessages                 int       `db:"num_messages"`
	CreatedAt                   time.Time `db:"created_at"`
}

func (summary *ConvoSummary) ToApi() *shared.ConvoSummary {
	return &shared.ConvoSummary{
		Id:                          summary.Id,
		LatestConvoMessageId:        summary.LatestConvoMessageId,
		LatestConvoMessageCreatedAt: summary.LatestConvoMessageCreatedAt,
		Summary:                     summary.Summary,
		Tokens:                      summary.Tokens,
		NumMessages:                 summary.NumMessages,
		CreatedAt:                   summary.CreatedAt,
	}
}

type PlanBuild struct {
	Id             string    `db:"id"`
	OrgId          string    `db:"org_id"`
	PlanId         string    `db:"plan_id"`
	ConvoMessageId string    `db:"convo_message_id"`
	FilePath       string    `db:"file_path"`
	Error          string    `db:"error"`
	CreatedAt      time.Time `db:"created_at"`
	UpdatedAt      time.Time `db:"updated_at"`
}

func (build *PlanBuild) ToApi() *shared.PlanBuild {
	return &shared.PlanBuild{
		Id:             build.Id,
		ConvoMessageId: build.ConvoMessageId,
		Error:          build.Error,
		FilePath:       build.FilePath,
		CreatedAt:      build.CreatedAt,
		UpdatedAt:      build.UpdatedAt,
	}
}

type OrgRole struct {
	Id          string    `db:"id"`
	OrgId       *string   `db:"org_id"`
	Name        string    `db:"name"`
	Label       string    `db:"label"`
	Description string    `db:"description"`
	CreatedAt   time.Time `db:"created_at"`
	UpdatedAt   time.Time `db:"updated_at"`
}

func (role *OrgRole) ToApi() *shared.OrgRole {
	return &shared.OrgRole{
		Id:          role.Id,
		IsDefault:   role.OrgId == nil,
		Label:       role.Label,
		Description: role.Description,
	}
}

type ModelStream struct {
	Id              string     `db:"id"`
	OrgId           string     `db:"org_id"`
	PlanId          string     `db:"plan_id"`
	InternalIp      string     `db:"internal_ip"`
	Branch          string     `db:"branch"`
	LastHeartbeatAt time.Time  `db:"last_heartbeat_at"`
	CreatedAt       time.Time  `db:"created_at"`
	FinishedAt      *time.Time `db:"finished_at"`
}

// type ModelStreamSubscription struct {
// 	Id            string     `db:"id"`
// 	OrgId         string     `db:"org_id"`
// 	PlanId        string     `db:"plan_id"`
// 	UserId        string     `db:"user_id"`
// 	ModelStreamId string     `db:"model_stream_id"`
// 	UserIp        string     `db:"user_ip"`
// 	CreatedAt     time.Time  `db:"created_at"`
// 	FinishedAt    *time.Time `db:"finished_at"`
// }

type LockScope string

const (
	LockScopeRead  LockScope = "r"
	LockScopeWrite LockScope = "w"
)

type repoLock struct {
	Id              string    `db:"id"`
	OrgId           string    `db:"org_id"`
	UserId          *string   `db:"user_id"`
	PlanId          string    `db:"plan_id"`
	Scope           LockScope `db:"scope"`
	Branch          *string   `db:"branch"`
	PlanBuildId     *string   `db:"plan_build_id"`
	LastHeartbeatAt time.Time `db:"last_heartbeat_at"`
	CreatedAt       time.Time `db:"created_at"`
}

type ModelPack struct {
	Id               string                   `db:"id"`
	OrgId            string                   `db:"org_id"`
	Name             string                   `db:"name"`
	Description      string                   `db:"description"`
	Planner          shared.PlannerRoleConfig `db:"planner"`
	Coder            *shared.ModelRoleConfig  `db:"coder"`
	PlanSummary      shared.ModelRoleConfig   `db:"plan_summary"`
	Builder          shared.ModelRoleConfig   `db:"builder"`
	WholeFileBuilder *shared.ModelRoleConfig  `db:"whole_file_builder"`
	Namer            shared.ModelRoleConfig   `db:"namer"`
	CommitMsg        shared.ModelRoleConfig   `db:"commit_msg"`
	ExecStatus       shared.ModelRoleConfig   `db:"exec_status"`
	Architect        *shared.ModelRoleConfig  `db:"context_loader"`
	CreatedAt        time.Time                `db:"created_at"`
	UpdatedAt        time.Time                `db:"updated_at"`
}

func ModelPackFromApi(apiModelPack *shared.ModelPack) *ModelPack {
	return &ModelPack{
		Name:             apiModelPack.Name,
		Description:      apiModelPack.Description,
		Planner:          apiModelPack.Planner,
		Architect:        apiModelPack.Architect,
		Coder:            apiModelPack.Coder,
		PlanSummary:      apiModelPack.PlanSummary,
		Builder:          apiModelPack.Builder,
		WholeFileBuilder: apiModelPack.WholeFileBuilder,
		Namer:            apiModelPack.Namer,
		CommitMsg:        apiModelPack.CommitMsg,
		ExecStatus:       apiModelPack.ExecStatus,
	}
}

func (modelPack *ModelPack) ToApi() *shared.ModelPack {
	return &shared.ModelPack{
		Id:               modelPack.Id,
		Name:             modelPack.Name,
		Description:      modelPack.Description,
		Planner:          modelPack.Planner,
		Architect:        modelPack.Architect,
		Coder:            modelPack.Coder,
		PlanSummary:      modelPack.PlanSummary,
		Builder:          modelPack.Builder,
		WholeFileBuilder: modelPack.WholeFileBuilder,
		Namer:            modelPack.Namer,
		CommitMsg:        modelPack.CommitMsg,
		ExecStatus:       modelPack.ExecStatus,
	}
}

type CustomModel struct {
	Id                    string                   `db:"id"`
	OrgId                 string                   `db:"org_id"`
	ModelId               shared.ModelId           `db:"model_id"`
	Publisher             shared.ModelPublisher    `db:"publisher"`
	Description           string                   `db:"description"`
	MaxTokens             int                      `db:"max_tokens"`
	DefaultMaxConvoTokens int                      `db:"default_max_convo_tokens"`
	MaxOutputTokens       int                      `db:"max_output_tokens"`
	ReservedOutputTokens  int                      `db:"reserved_output_tokens"`
	HasImageSupport       bool                     `db:"has_image_support"`
	PreferredOutputFormat shared.ModelOutputFormat `db:"preferred_output_format"`

	SystemPromptDisabled   bool                   `db:"system_prompt_disabled"`
	RoleParamsDisabled     bool                   `db:"role_params_disabled"`
	StopDisabled           bool                   `db:"stop_disabled"`
	PredictedOutputEnabled bool                   `db:"predicted_output_enabled"`
	ReasoningEffortEnabled bool                   `db:"reasoning_effort_enabled"`
	ReasoningEffort        shared.ReasoningEffort `db:"reasoning_effort"`
	IncludeReasoning       bool                   `db:"include_reasoning"`
	ReasoningBudget        int                    `db:"reasoning_budget"`
	SupportsCacheControl   bool                   `db:"supports_cache_control"`
	// for anthropic, single message system prompt needs to be flipped to 'user'
	SingleMessageNoSystemPrompt bool `db:"single_message_no_system_prompt"`

	// for anthropic, token estimate padding percentage
	TokenEstimatePaddingPct float64 `db:"token_estimate_padding_pct"`

	Providers CustomModelProviders `db:"providers"`

	CreatedAt time.Time `db:"created_at"`
	UpdatedAt time.Time `db:"updated_at"`
}

func CustomModelFromApi(apiModel *shared.CustomModel) *CustomModel {
	providers := make(CustomModelProviders, len(apiModel.Providers))
	for i, provider := range apiModel.Providers {
		providers[i] = CustomModelUsesProvider{
			Provider:       provider.Provider,
			CustomProvider: provider.CustomProvider,
			ModelName:      provider.ModelName,
		}
	}
	dbModel := CustomModel{
		Id:                          apiModel.Id,
		ModelId:                     apiModel.ModelId,
		Publisher:                   apiModel.Publisher,
		Description:                 apiModel.Description,
		MaxTokens:                   apiModel.MaxTokens,
		HasImageSupport:             apiModel.ModelCompatibility.HasImageSupport,
		DefaultMaxConvoTokens:       apiModel.DefaultMaxConvoTokens,
		MaxOutputTokens:             apiModel.MaxOutputTokens,
		ReservedOutputTokens:        apiModel.ReservedOutputTokens,
		PreferredOutputFormat:       apiModel.PreferredOutputFormat,
		SystemPromptDisabled:        apiModel.SystemPromptDisabled,
		RoleParamsDisabled:          apiModel.RoleParamsDisabled,
		StopDisabled:                apiModel.StopDisabled,
		PredictedOutputEnabled:      apiModel.PredictedOutputEnabled,
		IncludeReasoning:            apiModel.IncludeReasoning,
		ReasoningEffortEnabled:      apiModel.ReasoningEffortEnabled,
		ReasoningEffort:             apiModel.ReasoningEffort,
		ReasoningBudget:             apiModel.ReasoningBudget,
		SupportsCacheControl:        apiModel.SupportsCacheControl,
		SingleMessageNoSystemPrompt: apiModel.SingleMessageNoSystemPrompt,
		TokenEstimatePaddingPct:     apiModel.TokenEstimatePaddingPct,
		Providers:                   providers,
	}

	return &dbModel
}

func (model *CustomModel) ToApi() *shared.CustomModel {
	providers := make([]shared.BaseModelUsesProvider, len(model.Providers))
	for i, provider := range model.Providers {
		providers[i] = *provider.ToApi()
	}
	return &shared.CustomModel{
		Id:          model.Id,
		ModelId:     model.ModelId,
		Publisher:   model.Publisher,
		Description: model.Description,
		BaseModelShared: shared.BaseModelShared{
			DefaultMaxConvoTokens:       model.DefaultMaxConvoTokens,
			MaxTokens:                   model.MaxTokens,
			MaxOutputTokens:             model.MaxOutputTokens,
			ReservedOutputTokens:        model.ReservedOutputTokens,
			PreferredOutputFormat:       model.PreferredOutputFormat,
			SystemPromptDisabled:        model.SystemPromptDisabled,
			RoleParamsDisabled:          model.RoleParamsDisabled,
			StopDisabled:                model.StopDisabled,
			PredictedOutputEnabled:      model.PredictedOutputEnabled,
			IncludeReasoning:            model.IncludeReasoning,
			ReasoningEffortEnabled:      model.ReasoningEffortEnabled,
			ReasoningEffort:             model.ReasoningEffort,
			ReasoningBudget:             model.ReasoningBudget,
			SupportsCacheControl:        model.SupportsCacheControl,
			SingleMessageNoSystemPrompt: model.SingleMessageNoSystemPrompt,
			TokenEstimatePaddingPct:     model.TokenEstimatePaddingPct,

			ModelCompatibility: shared.ModelCompatibility{
				HasImageSupport: model.HasImageSupport,
			},
		},
		Providers: providers,
		CreatedAt: &model.CreatedAt,
		UpdatedAt: &model.UpdatedAt,
	}
}

type ExtraAuthVars []shared.ModelProviderExtraAuthVars

func (e *ExtraAuthVars) Scan(src interface{}) error {
	if src == nil {
		return nil
	}

	switch s := src.(type) {
	case []byte:
		return json.Unmarshal(s, e)
	case string:
		return json.Unmarshal([]byte(s), e)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (e ExtraAuthVars) Value() (driver.Value, error) {
	return json.Marshal(e)
}

type CustomProvider struct {
	Id            string        `db:"id"`
	OrgId         string        `db:"org_id"`
	Name          string        `db:"name"`
	BaseUrl       string        `db:"base_url"`
	SkipAuth      bool          `db:"skip_auth"`
	ApiKeyEnvVar  string        `db:"api_key_env_var"`
	ExtraAuthVars ExtraAuthVars `db:"extra_auth_vars"`
	CreatedAt     time.Time     `db:"created_at"`
	UpdatedAt     time.Time     `db:"updated_at"`
}

func CustomProviderFromApi(apiProvider *shared.CustomProvider) *CustomProvider {
	return &CustomProvider{
		Id:            apiProvider.Id,
		Name:          apiProvider.Name,
		BaseUrl:       apiProvider.BaseUrl,
		SkipAuth:      apiProvider.SkipAuth,
		ApiKeyEnvVar:  apiProvider.ApiKeyEnvVar,
		ExtraAuthVars: apiProvider.ExtraAuthVars,
	}
}

func (provider *CustomProvider) ToApi() *shared.CustomProvider {
	return &shared.CustomProvider{
		Id:            provider.Id,
		Name:          provider.Name,
		BaseUrl:       provider.BaseUrl,
		SkipAuth:      provider.SkipAuth,
		ApiKeyEnvVar:  provider.ApiKeyEnvVar,
		ExtraAuthVars: provider.ExtraAuthVars,
	}
}

type CustomModelUsesProvider struct {
	Provider       shared.ModelProvider `db:"provider"`
	CustomProvider *string              `db:"custom_provider"`
	ModelName      shared.ModelName     `db:"model_name"`
}

func (usesProvider *CustomModelUsesProvider) ToApi() *shared.BaseModelUsesProvider {
	return &shared.BaseModelUsesProvider{
		Provider:       usesProvider.Provider,
		ModelName:      usesProvider.ModelName,
		CustomProvider: usesProvider.CustomProvider,
	}
}

type CustomModelProviders []CustomModelUsesProvider

func (providers *CustomModelProviders) Scan(src interface{}) error {
	if src == nil {
		return nil
	}

	switch s := src.(type) {
	case []byte:
		return json.Unmarshal(s, providers)
	case string:
		return json.Unmarshal([]byte(s), providers)
	}

	return fmt.Errorf("unsupported data type: %T", src)
}

func (providers CustomModelProviders) Value() (driver.Value, error) {
	return json.Marshal(providers)
}

type DefaultPlanSettings struct {
	Id           string              `db:"id"`
	OrgId        string              `db:"org_id"`
	PlanSettings shared.PlanSettings `db:"plan_settings"`
	CreatedAt    time.Time           `db:"created_at"`
	UpdatedAt    time.Time           `db:"updated_at"`
}

// Models below are stored in files, not in the database.
// This allows us to store them in a git repo and use git to manage history.

type Context struct {
	Id              string                `json:"id"`
	OrgId           string                `json:"orgId"`
	OwnerId         string                `json:"ownerId"`
	ProjectId       string                `json:"projectId"`
	PlanId          string                `json:"planId"`
	ContextType     shared.ContextType    `json:"contextType"`
	Name            string                `json:"name"`
	Url             string                `json:"url"`
	FilePath        string                `json:"filePath"`
	Sha             string                `json:"sha"`
	NumTokens       int                   `json:"numTokens"`
	Body            string                `json:"body,omitempty"`
	BodySize        int64                 `json:"bodySize,omitempty"`
	ForceSkipIgnore bool                  `json:"forceSkipIgnore"`
	ImageDetail     openai.ImageURLDetail `json:"imageDetail,omitempty"`
	MapParts        shared.FileMapBodies  `json:"mapParts,omitempty"`
	MapShas         map[string]string     `json:"mapShas,omitempty"`
	MapTokens       map[string]int        `json:"mapTokens,omitempty"`
	MapSizes        map[string]int64      `json:"mapSizes,omitempty"`
	AutoLoaded      bool                  `json:"autoLoaded"`
	CreatedAt       time.Time             `json:"createdAt"`
	UpdatedAt       time.Time             `json:"updatedAt"`
}

func (context *Context) ToMeta() *Context {
	// everything except body and mapParts
	return &Context{
		Id:              context.Id,
		OrgId:           context.OrgId,
		OwnerId:         context.OwnerId,
		ProjectId:       context.ProjectId,
		PlanId:          context.PlanId,
		ContextType:     context.ContextType,
		Name:            context.Name,
		Url:             context.Url,
		FilePath:        context.FilePath,
		Sha:             context.Sha,
		NumTokens:       context.NumTokens,
		BodySize:        context.BodySize,
		ForceSkipIgnore: context.ForceSkipIgnore,
		AutoLoaded:      context.AutoLoaded,
		ImageDetail:     context.ImageDetail,
		MapShas:         context.MapShas,
		MapTokens:       context.MapTokens,
		MapSizes:        context.MapSizes,
		CreatedAt:       context.CreatedAt,
		UpdatedAt:       context.UpdatedAt,
	}
}

func (context *Context) ToApi() *shared.Context {
	return &shared.Context{
		Id:              context.Id,
		OwnerId:         context.OwnerId,
		ContextType:     context.ContextType,
		Name:            context.Name,
		Url:             context.Url,
		FilePath:        context.FilePath,
		Sha:             context.Sha,
		NumTokens:       context.NumTokens,
		Body:            context.Body,
		BodySize:        context.BodySize,
		ForceSkipIgnore: context.ForceSkipIgnore,
		AutoLoaded:      context.AutoLoaded,
		ImageDetail:     context.ImageDetail,
		MapParts:        context.MapParts,
		MapShas:         context.MapShas,
		MapTokens:       context.MapTokens,
		MapSizes:        context.MapSizes,
		CreatedAt:       context.CreatedAt,
		UpdatedAt:       context.UpdatedAt,
	}
}

type ConvoMessage struct {
	Id                    string                   `json:"id"`
	OrgId                 string                   `json:"orgId"`
	PlanId                string                   `json:"planId"`
	UserId                string                   `json:"userId"`
	Role                  string                   `json:"role"`
	Tokens                int                      `json:"tokens"`
	Num                   int                      `json:"num"`
	Message               string                   `json:"message"`
	Stopped               bool                     `json:"stopped"`
	Subtask               *Subtask                 `json:"subtask,omitempty"`
	AddedSubtasks         []*Subtask               `json:"addedSubtasks,omitempty"`
	RemovedSubtasks       []string                 `json:"removedSubtasks,omitempty"`
	Flags                 shared.ConvoMessageFlags `json:"flags"`
	ActivatedPaths        map[string]bool          `json:"activatePaths,omitempty"`
	ActivatedPathsOrdered []string                 `json:"activatePathsOrdered,omitempty"`
	CreatedAt             time.Time                `json:"createdAt"`
}

func (msg *ConvoMessage) ToApi() *shared.ConvoMessage {
	addedSubtasks := make([]*shared.Subtask, len(msg.AddedSubtasks))
	for i, subtask := range msg.AddedSubtasks {
		addedSubtasks[i] = subtask.ToApi()
	}
	return &shared.ConvoMessage{
		Id:              msg.Id,
		UserId:          msg.UserId,
		Role:            msg.Role,
		Tokens:          msg.Tokens,
		Num:             msg.Num,
		Message:         msg.Message,
		Stopped:         msg.Stopped,
		Flags:           msg.Flags,
		Subtask:         msg.Subtask.ToApi(),
		AddedSubtasks:   addedSubtasks,
		RemovedSubtasks: msg.RemovedSubtasks,
		CreatedAt:       msg.CreatedAt,
	}
}

type ConvoMessageDescription struct {
	Id                    string `json:"id"`
	OrgId                 string `json:"orgId"`
	PlanId                string `json:"planId"`
	ConvoMessageId        string `json:"convoMessageId"`
	SummarizedToMessageId string `json:"summarizedToMessageId"`
	WroteFiles            bool   `json:"wroteFiles"`
	CommitMsg             string `json:"commitMsg"`
	// Files                 []string        `json:"files"`
	Operations            []*shared.Operation `json:"operations"`
	Error                 string              `json:"error"`
	DidBuild              bool                `json:"didBuild"`
	BuildPathsInvalidated map[string]bool     `json:"buildPathsInvalidated"`
	AppliedAt             *time.Time          `json:"appliedAt,omitempty"`
	CreatedAt             time.Time           `json:"createdAt"`
	UpdatedAt             time.Time           `json:"updatedAt"`
}

func (desc *ConvoMessageDescription) ToApi() *shared.ConvoMessageDescription {
	return &shared.ConvoMessageDescription{
		Id:                    desc.Id,
		ConvoMessageId:        desc.ConvoMessageId,
		SummarizedToMessageId: desc.SummarizedToMessageId,
		WroteFiles:            desc.WroteFiles,
		CommitMsg:             desc.CommitMsg,
		// Files:                 desc.Files,
		Operations:            desc.Operations,
		DidBuild:              desc.DidBuild,
		BuildPathsInvalidated: desc.BuildPathsInvalidated,
		AppliedAt:             desc.AppliedAt,
		Error:                 desc.Error,
		CreatedAt:             desc.CreatedAt,
		UpdatedAt:             desc.UpdatedAt,
	}
}

type PlanFileResult struct {
	Id                  string `json:"id"`
	TypeVersion         int    `json:"typeVersion"`
	ReplaceWithLineNums bool   `json:"replaceWithLineNums"`
	OrgId               string `json:"orgId"`
	PlanId              string `json:"planId"`
	ConvoMessageId      string `json:"convoMessageId"`
	PlanBuildId         string `json:"planBuildId"`
	Path                string `json:"path"`
	Content             string `json:"content,omitempty"`

	Replacements []*shared.Replacement `json:"replacements"`

	RemovedFile bool `json:"removedFile"`

	AnyFailed bool   `json:"anyFailed"`
	Error     string `json:"error"`

	SyntaxErrors []string `json:"syntaxErrors"`

	AppliedAt  *time.Time `json:"appliedAt,omitempty"`
	RejectedAt *time.Time `json:"rejectedAt,omitempty"`
	CreatedAt  time.Time  `json:"createdAt"`
	UpdatedAt  time.Time  `json:"updatedAt"`
}

func (res *PlanFileResult) ToApi() *shared.PlanFileResult {
	return &shared.PlanFileResult{
		Id:                  res.Id,
		TypeVersion:         res.TypeVersion,
		ReplaceWithLineNums: res.ReplaceWithLineNums,
		PlanBuildId:         res.PlanBuildId,
		ConvoMessageId:      res.ConvoMessageId,
		Path:                res.Path,
		Content:             res.Content,
		AnyFailed:           res.AnyFailed,
		AppliedAt:           res.AppliedAt,
		RejectedAt:          res.RejectedAt,
		Replacements:        res.Replacements,
		RemovedFile:         res.RemovedFile,
		CreatedAt:           res.CreatedAt,
		UpdatedAt:           res.UpdatedAt,
	}
}

type PlanApply struct {
	Id                         string    `json:"id"`
	OrgId                      string    `json:"orgId"`
	PlanId                     string    `json:"planId"`
	UserId                     string    `json:"userId"`
	ConvoMessageIds            []string  `json:"convoMessageIds"`
	ConvoMessageDescriptionIds []string  `json:"convoMessageDescriptionIds"`
	PlanFileResultIds          []string  `json:"planFileResultIds"`
	CommitMsg                  string    `json:"commitMsg"`
	CreatedAt                  time.Time `json:"createdAt"`
}

func (apply *PlanApply) ToApi() *shared.PlanApply {
	return &shared.PlanApply{
		Id:                         apply.Id,
		UserId:                     apply.UserId,
		ConvoMessageIds:            apply.ConvoMessageIds,
		ConvoMessageDescriptionIds: apply.ConvoMessageDescriptionIds,
		PlanFileResultIds:          apply.PlanFileResultIds,
		CommitMsg:                  apply.CommitMsg,
		CreatedAt:                  apply.CreatedAt,
	}
}

type Subtask struct {
	Title       string   `json:"title"`
	Description string   `json:"description"`
	UsesFiles   []string `json:"usesFiles"`
	IsFinished  bool     `json:"isFinished"`
	NumTries    int      `json:"numTries"`
}

func (subtask *Subtask) ToApi() *shared.Subtask {
	if subtask == nil {
		return nil
	}
	return &shared.Subtask{
		Title:       subtask.Title,
		Description: subtask.Description,
		UsesFiles:   subtask.UsesFiles,
		IsFinished:  subtask.IsFinished,
	}
}


================================================
FILE: app/server/db/db.go
================================================
package db

import (
	"errors"
	"fmt"
	"log"
	"net/url"
	"os"
	"strings"

	"github.com/golang-migrate/migrate/v4"
	"github.com/golang-migrate/migrate/v4/database/postgres"
	_ "github.com/golang-migrate/migrate/v4/source/file"
	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"
)

var Conn *sqlx.DB

const LockTimeout = 4000
const IdleInTransactionSessionTimeout = 90000
const StatementTimeout = 30000

func Connect() error {
	var err error

	dbUrl := os.Getenv("DATABASE_URL")
	if dbUrl == "" {
		if os.Getenv("DB_HOST") != "" &&
			os.Getenv("DB_PORT") != "" &&
			os.Getenv("DB_USER") != "" &&
			os.Getenv("DB_PASSWORD") != "" &&
			os.Getenv("DB_NAME") != "" {
			encodedPassword := url.QueryEscape(os.Getenv("DB_PASSWORD"))

			dbUrl = "postgres://" + os.Getenv("DB_USER") + ":" + encodedPassword + "@" + os.Getenv("DB_HOST") + ":" + os.Getenv("DB_PORT") + "/" + os.Getenv("DB_NAME")
		}

		if dbUrl == "" {
			return errors.New("DATABASE_URL or DB_HOST, DB_PORT, DB_USER, DB_PASSWORD, and DB_NAME environment variables must be set")
		}
	}

	if strings.Contains(dbUrl, "?") {
		dbUrl += fmt.Sprintf("&statement_timeout=%d&lock_timeout=%d&timezone=UTC&idle_in_transaction_session_timeout=%d", StatementTimeout, LockTimeout, IdleInTransactionSessionTimeout)
	} else {
		dbUrl += fmt.Sprintf("?statement_timeout=%d&lock_timeout=%d&timezone=UTC&idle_in_transaction_session_timeout=%d", StatementTimeout, LockTimeout, IdleInTransactionSessionTimeout)
	}

	Conn, err = sqlx.Connect("postgres", dbUrl)
	if err != nil {
		return err
	}

	log.Println("connected to database")

	if os.Getenv("GOENV") == "production" {
		Conn.SetMaxOpenConns(50)
		Conn.SetMaxIdleConns(20)
	} else {
		Conn.SetMaxOpenConns(10)
		Conn.SetMaxIdleConns(5)
	}

	// Verify settings
	type setting struct {
		Name    string  `db:"name"`
		Setting string  `db:"setting"`
		Unit    *string `db:"unit"`
		Context string  `db:"context"`
	}

	var settings []setting
	err = Conn.Select(&settings, `
		SELECT name, setting, unit, context 
		FROM pg_settings 
		WHERE name IN ('statement_timeout', 'lock_timeout', 'TimeZone', 'idle_in_transaction_session_timeout')
`)
	if err != nil {
		return fmt.Errorf("error checking settings: %v", err)
	}

	s := ""
	for _, setting := range settings {
		unitStr := ""
		if setting.Unit != nil {
			unitStr = " " + *setting.Unit // Add a leading space only if there's a unit
		}
		s += fmt.Sprintf("- %s = %s%s (context: %s)\n", setting.Name, setting.Setting, unitStr, setting.Context)
	}
	log.Printf("\n\nDatabase settings:\n%s\n", s)

	return nil
}

func MigrationsUp() error {
	migrationsDir := "migrations"
	if os.Getenv("MIGRATIONS_DIR") != "" {
		migrationsDir = os.Getenv("MIGRATIONS_DIR")
	}

	return migrationsUp(migrationsDir)
}

func MigrationsUpWithDir(dir string) error {
	return migrationsUp(dir)
}

func migrationsUp(dir string) error {
	if Conn == nil {
		return errors.New("db not initialized")
	}

	driver, err := postgres.WithInstance(Conn.DB, &postgres.Config{})

	if err != nil {
		return fmt.Errorf("error creating postgres driver: %v", err)
	}

	m, err := migrate.NewWithDatabaseInstance(
		"file://"+dir,
		"postgres", driver)

	if err != nil {
		return fmt.Errorf("error creating migration instance: %v", err)
	}

	// Uncomment below (and update migration version) to reset migration state to a specific version after a failure
	// if os.Getenv("GOENV") == "development" {
	// 	migrateVersion := 2025052900
	// 	if err := m.Force(migrateVersion); err != nil {
	// 		return fmt.Errorf("error forcing migration version: %v", err)
	// 	}
	// }

	// Uncomment below to run down migrations (RESETS DATABASE!!)
	// if os.Getenv("GOENV") == "development" {
	// 	err = m.Down()
	// 	if err != nil {
	// 		if err == migrate.ErrNoChange {
	// 			log.Println("no migrations to run down")
	// 		} else {
	// 			return fmt.Errorf("error running down migrations: %v", err)
	// 		}
	// 	}
	// 	log.Println("ran down migrations - database was reset")
	// }

	// Uncomment below and edit 'stepsBack' to go back a specific number of migrations
	// if os.Getenv("GOENV") == "development" {
	// 	stepsBack := 1
	// 	err = m.Steps(-stepsBack)
	// 	if err != nil {
	// 		return fmt.Errorf("error running down migrations: %v", err)
	// 	}
	// 	log.Printf("went down %d migration\n", stepsBack)
	// }

	err = m.Up()

	if err != nil {
		if err == migrate.ErrNoChange {
			log.Println("migration state is up to date")
		} else {

			return fmt.Errorf("error running migrations: %v", err)
		}
	}

	if err == nil {
		log.Println("ran migrations successfully")
	}

	return nil
}


================================================
FILE: app/server/db/diff_helpers.go
================================================
package db

import (
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"runtime/debug"

	shared "plandex-shared"
)

func GetPlanDiffs(orgId, planId string, plain bool) (string, error) {
	planState, err := GetCurrentPlanState(CurrentPlanStateParams{
		OrgId:  orgId,
		PlanId: planId,
	})

	if err != nil {
		return "", fmt.Errorf("error getting current plan state: %v", err)
	}

	// create temp directory
	tempDirPath, err := os.MkdirTemp(getOrgDir(orgId), "tmp-diffs-*")

	if err != nil {
		return "", fmt.Errorf("error creating temp dir: %v", err)
	}

	defer func() {
		go os.RemoveAll(tempDirPath)
	}()

	// init a git repo in the temp dir
	err = initGitRepo(tempDirPath)

	if err != nil {
		return "", fmt.Errorf("error initializing git repo: %v", err)
	}

	files := planState.CurrentPlanFiles.Files
	removed := planState.CurrentPlanFiles.Removed

	// write the original files to the temp dir
	errCh := make(chan error, len(planState.ContextsByPath))
	hasAnyOriginal := false

	for path, context := range planState.ContextsByPath {
		go func(path string, context *shared.Context) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			_, hasPath := files[path]
			_, hasRemoved := removed[path]
			if hasPath || hasRemoved {
				hasAnyOriginal = true
				// ensure file directory exists
				err = os.MkdirAll(filepath.Dir(filepath.Join(tempDirPath, path)), 0755)
				if err != nil {
					errCh <- fmt.Errorf("error creating directory: %v", err)
					return
				}

				err = os.WriteFile(filepath.Join(tempDirPath, path), []byte(context.Body), 0644)
				if err != nil {
					errCh <- fmt.Errorf("error writing file: %v", err)
					return
				}
			}
			errCh <- nil
		}(path, context)
	}

	for range planState.ContextsByPath {
		err = <-errCh
		if err != nil {
			return "", fmt.Errorf("error writing original files to temp dir: %v", err)
		}
	}

	if hasAnyOriginal {
		// add and commit the files in the temp dir
		err := gitAdd(tempDirPath, ".")
		if err != nil {
			return "", fmt.Errorf("error adding files to git repository for dir: %s, err: %v", tempDirPath, err)
		}

		err = gitCommit(tempDirPath, "original files")
		if err != nil {
			return "", fmt.Errorf("error committing files to git repository for dir: %s, err: %v", tempDirPath, err)
		}
	}

	// write the current files to the temp dir
	errCh = make(chan error, len(files))

	for path, file := range files {
		go func(path, file string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			// ensure file directory exists
			err = os.MkdirAll(filepath.Dir(filepath.Join(tempDirPath, path)), 0755)
			if err != nil {
				errCh <- fmt.Errorf("error creating directory: %v", err)
				return
			}

			err = os.WriteFile(filepath.Join(tempDirPath, path), []byte(file), 0644)
			if err != nil {
				errCh <- fmt.Errorf("error writing file: %v", err)
				return
			}
			errCh <- nil
		}(path, file)
	}

	for path, shouldRemove := range removed {
		go func(path string, shouldRemove bool) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanDiffs: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			if shouldRemove {
				err = os.RemoveAll(filepath.Join(tempDirPath, path))
				if err != nil {
					errCh <- fmt.Errorf("error removing file: %v", err)
					return
				}
			}
			errCh <- nil
		}(path, shouldRemove)
	}

	for i := 0; i < len(files)+len(removed); i++ {
		err = <-errCh
		if err != nil {
			return "", fmt.Errorf("error applying changes to temp dir: %v", err)
		}
	}

	err = gitAdd(tempDirPath, ".")
	if err != nil {
		return "", fmt.Errorf("error adding files to git repository for dir: %s, err: %v", tempDirPath, err)
	}

	colorArg := "--color=always"
	if plain {
		colorArg = "--no-color"
	}
	res, err := exec.Command("git", "-C", tempDirPath, "diff", "--cached", colorArg).CombinedOutput()

	if err != nil {
		return "", fmt.Errorf("error getting diffs: %v", err)
	}

	return string(res), nil
}


================================================
FILE: app/server/db/fs.go
================================================
package db

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
)

var BaseDir string

func init() {
	home, err := os.UserHomeDir()
	if err != nil {
		panic(fmt.Errorf("error getting user home dir: %v", err))
	}

	log.Println("Plandex server home dir:", home)
	log.Println("os.Getenv(PLANDEX_BASE_DIR):", os.Getenv("PLANDEX_BASE_DIR"))
	log.Println("GOENV:", os.Getenv("GOENV"))
	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		log.Println("Local mode enabled")
	}

	BaseDir = os.Getenv("PLANDEX_BASE_DIR")

	if BaseDir == "" {
		if os.Getenv("GOENV") == "development" {
			BaseDir = filepath.Join(home, "plandex-server")
		} else {
			BaseDir = "/plandex-server"
		}
	}

	log.Printf("File system dir: %v\n", BaseDir)
}

func InitPlan(orgId, planId string) error {
	dir := getPlanDir(orgId, planId)
	err := os.MkdirAll(dir, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error creating plan dir: %v", err)
	}

	for _, subdirFn := range [](func(orgId, planId string) string){
		getPlanContextDir,
		getPlanConversationDir,
		getPlanResultsDir,
		getPlanDescriptionsDir} {
		err = os.MkdirAll(subdirFn(orgId, planId), os.ModePerm)

		if err != nil {
			return fmt.Errorf("error creating plan subdir: %v", err)
		}
	}

	err = InitGitRepo(orgId, planId)

	if err != nil {
		return fmt.Errorf("error initializing git repo: %v", err)
	}

	return nil
}

func DeletePlanDir(orgId, planId string) error {
	dir := getPlanDir(orgId, planId)
	err := os.RemoveAll(dir)

	if err != nil {
		return fmt.Errorf("error deleting plan dir: %v", err)
	}

	return nil
}

func getOrgDir(orgId string) string {
	return filepath.Join(BaseDir, "orgs", orgId)
}

func getProjectDir(orgId, projectId string) string {
	return filepath.Join(getOrgDir(orgId), "projects", projectId)
}

func getProjectMapCacheDir(orgId, projectId string) string {
	return filepath.Join(getProjectDir(orgId, projectId), "map_cache")
}

func getPlanDir(orgId, planId string) string {
	return filepath.Join(getOrgDir(orgId), "plans", planId)
}

func getPlanContextDir(orgId, planId string) string {
	return filepath.Join(getPlanDir(orgId, planId), "context")
}

func getPlanConversationDir(orgId, planId string) string {
	return filepath.Join(getPlanDir(orgId, planId), "conversation")
}

func getPlanResultsDir(orgId, planId string) string {
	return filepath.Join(getPlanDir(orgId, planId), "results")
}

func getPlanAppliesDir(orgId, planId string) string {
	return filepath.Join(getPlanDir(orgId, planId), "applies")
}

func getPlanDescriptionsDir(orgId, planId string) string {
	return filepath.Join(getPlanDir(orgId, planId), "descriptions")
}


================================================
FILE: app/server/db/git.go
================================================
package db

import (
	"bytes"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"runtime/debug"
	"strconv"
	"strings"
	"time"

	"github.com/fatih/color"
)

const (
	maxGitRetries     = 5
	baseGitRetryDelay = 100 * time.Millisecond
)

func init() {
	// ensure git is available
	cmd := exec.Command("git", "--version")
	if err := cmd.Run(); err != nil {
		panic(fmt.Errorf("error running git --version: %v", err))
	}
}

type GitRepo struct {
	orgId  string
	planId string
}

func InitGitRepo(orgId, planId string) error {
	dir := getPlanDir(orgId, planId)
	return initGitRepo(dir)
}

func initGitRepo(dir string) error {
	// Set the default branch name to 'main' for the new repository
	res, err := exec.Command("git", "-C", dir, "init", "-b", "main").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error initializing git repository with 'main' as default branch for dir: %s, err: %v, output: %s", dir, err, string(res))
	}

	// Configure user name and email for the repository
	if err := setGitConfig(dir, "user.email", "server@plandex.ai"); err != nil {
		return err
	}
	if err := setGitConfig(dir, "user.name", "Plandex"); err != nil {
		return err
	}

	return nil
}

func getGitRepo(orgId, planId string) *GitRepo {
	return &GitRepo{
		orgId:  orgId,
		planId: planId,
	}
}

func (repo *GitRepo) GitAddAndCommit(branch, message string) error {
	log.Printf("[Git] GitAddAndCommit - orgId: %s, planId: %s, branch: %s, message: %s", repo.orgId, repo.planId, branch, message)
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		return gitAdd(dir, ".")
	}, dir, fmt.Sprintf("GitAddAndCommit > gitAdd: plan=%s branch=%s", planId, branch))
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
	}

	err = gitWriteOperation(func() error {
		return gitCommit(dir, message)
	}, dir, fmt.Sprintf("GitAddAndCommit > gitCommit: plan=%s branch=%s", planId, branch))
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v", dir, err)
	}

	// log.Println("[Git] GitAddAndCommit - finished, logging repo state")

	// repo.LogGitRepoState()

	return nil
}

func (repo *GitRepo) GitRewindToSha(branch, sha string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		return gitRewindToSha(dir, sha)
	}, dir, fmt.Sprintf("GitRewindToSha > gitRewindToSha: plan=%s branch=%s", planId, branch))
	if err != nil {
		return fmt.Errorf("error rewinding git repository for dir: %s, err: %v", dir, err)
	}

	return nil
}

func (repo *GitRepo) GetCurrentCommitSha() (sha string, err error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	cmd := exec.Command("git", "-C", dir, "rev-parse", "HEAD")
	output, err := cmd.Output()
	if err != nil {
		return "", fmt.Errorf("error getting current commit SHA for dir: %s, err: %v", dir, err)
	}

	sha = strings.TrimSpace(string(output))
	return sha, nil
}

func (repo *GitRepo) GetCommitTime(branch, ref string) (time.Time, error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	// Use git show to get the commit timestamp
	cmd := exec.Command("git", "-C", dir, "show", "-s", "--format=%ct", ref)
	output, err := cmd.Output()
	if err != nil {
		return time.Time{}, fmt.Errorf("error getting commit time for ref %s: %v", ref, err)
	}

	// Parse the Unix timestamp
	timestamp, err := strconv.ParseInt(strings.TrimSpace(string(output)), 10, 64)
	if err != nil {
		return time.Time{}, fmt.Errorf("error parsing commit timestamp for ref %s: %v", ref, err)
	}

	// Convert Unix timestamp to time.Time
	commitTime := time.Unix(timestamp, 0)
	return commitTime, nil
}

func (repo *GitRepo) GitResetToSha(sha string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		cmd := exec.Command("git", "-C", dir, "reset", "--hard", sha)
		_, err := cmd.Output()
		if err != nil {
			return fmt.Errorf("error resetting git repository to SHA for dir: %s, sha: %s, err: %v", dir, sha, err)
		}

		return nil
	}, dir, fmt.Sprintf("GitResetToSha > gitReset: plan=%s sha=%s", planId, sha))

	if err != nil {
		return fmt.Errorf("error resetting git repository to SHA for dir: %s, sha: %s, err: %v", dir, sha, err)
	}

	return nil
}

func (repo *GitRepo) GitCheckoutSha(sha string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		cmd := exec.Command("git", "-C", dir, "checkout", sha)
		_, err := cmd.Output()
		if err != nil {
			return fmt.Errorf("error checking out git repository at SHA for dir: %s, sha: %s, err: %v", dir, sha, err)
		}

		return nil
	}, dir, fmt.Sprintf("GitCheckoutSha > gitCheckout: plan=%s sha=%s", planId, sha))

	if err != nil {
		return fmt.Errorf("error checking out git repository at SHA for dir: %s, sha: %s, err: %v", dir, sha, err)
	}

	return nil
}

func (repo *GitRepo) GetGitCommitHistory(branch string) (body string, shas []string, err error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	body, shas, err = getGitCommitHistory(dir)
	if err != nil {
		return "", nil, fmt.Errorf("error getting git history for dir: %s, err: %v", dir, err)
	}

	return body, shas, nil
}

func (repo *GitRepo) GetLatestCommit(branch string) (sha, body string, err error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	sha, body, err = getLatestCommit(dir)
	if err != nil {
		return "", "", fmt.Errorf("error getting latest commit for dir: %s, err: %v", dir, err)
	}

	return sha, body, nil
}

func (repo *GitRepo) GetLatestCommitShaBeforeTime(branch string, before time.Time) (sha string, err error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	log.Printf("ADMIN - GetLatestCommitShaBeforeTime - dir: %s, before: %s", dir, before.Format("2006-01-02T15:04:05Z"))

	// Round up to the next second
	// roundedTime := before.Add(time.Second).Truncate(time.Second)

	gitFormattedTime := before.Format("2006-01-02 15:04:05+0000")

	// log.Printf("ADMIN - Git formatted time: %s", gitFormattedTime)

	cmd := exec.Command("git", "-C", dir, "log", "-n", "1",
		"--before="+gitFormattedTime,
		"--pretty=%h@@|@@%B@>>>@")
	log.Printf("ADMIN - Executing command: %s", cmd.String())
	res, err := cmd.CombinedOutput()
	if err != nil {
		return "", fmt.Errorf("error getting latest commit before time for dir: %s, err: %v, output: %s", dir, err, string(res))
	}

	// log.Printf("ADMIN - git log res: %s", string(res))

	output := strings.TrimSpace(string(res))

	// history := processGitHistoryOutput(strings.TrimSpace(string(res)))

	// log.Printf("ADMIN - History: %v", history)

	if output == "" {
		return "", fmt.Errorf("no commits found before time: %s", before.Format("2006-01-02T15:04:05Z"))
	}

	sha = strings.Split(output, "@@|@@")[0]
	return sha, nil
}

func (repo *GitRepo) GitListBranches() ([]string, error) {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	var out bytes.Buffer
	cmd := exec.Command("git", "branch", "--format=%(refname:short)")
	cmd.Dir = dir
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		return nil, fmt.Errorf("error getting git branches for dir: %s, err: %v", dir, err)
	}

	branches := strings.Split(strings.TrimSpace(out.String()), "\n")

	if len(branches) == 0 || (len(branches) == 1 && branches[0] == "") {
		return []string{"main"}, nil
	}

	return branches, nil
}

func (repo *GitRepo) GitCreateBranch(newBranch string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		res, err := exec.Command("git", "-C", dir, "checkout", "-b", newBranch).CombinedOutput()
		if err != nil {
			return fmt.Errorf("error creating git branch for dir: %s, err: %v, output: %s", dir, err, string(res))
		}

		return nil
	}, dir, fmt.Sprintf("GitCreateBranch > gitCheckout: plan=%s branch=%s", planId, newBranch))

	if err != nil {
		return err
	}

	return nil
}

func (repo *GitRepo) GitDeleteBranch(branchName string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		res, err := exec.Command("git", "-C", dir, "branch", "-D", branchName).CombinedOutput()
		if err != nil {
			return fmt.Errorf("error deleting git branch for dir: %s, err: %v, output: %s", dir, err, string(res))
		}

		return nil
	}, dir, fmt.Sprintf("GitDeleteBranch > gitBranch: plan=%s branch=%s", planId, branchName))

	if err != nil {
		return err
	}

	return nil
}

func (repo *GitRepo) GitClearUncommittedChanges(branch string) error {
	orgId := repo.orgId
	planId := repo.planId

	log.Printf("[Git] GitClearUncommittedChanges - orgId: %s, planId: %s, branch: %s", orgId, planId, branch)

	dir := getPlanDir(orgId, planId)

	// first do a lightweight git status to check if there are any uncommitted changes
	// prevents heavier operations below if there are no changes (the usual case)
	res, err := exec.Command("git", "status", "--porcelain").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error checking for uncommitted changes: %v, output: %s", err, string(res))
	}

	// If there's output, there are uncommitted changes
	hasChanges := strings.TrimSpace(string(res)) != ""

	if !hasChanges {
		log.Printf("[Git] GitClearUncommittedChanges - no changes to clear for plan %s", planId)
		return nil
	}

	err = gitWriteOperation(func() error {
		// Reset staged changes
		log.Printf("[Git] GitClearUncommittedChanges - resetting staged changes for plan %s", planId)
		res, err := exec.Command("git", "-C", dir, "reset", "--hard").CombinedOutput()
		if err != nil {
			return fmt.Errorf("error resetting staged changes | err: %v, output: %s", err, string(res))
		}
		log.Printf("[Git] GitClearUncommittedChanges - reset staged changes finished for plan %s", planId)
		return nil
	}, dir, fmt.Sprintf("GitClearUncommittedChanges > gitReset: plan=%s", planId))

	if err != nil {
		return err
	}

	err = gitWriteOperation(func() error {
		// Clean untracked files
		log.Printf("[Git] GitClearUncommittedChanges - cleaning untracked files for plan %s", planId)
		res, err := exec.Command("git", "-C", dir, "clean", "-d", "-f").CombinedOutput()
		if err != nil {
			return fmt.Errorf("error cleaning untracked files | err: %v, output: %s", err, string(res))
		}
		log.Printf("[Git] GitClearUncommittedChanges - clean untracked files finished for plan %s", planId)
		return nil
	}, dir, fmt.Sprintf("GitClearUncommittedChanges > gitClean: plan=%s", planId))

	return err
}

func (repo *GitRepo) GitCheckoutBranch(branch string) error {
	orgId := repo.orgId
	planId := repo.planId

	dir := getPlanDir(orgId, planId)

	err := gitWriteOperation(func() error {
		return gitCheckoutBranch(dir, branch)
	}, dir, fmt.Sprintf("GitCheckoutBranch > gitCheckout: plan=%s branch=%s", planId, branch))

	if err != nil {
		return err
	}

	return nil
}

func gitAdd(repoDir, path string) error {

	if err := gitRemoveIndexLockFileIfExists(repoDir); err != nil {
		return fmt.Errorf("error removing lock file before add: %v", err)
	}

	res, err := exec.Command("git", "-C", repoDir, "add", path).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}
	return nil
}

func gitCommit(repoDir, commitMsg string) error {
	if err := gitRemoveIndexLockFileIfExists(repoDir); err != nil {
		return fmt.Errorf("error removing lock file before commit: %v", err)
	}

	res, err := exec.Command("git", "-C", repoDir, "commit", "-m", commitMsg).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}
	return nil

}

func gitCheckoutBranch(repoDir, branch string) error {
	log.Printf("[Git] gitCheckoutBranch - repoDir: %s, branch: %s", repoDir, branch)
	if err := gitRemoveIndexLockFileIfExists(repoDir); err != nil {
		return fmt.Errorf("error removing lock file before checkout: %v", err)
	}

	// get current branch and only checkout if it's not the same
	// trying to check out the same branch will result in an error
	var out bytes.Buffer
	cmd := exec.Command("git", "-C", repoDir, "branch", "--show-current")
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		return fmt.Errorf("error getting current git branch for dir: %s, err: %v", repoDir, err)
	}

	currentBranch := strings.TrimSpace(out.String())
	log.Printf("[Git] gitCheckoutBranch - currentBranch: %s", currentBranch)

	if currentBranch == branch {
		log.Printf("[Git] gitCheckoutBranch - already on branch %s, skipping", branch)
		return nil
	}

	log.Println("[Git] gitCheckoutBranch - checking out branch:", branch)
	res, err := exec.Command("git", "-C", repoDir, "checkout", branch).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error checking out git branch for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}
	return nil
}

func gitRewindToSha(repoDir, sha string) error {
	res, err := exec.Command("git", "-C", repoDir, "reset", "--hard", sha).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error executing git reset for dir: %s, sha: %s, err: %v, output: %s", repoDir, sha, err, string(res))
	}

	return nil
}

func getLatestCommit(dir string) (sha, body string, err error) {
	var out bytes.Buffer
	cmd := exec.Command("git", "log", "--pretty=%h@@|@@%at@@|@@%B@>>>@")
	cmd.Dir = dir
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		return "", "", fmt.Errorf("error getting git history for dir: %s, err: %v", dir, err)
	}

	// Process the log output to get it in the desired format.
	history := processGitHistoryOutput(strings.TrimSpace(out.String()))

	first := history[0]

	sha = first[0]
	body = first[1]

	return sha, body, nil
}

func getGitCommitHistory(dir string) (body string, shas []string, err error) {
	var out bytes.Buffer
	cmd := exec.Command("git", "log", "--pretty=%h@@|@@%at@@|@@%B@>>>@")
	cmd.Dir = dir
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		return "", nil, fmt.Errorf("error getting git history for dir: %s, err: %v", dir, err)
	}

	// Process the log output to get it in the desired format.
	history := processGitHistoryOutput(strings.TrimSpace(out.String()))

	var output []string
	for _, el := range history {
		shas = append(shas, el[0])
		output = append(output, el[1])
	}

	return strings.Join(output, "\n\n"), shas, nil
}

// processGitHistoryOutput processes the raw output from the git log command and returns a formatted string.
func processGitHistoryOutput(raw string) [][2]string {
	var history [][2]string
	entries := strings.Split(raw, "@>>>@") // Split entries using the custom separator.

	for _, entry := range entries {
		// First clean up any leading/trailing whitespace or newlines from each entry.
		entry = strings.TrimSpace(entry)

		// Now split the cleaned entry into its parts.
		parts := strings.Split(entry, "@@|@@")
		if len(parts) == 3 {
			sha := parts[0]
			timestampStr := parts[1]
			message := strings.TrimSpace(parts[2]) // Trim whitespace from message as well.

			// Extract and format timestamp.
			timestamp, err := strconv.ParseInt(timestampStr, 10, 64)
			if err != nil {
				continue // Skip entries with invalid timestamps.
			}

			dt := time.Unix(timestamp, 0).UTC()
			formattedTs := dt.Format("Mon Jan 2, 2006 | 3:04:05pm MST")

			// Prepare the header with colors.
			headerColor := color.New(color.FgCyan, color.Bold)
			dateColor := color.New(color.FgCyan)

			// Combine sha, formatted timestamp, and message header into one string.
			header := fmt.Sprintf("%s | %s", headerColor.Sprintf("📝 Update %s", sha), dateColor.Sprintf("%s", formattedTs))

			// Combine header and message with a newline only if the message is not empty.
			fullEntry := header
			if message != "" {
				fullEntry += "\n" + message
			}

			history = append(history, [2]string{sha, fullEntry})
		}
	}

	return history
}

func removeLockFile(lockFilePath string) error {
	_, err := os.Stat(lockFilePath)
	exists := err == nil
	// log.Println("index.lock file exists:", exists)
	if err != nil && !os.IsNotExist(err) {
		return fmt.Errorf("error checking lock file: %v", err)
	}

	attempts := 0
	for exists {
		if attempts > 10 {
			return fmt.Errorf("error removing index.lock file: %v after %d attempts", err, attempts)
		}

		log.Printf("[Git] removeLockFile - removing index.lock file: %s, attempt: %d", lockFilePath, attempts)

		if err := os.Remove(lockFilePath); err != nil {
			if os.IsNotExist(err) {
				log.Printf("[Git] removeLockFile - %s file not found, skipping removal", lockFilePath)
				return nil
			}

			return fmt.Errorf("error removing lock file: %v", err)
		}

		_, err = os.Stat(lockFilePath)
		exists = err == nil

		if err != nil && !os.IsNotExist(err) {
			return fmt.Errorf("error checking lock file: %v", err)
		}

		log.Printf("[Git] removeLockFile - after removal, %s file exists: %t", lockFilePath, exists)
		if exists {
			log.Printf("[Git] removeLockFile - %s file still exists, retrying after delay", lockFilePath)
		} else {
			log.Printf("[Git] removeLockFile - %s file removed successfully", lockFilePath)
			return nil
		}

		attempts++
		time.Sleep(20 * time.Millisecond)
	}

	return nil
}

func gitRemoveIndexLockFileIfExists(repoDir string) error {
	log.Printf("[Git] gitRemoveIndexLockFileIfExists - repoDir: %s", repoDir)

	paths := []string{
		filepath.Join(repoDir, ".git", "index.lock"),
		filepath.Join(repoDir, ".git", "refs", "heads", "HEAD.lock"),
		filepath.Join(repoDir, ".git", "HEAD.lock"),
	}

	errCh := make(chan error, len(paths))

	for _, path := range paths {
		go func(path string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in gitRemoveIndexLockFileIfExists: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in gitRemoveIndexLockFileIfExists: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			if err := removeLockFile(path); err != nil {
				errCh <- err
				return
			}
			errCh <- nil
		}(path)
	}

	errs := []error{}
	for i := 0; i < len(paths); i++ {
		err := <-errCh
		if err != nil {
			errs = append(errs, err)
		}
	}

	if len(errs) > 0 {
		return fmt.Errorf("error removing lock files: %v", errs)
	}

	return nil
}

func setGitConfig(repoDir, key, value string) error {
	res, err := exec.Command("git", "-C", repoDir, "config", key, value).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error setting git config %s to %s for dir: %s, err: %v, output: %s", key, value, repoDir, err, string(res))
	}
	return nil
}

func gitWriteOperation(operation func() error, repoDir, label string) error {
	log.Printf("[Git] gitWriteOperation - label: %s", label)
	var err error
	for attempt := 0; attempt < maxGitRetries; attempt++ {
		if attempt > 0 {
			delay := time.Duration(1<<uint(attempt-1)) * baseGitRetryDelay // Exponential backoff
			time.Sleep(delay)
			log.Printf("Retry attempt %d for git operation %s (delay: %v)\n", attempt+1, label, delay)
		}

		err = operation()
		if err == nil {
			return nil
		}

		// Check if error is retryable
		if strings.Contains(err.Error(), "index.lock") || strings.Contains(err.Error(), "cannot lock ref") {
			log.Printf("Git lock file error detected for %s, will retry: %v\n", label, err)
			err = gitRemoveIndexLockFileIfExists(repoDir)
			if err != nil {
				log.Printf("error removing lock files: %v", err)
			}
			continue
		}

		// Non-retryable error
		return err
	}
	return fmt.Errorf("operation %s failed after %d attempts: %v", label, maxGitRetries, err)
}

// LogGitRepoState prints out useful debug info about the current git repository:
//   - The currently checked-out branch
//   - The last few commits
//   - The status (untracked changes, etc.)
//   - A directory listing of refs/heads
//   - A directory listing of .git/ (to spot any leftover lock files or HEAD files)
func (repo *GitRepo) LogGitRepoState() {
	repoDir := getPlanDir(repo.orgId, repo.planId)

	log.Println("[DEBUG] --- Git Repo State ---")

	// 1. Current branch
	out, err := exec.Command("git", "-C", repoDir, "branch", "--show-current").CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error running `git branch --show-current`: %v, output: %s", err, string(out))
	} else {
		log.Printf("[DEBUG] Current branch: %s", string(out))
	}

	// 2. Recent commits
	out, err = exec.Command("git", "-C", repoDir, "log", "--oneline", "-5").CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error running `git log --oneline -5`: %v, output: %s", err, string(out))
	} else {
		log.Printf("[DEBUG] Recent commits:\n%s", string(out))
	}

	// 3. Git status
	out, err = exec.Command("git", "-C", repoDir, "status", "--short", "--branch").CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error running `git status`: %v, output: %s", err, string(out))
	} else {
		log.Printf("[DEBUG] Git status:\n%s", string(out))
	}

	// 4. Show all refs (to see if `.git/refs/heads/HEAD` exists)
	out, err = exec.Command("git", "-C", repoDir, "show-ref").CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error running `git show-ref`: %v, output: %s", err, string(out))
	} else {
		log.Printf("[DEBUG] All refs:\n%s", string(out))
	}

	// 5. Directory listing of .git/refs/heads
	headsDir := filepath.Join(repoDir, ".git", "refs", "heads")
	out, err = exec.Command("ls", "-l", headsDir).CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error listing heads dir: %s, err: %v, output: %s", headsDir, err, string(out))
	} else {
		log.Printf("[DEBUG] .git/refs/heads contents:\n%s", string(out))
	}

	// 5a. If there's actually a HEAD file in `.git/refs/heads`, cat it.
	headRefPath := filepath.Join(headsDir, "HEAD")
	if _, err := os.Stat(headRefPath); err == nil {
		// The file `.git/refs/heads/HEAD` exists, which is unusual
		log.Printf("[DEBUG] Found .git/refs/heads/HEAD. Dumping contents:")
		catOut, _ := exec.Command("cat", headRefPath).CombinedOutput()
		log.Printf("[DEBUG] .git/refs/heads/HEAD contents:\n%s", string(catOut))
	} else if !os.IsNotExist(err) {
		log.Printf("[DEBUG] error checking for .git/refs/heads/HEAD: %v", err)
	}

	// 6. Directory listing of .git/ in case there's HEAD.lock or index.lock
	gitDir := filepath.Join(repoDir, ".git")
	out, err = exec.Command("ls", "-l", gitDir).CombinedOutput()
	if err != nil {
		log.Printf("[DEBUG] error listing .git dir: %s, err: %v, output: %s", gitDir, err, string(out))
	} else {
		log.Printf("[DEBUG] .git/ contents:\n%s", string(out))
	}

	// 6a. If there's a .git/HEAD file, cat it
	headFilePath := filepath.Join(gitDir, "HEAD")
	if _, err := os.Stat(headFilePath); err == nil {
		log.Printf("[DEBUG] .git/HEAD file exists. Dumping contents:")
		catOut, _ := exec.Command("cat", headFilePath).CombinedOutput()
		log.Printf("[DEBUG] .git/HEAD contents:\n%s", string(catOut))
	} else if !os.IsNotExist(err) {
		log.Printf("[DEBUG] error checking for .git/HEAD: %v", err)
	}

	// 6b. Check for HEAD.lock or index.lock specifically
	headLockPath := filepath.Join(gitDir, "HEAD.lock")
	if _, err := os.Stat(headLockPath); err == nil {
		log.Printf("[DEBUG] HEAD.lock file exists at: %s", headLockPath)
	} else if !os.IsNotExist(err) {
		log.Printf("[DEBUG] error checking for HEAD.lock: %v", err)
	}

	indexLockPath := filepath.Join(gitDir, "index.lock")
	if _, err := os.Stat(indexLockPath); err == nil {
		log.Printf("[DEBUG] index.lock file exists at: %s", indexLockPath)
	} else if !os.IsNotExist(err) {
		log.Printf("[DEBUG] error checking for index.lock: %v", err)
	}

	log.Println("[DEBUG] --- End Git Repo State ---")
}


================================================
FILE: app/server/db/invite_helpers.go
================================================
package db

import (
	"context"
	"database/sql"
	"fmt"
	"strings"

	"github.com/jmoiron/sqlx"
)

func CreateInvite(invite *Invite, tx *sqlx.Tx) error {
	err := tx.QueryRow("INSERT INTO invites (org_id, email, name, inviter_id, org_role_id) VALUES ($1, $2, $3, $4, $5) RETURNING id", invite.OrgId, invite.Email, invite.Name, invite.InviterId, invite.OrgRoleId).Scan(&invite.Id)

	if err != nil {
		return fmt.Errorf("error creating invite: %v", err)
	}

	return nil
}

func GetInvite(id string) (*Invite, error) {
	var invite Invite
	err := Conn.Get(&invite, "SELECT * FROM invites WHERE id = $1", id)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting invite: %v", err)
	}

	return &invite, nil
}

func GetActiveInviteByEmail(orgId, email string) (*Invite, error) {
	var invite Invite
	err := Conn.Get(&invite, "SELECT * FROM invites WHERE org_id = $1 AND email = $2 AND accepted_at IS NULL", orgId, email)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting invite: %v", err)
	}

	return &invite, nil
}

func ListPendingInvites(orgId string) ([]*Invite, error) {
	var invites []*Invite
	err := Conn.Select(&invites, "SELECT * FROM invites WHERE org_id = $1 AND accepted_at IS NULL", orgId)

	if err != nil {
		return nil, fmt.Errorf("error getting pending invites for org: %v", err)
	}

	return invites, nil
}

func ListAllInvites(orgId string) ([]*Invite, error) {
	var invites []*Invite
	err := Conn.Select(&invites, "SELECT * FROM invites WHERE org_id = $1", orgId)

	if err != nil {
		return nil, fmt.Errorf("error getting all invites for org: %v", err)
	}

	return invites, nil
}

func ListAcceptedInvites(orgId string) ([]*Invite, error) {
	var invites []*Invite
	err := Conn.Select(&invites, "SELECT * FROM invites WHERE org_id = $1 AND accepted_at IS NOT NULL", orgId)

	if err != nil {
		return nil, fmt.Errorf("error getting accepted invites for org: %v", err)
	}

	return invites, nil
}

func GetPendingInvitesForEmail(email string) ([]*Invite, error) {
	email = strings.ToLower(email)
	var invites []*Invite
	err := Conn.Select(&invites, "SELECT * FROM invites WHERE email = $1 AND accepted_at IS NULL", email)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting invites and org names for email: %v", err)
	}

	return invites, nil
}

func DeleteInvite(id string, tx *sqlx.Tx) error {
	query := "DELETE FROM invites WHERE id = $1"
	var err error

	if tx == nil {
		_, err = Conn.Exec(query, id)
	} else {
		_, err = tx.Exec(query, id)
	}

	if err != nil {
		return fmt.Errorf("error deleting invite: %v", err)
	}

	return nil
}

func AcceptInvite(ctx context.Context, invite *Invite, inviteeId string) error {
	err := WithTx(ctx, "accept invite", func(tx *sqlx.Tx) error {

		_, err := tx.Exec(`UPDATE invites SET accepted_at = NOW(), invitee_id = $1 WHERE id = $2`, inviteeId, invite.Id)
		if err != nil {
			return fmt.Errorf("error accepting invite: %v", err)
		}

		// create org user
		err = CreateOrgUser(invite.OrgId, inviteeId, invite.OrgRoleId, tx)

		if err != nil {
			return fmt.Errorf("error creating org user: %v", err)
		}

		return nil
	})

	if err != nil {
		return fmt.Errorf("error accepting invite: %v", err)
	}

	invite.InviteeId = &inviteeId

	return nil
}


================================================
FILE: app/server/db/locks.go
================================================
package db

import (
	"bytes"
	"context"
	"database/sql"
	"fmt"
	"log"
	"math"
	"math/rand"
	"plandex-server/notify"
	"plandex-server/shutdown"
	"runtime"
	"runtime/debug"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/lib/pq"
	"github.com/pkg/errors"
)

const locksVerboseLogging = false

const lockHeartbeatInterval = 3 * time.Second
const lockHeartbeatTimeout = 60 * time.Second
const maxLockRetries = 6
const initialLockRetryDelay = 300 * time.Millisecond
const backoffFactor = 2    // Exponential base
const jitterFraction = 0.3 // e.g. ±30% of the backoff

// We want deletes to win quickly vs. lock reads, so we retry them more aggressively with no backoff
const maxDeleteRetries = 60
const deleteRetryDelay = 50 * time.Millisecond

var activeLockIds = make(map[string]bool)
var activeLockIdsMu sync.Mutex

// LockRepoParams holds the data needed for your lock calls
type LockRepoParams struct {
	OrgId       string
	UserId      string
	PlanId      string
	Branch      string
	Scope       LockScope
	PlanBuildId string
	Ctx         context.Context
	CancelFn    context.CancelFunc
	Reason      string
}

func lockRepoDB(params LockRepoParams, numRetry int) (string, error) {
	start := time.Now()
	goroutineID := getGoroutineID()

	if locksVerboseLogging {
		log.Printf("[Lock][%d] START lock attempt for plan %s scope %s (retry %d) at %v | reason: %s",
			goroutineID, params.PlanId, params.Scope, numRetry, start, params.Reason)
	}

	defer func() {
		if locksVerboseLogging {
			elapsed := time.Since(start)
			log.Printf("[Lock][%d] END lock attempt took %v | reason: %s", goroutineID, elapsed, params.Reason)
		}
	}()

	// ensure context did not cancel
	if params.Ctx.Err() != nil {
		if locksVerboseLogging {
			log.Printf("[Lock][%d] Context canceled, returning error: %v | reason: %s", goroutineID, params.Ctx.Err(), params.Reason)
		}
		return "", params.Ctx.Err()
	}

	initialJitter := time.Duration(rand.Int63n(int64(5000 * time.Microsecond)))

	select {
	case <-params.Ctx.Done():
		return "", params.Ctx.Err()
	case <-time.After(initialJitter):
	}

	orgId := params.OrgId
	userId := params.UserId
	planId := params.PlanId
	branch := params.Branch
	scope := params.Scope
	planBuildId := params.PlanBuildId
	ctx := params.Ctx
	cancelFn := params.CancelFn

	if orgId == "" {
		return "", fmt.Errorf("orgId is required")
	}
	if planId == "" {
		return "", fmt.Errorf("planId is required")
	}
	if scope != LockScopeRead && scope != LockScopeWrite {
		return "", fmt.Errorf("invalid lock scope: %s", scope)
	}

	tx, err := Conn.BeginTxx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
	if err != nil {
		if locksVerboseLogging {
			log.Printf("[Lock][%d] Error starting transaction %v | reason: %s",
				goroutineID, err, params.Reason)
		}
		return "", fmt.Errorf("error starting transaction: %v", err)
	}

	var committed bool

	// Ensure that rollback is attempted in case of failure
	defer func() {
		if committed {
			return
		}

		panicErr := recover()
		if panicErr != nil {
			log.Printf("panic in lock repo: %v", panicErr)
		}

		if rbErr := tx.Rollback(); rbErr != nil {
			if rbErr == sql.ErrTxDone {
				if locksVerboseLogging {
					// log.Println("attempted to roll back transaction, but it was already committed")
				}
			} else {
				log.Printf("transaction rollback error: %v\n", rbErr)
			}
		} else {
			if locksVerboseLogging {
				log.Println("transaction rolled back")
			}
		}
	}()

	forUpdate := params.Scope == LockScopeWrite

	selectStart := time.Now()
	if locksVerboseLogging {
		if forUpdate {
			log.Printf("[Lock][%d] Starting SELECT FOR UPDATE at %v | reason: %s", goroutineID, selectStart, params.Reason)
		} else {
			log.Printf("[Lock][%d] Starting SELECT FOR SHARE at %v | reason: %s", goroutineID, selectStart, params.Reason)
		}
	}

	lockablePlanIdQuery := "SELECT * FROM lockable_plan_ids WHERE plan_id = $1"
	if forUpdate {
		lockablePlanIdQuery += " FOR UPDATE"
	} else {
		lockablePlanIdQuery += " FOR SHARE"
	}

	_, err = tx.Exec(lockablePlanIdQuery, planId)
	if err != nil {
		log.Printf("[Lock][%d] getting lockable plan id for %s: %v | reason: %s", goroutineID, planId, err, params.Reason)
		return retryWithExponentialBackoff(params.Ctx, err, numRetry, func(nextAttempt int) (string, error) {
			return lockRepoDB(params, nextAttempt)
		})
	}

	log.Printf("[Lock][%d] got lockable plan id for %s | reason: %s", goroutineID, planId, params.Reason)

	query := "SELECT id, org_id, user_id, plan_id, plan_build_id, scope, branch, last_heartbeat_at, created_at FROM repo_locks WHERE plan_id = $1"
	if forUpdate {
		query += " FOR UPDATE"
	} else {
		query += " FOR SHARE"
	}
	queryArgs := []interface{}{planId}

	var locks []*repoLock
	if locksVerboseLogging {
		log.Println("obtaining repo lock with query")
	}
	repoLockRows, err := tx.Query(query, queryArgs...)
	if err != nil {
		log.Printf("[Lock][%d] error obtaining repo lock with query: %v | reason: %s", goroutineID, err, params.Reason)
		return retryWithExponentialBackoff(params.Ctx, err, numRetry, func(nextAttempt int) (string, error) {
			return lockRepoDB(params, nextAttempt)
		})
	}
	if locksVerboseLogging {
		log.Println("repo lock query executed")
	}

	if locksVerboseLogging {
		if forUpdate {
			log.Printf("[Lock][%d] SELECT FOR UPDATE took %v | reason: %s",
				goroutineID, time.Since(selectStart), params.Reason)
		} else {
			log.Printf("[Lock][%d] SELECT FOR SHARE took %v | reason: %s",
				goroutineID, time.Since(selectStart), params.Reason)
		}
	}

	defer repoLockRows.Close()

	var expiredLockIds []string
	expiredLockIdsSet := make(map[string]bool)

	now := time.Now()
	for repoLockRows.Next() {
		var lock repoLock
		if err := repoLockRows.Scan(&lock.Id, &lock.OrgId, &lock.UserId, &lock.PlanId, &lock.PlanBuildId, &lock.Scope, &lock.Branch, &lock.LastHeartbeatAt, &lock.CreatedAt); err != nil {
			return "", fmt.Errorf("error scanning repo lock: %v", err)
		}

		// ensure heartbeat hasn't timed out
		if now.Sub(lock.LastHeartbeatAt) < lockHeartbeatTimeout {
			locks = append(locks, &lock)
		} else {
			expiredLockIds = append(expiredLockIds, lock.Id)
			expiredLockIdsSet[lock.Id] = true
		}
	}

	if err := repoLockRows.Err(); err != nil {
		log.Printf("[Lock][%d] error iterating over repo locks: %v | reason: %s", goroutineID, err, params.Reason)
		return "", fmt.Errorf("error iterating over repo locks: %v", err)
	}

	log.Printf("[Lock][%d] %d locks found, %d expired | reason: %s", goroutineID, len(locks), len(expiredLockIds), params.Reason)

	if len(expiredLockIds) > 0 {
		log.Printf("[Lock][%d] %d expired locks found, deleting | reason: %s", goroutineID, len(expiredLockIds), params.Reason)
		if locksVerboseLogging {
			log.Printf("deleting expired locks: %v", expiredLockIds)
		}

		query := "DELETE FROM repo_locks WHERE id = ANY($1)"
		_, err := tx.Exec(query, pq.Array(expiredLockIds))
		if err != nil {
			if isDeadlockError(err) {
				log.Println("deadlock clearing expired locks, won't do anything")
			} else {
				log.Printf("[Lock][%d] error removing expired locks: %v | reason: %s", goroutineID, err, params.Reason)
				return "", fmt.Errorf("error removing expired locks: %v", err)
			}
		}
	}

	canAcquire := true

	for _, lock := range locks {
		lockBranch := ""
		if lock.Branch != nil {
			lockBranch = *lock.Branch
		}

		if scope == LockScopeRead {
			// if we're trying to acquire a read lock, we can do so unless there's a conflicting lock
			// a write lock always conflicts with a read lock (regardless of branch)
			// a read lock conflicts if it's for a different branch (since it would need to checkout a different branch in the middle of an already-running read)
			if lock.Scope == LockScopeWrite {
				canAcquire = false
				break
			} else if lock.Scope == LockScopeRead {
				if lockBranch != branch {
					canAcquire = false
					break
				}
			}
		} else if scope == LockScopeWrite {
			// if we're trying to acquire a write lock, we can only do so if there's no other lock (read or write)
			canAcquire = false
			break
		} else {
			err = fmt.Errorf("invalid lock scope: %v", scope)
			return "", err
		}
	}

	if !canAcquire {
		if locksVerboseLogging {
			log.Println("can't acquire lock.", "numRetry:", numRetry)
		}
		conflictErr := errors.New("lock conflict: cannot acquire read/write lock")
		log.Printf("[Lock][%d] can't acquire lock, retrying: %v | reason: %s | now: %s | locks:\n%s\n", goroutineID, conflictErr, params.Reason, now, spew.Sdump(locks))

		return retryWithExponentialBackoff(params.Ctx, conflictErr, numRetry, func(nextAttempt int) (string, error) {
			return lockRepoDB(params, nextAttempt)
		})
	}

	if locksVerboseLogging {
		log.Println("can acquire lock - inserting new lock")
	}

	insertStart := time.Now()
	if locksVerboseLogging {
		log.Printf("[Lock][%d] Starting INSERT at %v | reason: %s", goroutineID, insertStart, params.Reason)
	}

	// Insert the new lock
	var lockPlanBuildId *string
	if planBuildId != "" {
		lockPlanBuildId = &planBuildId
	}

	var lockBranch *string
	if branch != "" {
		lockBranch = &branch
	}

	newLock := &repoLock{
		PlanId:      planId,
		OrgId:       orgId,
		PlanBuildId: lockPlanBuildId,
		Scope:       scope,
		Branch:      lockBranch,
	}

	if userId != "" {
		newLock.UserId = &userId
	}

	var insertedId sql.NullString

	insertQuery := "INSERT INTO repo_locks (org_id, user_id, plan_id, plan_build_id, scope, branch) VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (plan_id) WHERE scope = 'w' DO NOTHING RETURNING id"

	if locksVerboseLogging {
		log.Printf("Insert query: %s", insertQuery)
	}

	err = tx.QueryRow(
		insertQuery,
		newLock.OrgId,
		newLock.UserId,
		newLock.PlanId,
		newLock.PlanBuildId,
		newLock.Scope,
		newLock.Branch,
	).Scan(&insertedId)
	if err != nil {
		if err == sql.ErrNoRows {
			// Means ON CONFLICT DO NOTHING prevented insertion
			// => concurrency conflict => backoff & retry
			return retryWithExponentialBackoff(params.Ctx,
				errors.New("lock conflict: row not inserted"),
				numRetry,
				func(nextAttempt int) (string, error) {
					return lockRepoDB(params, nextAttempt)
				},
			)
		}

		log.Printf("[Lock][%d] error inserting new lock: %v | reason: %s", goroutineID, err, params.Reason)
		return "", fmt.Errorf("error inserting new lock: %v", err)
	}

	if insertedId.Valid {
		newLock.Id = insertedId.String
	} else {
		if locksVerboseLogging {
			log.Printf("no rows returned from insert query, means there was a conflict")
		}
		return retryWithExponentialBackoff(params.Ctx, err, numRetry, func(nextAttempt int) (string, error) {
			return lockRepoDB(params, nextAttempt)
		})
	}

	if locksVerboseLogging {
		log.Printf("[Lock][%d] INSERT took %v | reason: %s",
			goroutineID, time.Since(insertStart), params.Reason)
	}

	// Commit the transaction
	if err = tx.Commit(); err != nil {
		return "", fmt.Errorf("error committing transaction: %v", err)
	}

	committed = true

	activeLockIdsMu.Lock()
	activeLockIds[newLock.Id] = true
	activeLockIdsMu.Unlock()

	log.Printf("Lock acquired: %s for plan %s with scope %s | reason: %s", newLock.Id, planId, scope, params.Reason)

	// Start a goroutine to keep the lock alive
	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in heartbeat goroutine: %v\n%s", r, debug.Stack())
				cancelFn()
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in lock heartbeat goroutine: %v\n%s", r, debug.Stack()))
			}
		}()

		onCancel := func() {
			log.Printf("[Lock][Heartbeat] Timeout or context canceled during heartbeat loop for lock %s for plan %s | reason: %s", newLock.Id, planId, params.Reason)
		}

		numErrors := 0
		for {
			select {
			case <-ctx.Done():
				onCancel()
				return

			default:
				jitter := time.Duration(rand.Int63n(int64(float64(lockHeartbeatInterval)*0.1)) * int64(numErrors+1))

				log.Printf("[Lock][Heartbeat] Will update heartbeat for %s | %s | Heartbeat interval: %s, jitter: %s", planId, params.Reason, lockHeartbeatInterval, jitter)

				select {
				case <-ctx.Done():
					onCancel()
					return
				case <-time.After(lockHeartbeatInterval + jitter):
				}

				log.Printf("[Lock][Heartbeat] %s | %s | Updating repo lock last heartbeat\n", planId, params.Reason)

				res, err := Conn.Exec("UPDATE repo_locks SET last_heartbeat_at = NOW() WHERE id = $1", newLock.Id)

				if err != nil {
					log.Printf("[Lock][Heartbeat] %s | %s | Error updating repo lock last heartbeat: %v\n", planId, params.Reason, err)

					if isDeadlockError(err) {
						log.Printf("[Lock][Heartbeat] %s | %s | Heartbeat deadlock error, keep retrying\n", planId, params.Reason)
					}

					numErrors++

					if numErrors > 5 {
						log.Printf("[Lock][Heartbeat] %s | %s | Too many errors updating repo lock last heartbeat: %v\n", planId, params.Reason, err)
						cancelFn()
						return
					}
				} else {
					// check if 0 rows were updated
					rowsAffected, err := res.RowsAffected()
					if err != nil {
						log.Printf("Error getting rows affected: %v\n", err)
						cancelFn()
						return
					}

					if rowsAffected == 0 {
						log.Printf("[Lock][Heartbeat] %s | %s | Lock not found: %s | stopping heartbeat loop\n", planId, params.Reason, newLock.Id)
						return
					}

					log.Printf("[Lock][Heartbeat] %s | %s | Lock found: %s | continuing heartbeat loop\n", planId, params.Reason, newLock.Id)
				}
			}

		}
	}()

	// check if git lock file exists
	// remove it if so
	err = gitRemoveIndexLockFileIfExists(getPlanDir(orgId, planId))
	if err != nil {
		log.Printf("[Lock] %s | %s | Error removing lock file: %v", planId, params.Reason, err)
		return newLock.Id, fmt.Errorf("error removing lock file: %v", err)
	}

	if branch != "" {
		// checkout the branch
		err = gitCheckoutBranch(getPlanDir(orgId, planId), branch)
		if err != nil {
			log.Printf("[Lock] %s | %s | Error checking out branch: %v", planId, params.Reason, err)
			return newLock.Id, fmt.Errorf("error checking out branch: %v", err)
		}
		log.Printf("[Lock] %s | %s | Checked out branch", planId, params.Reason)
	}

	return newLock.Id, nil
}

func deleteRepoLockDB(id, planId, reason string, numRetry int) error {
	start := time.Now()
	goroutineID := getGoroutineID()

	if locksVerboseLogging {
		log.Printf("[Lock][Delete][%d] START delete lock %s at %v | reason: %s", goroutineID, id, start, reason)

		defer func() {
			log.Printf("[Lock][Delete][%d] END delete lock took %v | reason: %s", goroutineID, time.Since(start), reason)
		}()
	}

	result, err := Conn.Exec("DELETE FROM repo_locks WHERE id = $1", id)
	if err != nil {
		log.Printf("[Lock][Delete][%d] Error deleting lock: %v | reason: %s", goroutineID, err, reason)

		err := retryDeleteLock(shutdown.ShutdownCtx, err, numRetry, func(nextAttempt int) error {
			return deleteRepoLockDB(id, planId, reason, nextAttempt)
		})

		if err != nil {
			log.Printf("[Lock][Delete][%d] Error deleting lock after retries: %v | %s | %s | %s", goroutineID, err, id, planId, reason)
			return err
		}

		// retries succeeded, stop
		return nil
	}

	rowsAffected, _ := result.RowsAffected()
	if rowsAffected > 0 {
		log.Printf("[Lock][Delete][%d] Lock released: %s for plan %s | %s", goroutineID, id, planId, reason)
	} else {
		log.Printf("[Lock][Delete][%d] Lock not found: %s | %s | %s", goroutineID, id, planId, reason)
	}

	activeLockIdsMu.Lock()
	delete(activeLockIds, id)
	activeLockIdsMu.Unlock()

	return nil
}

func formatStackTrace(stack []byte) string {
	numLines := 10
	if !locksVerboseLogging {
		numLines = 5
	}
	return formatStackTraceWithNumLines(stack, numLines)
}

func formatStackTraceLong(stack []byte) string {
	return formatStackTraceWithNumLines(stack, 20)
}

func formatStackTraceWithNumLines(stack []byte, numLines int) string {
	lines := strings.Split(string(stack), "\n")
	// Take first 10 meaningful lines of stack trace
	// Skip runtime frames (first 7 lines) and limit to next 10 lines
	relevantLines := lines[7:min(len(lines), 7+numLines)]
	return strings.Join(relevantLines, "\n")
}

func getGoroutineID() uint64 {
	b := make([]byte, 64)
	b = b[:runtime.Stack(b, false)]
	b = bytes.TrimPrefix(b, []byte("goroutine "))
	b = b[:bytes.IndexByte(b, ' ')]
	n, _ := strconv.ParseUint(string(b), 10, 64)
	return n
}

func isDeadlockError(err error) bool {
	if err == nil {
		return false
	}

	if pqErr, ok := err.(*pq.Error); ok && (pqErr.Code == "40001" || pqErr.Code == "40P01") {
		return true
	}

	return false
}

func retryWithExponentialBackoff(
	ctx context.Context,
	cause error,
	attempt int,
	nextCall func(int) (string, error),
) (string, error) {
	// If we have retried enough times, bail out.
	if attempt >= maxLockRetries {
		log.Printf("[Lock][Retry][%d] Failed to acquire lock after %d attempts: %v", getGoroutineID(), attempt, cause)
		return "", fmt.Errorf("failed to acquire lock after %d attempts: %w", attempt, cause)
	}

	// Exponential delay: initialRetryDelay * 2^(attempt)
	backoff := time.Duration(float64(initialLockRetryDelay) * math.Pow(backoffFactor, float64(attempt)))
	// Add jitter: ± jitterFraction
	jitterRange := time.Duration(float64(backoff) * jitterFraction)
	jitter := time.Duration(rand.Int63n(int64(jitterRange)*2)) - jitterRange

	wait := backoff + jitter
	if wait < 0 {
		wait = 0
	}

	log.Printf("[Lock][Retry][%d] Lock/transaction conflict (attempt #%d). Retrying in %s... (cause: %v)", getGoroutineID(), attempt, wait, cause)

	select {
	case <-ctx.Done():
		log.Printf("[Lock][Retry][%d] Context canceled while waiting to retry: %v", getGoroutineID(), ctx.Err())
		return "", fmt.Errorf("context canceled while waiting to retry: %w", ctx.Err())
	case <-time.After(wait):
		// Proceed with the next attempt.
	}

	return nextCall(attempt + 1)
}

func retryDeleteLock(ctx context.Context, cause error, attempt int, nextCall func(int) error) error {
	if attempt >= maxDeleteRetries {
		return fmt.Errorf("delete lock failed after 10 attempts: %w", cause)
	}
	// retry 10 times, no backoff or maybe a tiny 50ms
	select {
	case <-ctx.Done():
		return ctx.Err()
	case <-time.After(deleteRetryDelay):
	}
	return nextCall(attempt + 1)
}

func CleanupActiveLocks(ctx context.Context) error {
	log.Println("Cleaning up any active repo locks...")

	// Start a transaction with repeatable read isolation level
	tx, err := Conn.BeginTxx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
	if err != nil {
		return fmt.Errorf("error starting transaction: %v", err)
	}

	// Ensure rollback is attempted in case of failure
	defer func() {
		panicErr := recover()
		if panicErr != nil {
			log.Printf("panic in cleanup all locks: %v", panicErr)
		}

		if rbErr := tx.Rollback(); rbErr != nil {
			if rbErr == sql.ErrTxDone {
				// log.Println("attempted to roll back transaction, but it was already committed")
			} else {
				log.Printf("transaction rollback error: %v\n", rbErr)
			}
		} else {
			if locksVerboseLogging {
				log.Println("transaction rolled back")
			}
		}
	}()

	// Delete all active locks
	query := "DELETE FROM repo_locks WHERE id = ANY($1)"
	ids := make([]string, 0, len(activeLockIds))
	for id := range activeLockIds {
		ids = append(ids, id)
	}
	_, err = tx.Exec(query, pq.Array(ids))
	if err != nil {
		if err == sql.ErrNoRows {
			log.Println("No active locks to cleanup")
		} else {
			return fmt.Errorf("error removing all locks: %v", err)
		}
	}

	// Commit the transaction
	if err = tx.Commit(); err != nil {
		return fmt.Errorf("error committing transaction: %v", err)
	}

	activeLockIdsMu.Lock()
	activeLockIds = make(map[string]bool)
	activeLockIdsMu.Unlock()

	log.Println("Successfully cleaned up all repo locks")
	return nil
}


================================================
FILE: app/server/db/models.go
================================================
package db

import (
	"database/sql"
	"fmt"

	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

func UpsertCustomModel(tx *sqlx.Tx, model *CustomModel) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	query := `
INSERT INTO custom_models (
    org_id, model_id,
    publisher, description,
    max_tokens, default_max_convo_tokens, max_output_tokens, reserved_output_tokens,
    has_image_support, preferred_output_format,
    system_prompt_disabled, role_params_disabled, stop_disabled,
    predicted_output_enabled, reasoning_effort_enabled, reasoning_effort,
    include_reasoning, reasoning_budget, supports_cache_control,
    single_message_no_system_prompt, token_estimate_padding_pct,
    providers
)
VALUES (
    $1,$2,
    $3,$4,
    $5,$6,$7,$8,
    $9,$10,
    $11,$12,$13,
    $14,$15,$16,
    $17,$18,$19,
    $20,$21,
    $22
)
ON CONFLICT (org_id, model_id)
DO UPDATE SET
    publisher                     = EXCLUDED.publisher,
    description                   = EXCLUDED.description,
    max_tokens                    = EXCLUDED.max_tokens,
    default_max_convo_tokens      = EXCLUDED.default_max_convo_tokens,
    max_output_tokens             = EXCLUDED.max_output_tokens,
    reserved_output_tokens        = EXCLUDED.reserved_output_tokens,
    has_image_support             = EXCLUDED.has_image_support,
    preferred_output_format       = EXCLUDED.preferred_output_format,
    system_prompt_disabled        = EXCLUDED.system_prompt_disabled,
    role_params_disabled          = EXCLUDED.role_params_disabled,
    stop_disabled                 = EXCLUDED.stop_disabled,
    predicted_output_enabled      = EXCLUDED.predicted_output_enabled,
    reasoning_effort_enabled      = EXCLUDED.reasoning_effort_enabled,
    reasoning_effort              = EXCLUDED.reasoning_effort,
    include_reasoning             = EXCLUDED.include_reasoning,
    reasoning_budget              = EXCLUDED.reasoning_budget,
    supports_cache_control        = EXCLUDED.supports_cache_control,
    single_message_no_system_prompt = EXCLUDED.single_message_no_system_prompt,
    token_estimate_padding_pct    = EXCLUDED.token_estimate_padding_pct,
    providers                     = EXCLUDED.providers
RETURNING id, created_at, updated_at;
`

	return tx.QueryRow(
		query,
		model.OrgId,
		model.ModelId,
		model.Publisher,
		model.Description,
		model.MaxTokens,
		model.DefaultMaxConvoTokens,
		model.MaxOutputTokens,
		model.ReservedOutputTokens,
		model.HasImageSupport,
		model.PreferredOutputFormat,
		model.SystemPromptDisabled,
		model.RoleParamsDisabled,
		model.StopDisabled,
		model.PredictedOutputEnabled,
		model.ReasoningEffortEnabled,
		model.ReasoningEffort,
		model.IncludeReasoning,
		model.ReasoningBudget,
		model.SupportsCacheControl,
		model.SingleMessageNoSystemPrompt,
		model.TokenEstimatePaddingPct,
		model.Providers,
	).Scan(&model.Id, &model.CreatedAt, &model.UpdatedAt)
}

func ListCustomModels(orgId string) ([]*CustomModel, error) {
	var models []*CustomModel
	err := Conn.Select(&models, `SELECT * FROM custom_models WHERE org_id = $1 ORDER BY created_at`, orgId)
	return models, err
}

func ListCustomModelsForModelIds(orgId string, modelIds []string) ([]*CustomModel, error) {
	var models []*CustomModel
	query := `SELECT * FROM custom_models WHERE org_id = $1 AND model_id = ANY($2) ORDER BY created_at`
	err := Conn.Select(&models, query, orgId, pq.Array(modelIds))
	return models, err
}

func GetCustomModel(orgId, id string) (*CustomModel, error) {
	var model CustomModel
	err := Conn.Get(&model, `SELECT * FROM custom_models WHERE org_id = $1 AND id = $2`, orgId, id)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}
		return nil, err
	}
	return &model, nil
}

func DeleteCustomModels(tx *sqlx.Tx, orgId string, ids []string) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	_, err := tx.Exec(`DELETE FROM custom_models WHERE org_id = $1 AND id = ANY($2)`, orgId, pq.Array(ids))
	if err != nil {
		return fmt.Errorf("error deleting custom models: %v", err)
	}
	return nil
}

func UpsertCustomProvider(tx *sqlx.Tx, p *CustomProvider) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	const q = `
INSERT INTO custom_providers (
	  org_id, name, base_url,
	  skip_auth, api_key_env_var, extra_auth_vars
)
VALUES (
	  $1,$2,$3,
	  $4,$5,$6
)
ON CONFLICT (org_id, name)
DO UPDATE SET
	  base_url        = EXCLUDED.base_url,
	  skip_auth       = EXCLUDED.skip_auth,
	  api_key_env_var = EXCLUDED.api_key_env_var,
	  extra_auth_vars = EXCLUDED.extra_auth_vars
RETURNING id, created_at, updated_at;
`
	return tx.QueryRow(
		q,
		p.OrgId,
		p.Name,
		p.BaseUrl,
		p.SkipAuth,
		p.ApiKeyEnvVar,
		p.ExtraAuthVars,
	).Scan(&p.Id, &p.CreatedAt, &p.UpdatedAt)
}

func GetCustomProvider(orgId, id string) (*CustomProvider, error) {
	var provider CustomProvider
	err := Conn.Get(&provider, `SELECT * FROM custom_providers WHERE org_id = $1 AND id = $2`, orgId, id)
	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}
		return nil, err
	}
	return &provider, nil
}

func ListCustomProviders(orgId string) ([]*CustomProvider, error) {
	var providers []*CustomProvider
	err := Conn.Select(&providers, `SELECT * FROM custom_providers WHERE org_id = $1 ORDER BY name`, orgId)
	return providers, err
}

func ListCustomProvidersForNames(orgId string, names []string) ([]*CustomProvider, error) {
	var providers []*CustomProvider
	query := `SELECT * FROM custom_providers WHERE org_id = $1 AND name = ANY($2) ORDER BY name`
	err := Conn.Select(&providers, query, orgId, pq.Array(names))
	return providers, err
}

func DeleteCustomProviders(tx *sqlx.Tx, orgId string, ids []string) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	_, err := tx.Exec(`DELETE FROM custom_providers WHERE org_id = $1 AND id = ANY($2)`, orgId, pq.Array(ids))
	if err != nil {
		return fmt.Errorf("error deleting custom providers: %v", err)
	}
	return nil
}

func UpsertModelPack(tx *sqlx.Tx, mp *ModelPack) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	const q = `
INSERT INTO model_sets (
	  org_id, name, description,
	  planner, coder, plan_summary,
	  builder, whole_file_builder, namer,
	  commit_msg, exec_status, context_loader
)
VALUES (
	  $1,$2,$3,
	  $4,$5,$6,
	  $7,$8,$9,
	  $10,$11,$12
)
ON CONFLICT (org_id, name)
DO UPDATE SET
	  description        = EXCLUDED.description,
	  planner            = EXCLUDED.planner,
	  coder              = EXCLUDED.coder,
	  plan_summary       = EXCLUDED.plan_summary,
	  builder            = EXCLUDED.builder,
	  whole_file_builder = EXCLUDED.whole_file_builder,
	  namer              = EXCLUDED.namer,
	  commit_msg         = EXCLUDED.commit_msg,
	  exec_status        = EXCLUDED.exec_status,
	  context_loader     = EXCLUDED.context_loader
RETURNING id, created_at;
`
	return tx.QueryRow(
		q,
		mp.OrgId,
		mp.Name,
		mp.Description,
		mp.Planner,
		mp.Coder,
		mp.PlanSummary,
		mp.Builder,
		mp.WholeFileBuilder,
		mp.Namer,
		mp.CommitMsg,
		mp.ExecStatus,
		mp.Architect,
	).Scan(&mp.Id, &mp.CreatedAt)
}

func ListModelPacks(orgId string) ([]*ModelPack, error) {
	var modelPacks []*ModelPack

	query := `SELECT * FROM model_sets WHERE org_id = $1`
	err := Conn.Select(&modelPacks, query, orgId)

	if err != nil {
		return nil, fmt.Errorf("error fetching model packs: %v", err)
	}

	return modelPacks, nil
}

func ListModelPacksForNames(orgId string, names []string) ([]*ModelPack, error) {
	var modelPacks []*ModelPack
	query := `SELECT * FROM model_sets WHERE org_id = $1 AND name = ANY($2)`
	err := Conn.Select(&modelPacks, query, orgId, names)
	return modelPacks, err
}

func DeleteModelPacks(tx *sqlx.Tx, orgId string, ids []string) error {
	if tx == nil {
		return fmt.Errorf("tx is nil")
	}
	_, err := tx.Exec(`DELETE FROM model_sets WHERE org_id = $1 AND id = ANY($2)`, orgId, pq.Array(ids))

	if err != nil {
		return fmt.Errorf("error deleting model pack: %v", err)
	}

	return nil
}


================================================
FILE: app/server/db/org_helpers.go
================================================
package db

import (
	"database/sql"
	"fmt"
	"log"
	"strings"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

const orgFields = "id, name, domain, auto_add_domain_users, owner_id, is_trial, created_at, updated_at"

func GetAccessibleOrgsForUser(user *User) ([]*Org, error) {
	// direct access
	var orgUsers []*OrgUser
	var orgs []*Org

	err := Conn.Select(&orgUsers, "SELECT * FROM orgs_users WHERE user_id = $1", user.Id)
	if err != nil {
		return nil, fmt.Errorf("error getting orgs for user: %v", err)
	}

	orgRoleIdByOrgId := map[string]string{}
	orgIds := []string{}
	for _, ou := range orgUsers {
		orgIds = append(orgIds, ou.OrgId)
		orgRoleIdByOrgId[ou.OrgId] = ou.OrgRoleId
	}

	if len(orgIds) > 0 {
		query := fmt.Sprintf("SELECT %s FROM orgs WHERE id = ANY($1)", orgFields)
		err = Conn.Select(&orgs, query, pq.Array(orgIds))
		if err != nil {
			return nil, fmt.Errorf("error getting orgs for user: %v", err)
		}
	} else {
		log.Println("No orgs found for user")
		return orgs, nil
	}

	// access via invitation
	invites, err := GetPendingInvitesForEmail(user.Email)
	if err != nil {
		return nil, fmt.Errorf("error getting invites for user: %v", err)
	}

	orgIds = []string{}
	for _, invite := range invites {
		orgIds = append(orgIds, invite.OrgId)
		orgRoleIdByOrgId[invite.OrgId] = invite.OrgRoleId
	}

	if len(orgIds) > 0 {
		var orgsFromInvites []*Org
		query := fmt.Sprintf("SELECT %s FROM orgs WHERE id = ANY($1)", orgFields)
		err = Conn.Select(&orgsFromInvites, query, pq.Array(orgIds))
		if err != nil {
			return nil, fmt.Errorf("error getting orgs from invites: %v", err)
		}
		orgs = append(orgs, orgsFromInvites...)
	}

	return orgs, nil
}
func GetOrg(orgId string) (*Org, error) {
	var org Org
	query := fmt.Sprintf("SELECT %s FROM orgs WHERE id = $1", orgFields)
	err := Conn.Get(&org, query, orgId)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, fmt.Errorf("org not found")
		}

		return nil, fmt.Errorf("error getting org: %v", err)
	}

	return &org, nil
}

func ValidateOrgMembership(userId string, orgId string) (bool, error) {
	var count int
	err := Conn.QueryRow("SELECT COUNT(*) FROM orgs_users WHERE user_id = $1 AND org_id = $2", userId, orgId).Scan(&count)

	if err != nil {
		return false, fmt.Errorf("error validating org membership: %v", err)
	}

	return count > 0, nil
}

func CreateOrg(req *shared.CreateOrgRequest, userId string, domain *string, tx *sqlx.Tx) (*Org, error) {
	org := &Org{
		Name:               req.Name,
		Domain:             domain,
		AutoAddDomainUsers: req.AutoAddDomainUsers,
		OwnerId:            userId,
	}

	err := tx.QueryRow("INSERT INTO orgs (name, domain, auto_add_domain_users, owner_id, is_trial) VALUES ($1, $2, $3, $4, false) RETURNING id", req.Name, domain, req.AutoAddDomainUsers, userId).Scan(&org.Id)

	if err != nil {
		if IsNonUniqueErr(err) {
			// Handle the uniqueness constraint violation
			return nil, fmt.Errorf("an org with domain %s already exists", *domain)

		}

		return nil, fmt.Errorf("error creating org: %v", err)
	}

	orgOwnerRoleId, err := GetOrgOwnerRoleId()
	if err != nil {
		return nil, fmt.Errorf("error getting org owner role id: %v", err)
	}

	_, err = tx.Exec("INSERT INTO orgs_users (org_id, user_id, org_role_id) VALUES ($1, $2, $3)", org.Id, userId, orgOwnerRoleId)

	if err != nil {
		return nil, fmt.Errorf("error adding org membership: %v", err)
	}

	return org, nil
}

func GetOrgForDomain(domain string) (*Org, error) {
	var org Org
	query := fmt.Sprintf("SELECT %s FROM orgs WHERE domain = $1", orgFields)
	err := Conn.Get(&org, query, domain)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting org for domain: %v", err)
	}

	return &org, nil
}

func AddOrgDomainUsers(orgId, domain string, tx *sqlx.Tx) error {
	usersForDomain, err := GetUsersForDomain(domain)

	if err != nil {
		return fmt.Errorf("error getting users for domain: %v", err)
	}

	orgMemberRoleId, err := GetOrgMemberRoleId()

	if err != nil {
		return fmt.Errorf("error getting org member role id: %v", err)
	}

	if len(usersForDomain) > 0 {
		// create org users for each user
		var valueStrings []string
		var valueArgs []interface{}
		for i, user := range usersForDomain {
			num := i * 3
			valueStrings = append(valueStrings, fmt.Sprintf("($%d, $%d, $%d)", num+1, num+2, num+3))
			valueArgs = append(valueArgs, orgId, user.Id, orgMemberRoleId)
		}

		// Join all value strings and execute a single query
		stmt := fmt.Sprintf("INSERT INTO orgs_users (org_id, user_id, org_role_id) VALUES %s ON CONFLICT ON CONSTRAINT org_user_unique DO NOTHING", strings.Join(valueStrings, ","))
		_, err = tx.Exec(stmt, valueArgs...)

		if err != nil {
			return fmt.Errorf("error adding org users: %v", err)
		}
	}

	return nil
}

func DeleteOrgUser(orgId, userId string, tx *sqlx.Tx) error {
	log.Printf("Deleting org user, org: %s | user: %s\n", orgId, userId)

	_, err := tx.Exec("DELETE FROM orgs_users WHERE org_id = $1 AND user_id = $2", orgId, userId)

	if err != nil {
		return fmt.Errorf("error deleting org member: %v", err)
	}

	return nil
}

func CreateOrgUser(orgId, userId, orgRoleId string, tx *sqlx.Tx) error {
	query := "INSERT INTO orgs_users (org_id, user_id, org_role_id) VALUES ($1, $2, $3)"
	var err error
	if tx == nil {
		_, err = Conn.Exec(query, orgId, userId, orgRoleId)
	} else {
		_, err = tx.Exec(query, orgId, userId, orgRoleId)
	}

	if err != nil {
		return fmt.Errorf("error adding org member: %v", err)
	}

	return nil
}

func ListOrgRoles(orgId string) ([]*OrgRole, error) {
	var orgRoles []*OrgRole
	err := Conn.Select(&orgRoles, "SELECT * FROM org_roles WHERE org_id IS NULL OR org_id = $1", orgId)

	if err != nil {
		return nil, fmt.Errorf("error listing org roles: %v", err)
	}

	return orgRoles, nil
}

func AddToOrgForDomain(userId, domain string, tx *sqlx.Tx) (string, error) {
	org, err := GetOrgForDomain(domain)

	if err != nil {
		return "", fmt.Errorf("error getting org for domain: %v", err)
	}

	orgOwnerRoleId, err := GetOrgOwnerRoleId()

	if err != nil {
		return "", fmt.Errorf("error getting org owner role id: %v", err)
	}

	if org != nil && org.AutoAddDomainUsers {
		err = CreateOrgUser(org.Id, userId, orgOwnerRoleId, tx)

		if err != nil {
			return "", fmt.Errorf("error adding org user: %v", err)
		}
	}

	var orgId string
	if org != nil {
		orgId = org.Id
	}

	return orgId, nil
}


================================================
FILE: app/server/db/plan_config_helpers.go
================================================
package db

import (
	"fmt"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
)

func GetPlanConfig(planId string) (*shared.PlanConfig, error) {
	query := "SELECT plan_config FROM plans WHERE id = $1"

	var config shared.PlanConfig
	err := Conn.Get(&config, query, planId)

	if err != nil {
		return nil, fmt.Errorf("error getting plan config: %v", err)
	}

	return &config, nil
}

func StorePlanConfig(planId string, config *shared.PlanConfig) error {
	query := `
		UPDATE plans 
		SET plan_config = $1
		WHERE id = $2
	`

	_, err := Conn.Exec(query, config, planId)

	if err != nil {
		return fmt.Errorf("error storing plan config: %v", err)
	}

	return nil
}

func GetDefaultPlanConfig(userId string) (*shared.PlanConfig, error) {
	query := "SELECT default_plan_config FROM users WHERE id = $1"

	var config shared.PlanConfig
	err := Conn.Get(&config, query, userId)

	if err != nil {
		return nil, fmt.Errorf("error getting default plan config: %v", err)
	}

	return &config, nil
}

func StoreDefaultPlanConfig(userId string, config *shared.PlanConfig, tx *sqlx.Tx) error {
	query := `
		UPDATE users SET default_plan_config = $1 WHERE id = $2
	`

	_, err := tx.Exec(query, config, userId)

	if err != nil {
		return fmt.Errorf("error storing default plan config: %v", err)
	}

	return nil
}


================================================
FILE: app/server/db/plan_helpers.go
================================================
package db

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"runtime/debug"
	"strconv"
	"time"

	shared "plandex-shared"

	"github.com/google/uuid"
	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
	"github.com/sashabaranov/go-openai"
)

func CreatePlan(ctx context.Context, orgId, projectId, userId, name string) (*Plan, error) {
	var plan *Plan
	err := WithTx(ctx, "create plan", func(tx *sqlx.Tx) error {

		planConfig, err := GetDefaultPlanConfig(userId)

		if err != nil {
			return fmt.Errorf("error getting default plan config: %v", err)
		}

		query := `INSERT INTO plans (org_id, owner_id, project_id, name, plan_config) 
	VALUES ($1, $2, $3, $4, $5)
	RETURNING id, created_at, updated_at`

		plan = &Plan{
			OrgId:      orgId,
			OwnerId:    userId,
			ProjectId:  projectId,
			Name:       name,
			PlanConfig: planConfig,
		}

		err = tx.QueryRow(
			query,
			orgId,
			userId,
			projectId,
			name,
			planConfig,
		).Scan(
			&plan.Id,
			&plan.CreatedAt,
			&plan.UpdatedAt,
		)

		if err != nil {
			return fmt.Errorf("error creating plan: %v", err)
		}

		_, err = tx.Exec("INSERT INTO lockable_plan_ids (plan_id) VALUES ($1)", plan.Id)

		if err != nil {
			return fmt.Errorf("error inserting lockable plan id: %v", err)
		}

		// the one place where we do this to skip the locking queue
		// ok to cheat this once since we're creating a new plan
		repo := getGitRepo(orgId, plan.Id)
		_, err = CreateBranch(repo, plan, nil, "main", tx)

		if err != nil {
			return fmt.Errorf("error creating main branch: %v", err)
		}

		log.Println("Created branch main")

		err = InitPlan(orgId, plan.Id)

		if err != nil {
			return fmt.Errorf("error initializing plan dir: %v", err)
		}

		log.Println("Initialized plan dir")

		return nil
	})

	if err != nil {
		return nil, err
	}

	return plan, nil
}

func ListOwnedPlans(projectIds []string, userId string, archived bool) ([]*Plan, error) {
	qs := "SELECT * FROM plans WHERE project_id = ANY($1) AND owner_id = $2"
	qargs := []interface{}{pq.Array(projectIds), userId}

	if archived {
		qs += " AND archived_at IS NOT NULL"
	} else {
		qs += " AND archived_at IS NULL"
	}

	qs += " ORDER BY updated_at DESC"

	var plans []*Plan
	err := Conn.Select(&plans, qs, qargs...)

	if err != nil {
		return nil, fmt.Errorf("error listing plans: %v", err)
	}

	return plans, nil
}

func GetPlanNamesById(planIds []string) (map[string]string, error) {
	var plans []*Plan
	err := Conn.Select(&plans, "SELECT id, name FROM plans WHERE id = ANY($1)", pq.Array(planIds))
	if err != nil {
		return nil, fmt.Errorf("error getting plan names: %v", err)
	}

	namesMap := make(map[string]string)
	for _, plan := range plans {
		namesMap[plan.Id] = plan.Name
	}

	return namesMap, nil
}

func AddPlanContextTokens(planId, branch string, addTokens int) error {
	_, err := Conn.Exec("UPDATE branches SET context_tokens = context_tokens + $1 WHERE plan_id = $2 AND name = $3", addTokens, planId, branch)
	if err != nil {
		return fmt.Errorf("error updating plan tokens: %v", err)
	}
	return nil
}

func AddPlanConvoMessage(msg *ConvoMessage, branch string) error {
	errCh := make(chan error, 2)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in AddPlanConvoMessage: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in AddPlanConvoMessage: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()

		_, err := Conn.Exec("UPDATE branches SET convo_tokens = convo_tokens + $1 WHERE plan_id = $2 AND name = $3", msg.Tokens, msg.PlanId, branch)

		if err != nil {
			errCh <- fmt.Errorf("error updating plan tokens: %v", err)
			return
		}

		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in AddPlanConvoMessage: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in AddPlanConvoMessage: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()

		if msg.Role != openai.ChatMessageRoleAssistant {
			errCh <- nil
			return
		}
		_, err := Conn.Exec("UPDATE plans SET total_replies = total_replies + 1 WHERE id = $1", msg.PlanId)
		if err != nil {
			errCh <- fmt.Errorf("error updating plan total replies: %v", err)
		}

		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error updating plan tokens: %v", err)
		}
	}

	return nil
}

func SyncPlanTokens(orgId, planId, branch string) error {
	var contexts []*Context
	var convos []*ConvoMessage
	errCh := make(chan error, 2)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in SyncPlanTokens: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in SyncPlanTokens: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		var err error
		contexts, err = GetPlanContexts(orgId, planId, false, false)
		errCh <- err
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in SyncPlanTokens: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in SyncPlanTokens: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		var err error
		convos, err = GetPlanConvo(orgId, planId)
		errCh <- err
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error getting contexts or convo: %v", err)
		}
	}

	contextTokens := 0
	for _, context := range contexts {
		contextTokens += context.NumTokens
	}

	convoTokens := 0
	for _, msg := range convos {
		convoTokens += msg.Tokens
	}

	_, err := Conn.Exec("UPDATE branches SET context_tokens = $1, convo_tokens = $2 WHERE plan_id = $3 AND name = $4", contextTokens, convoTokens, planId, branch)

	if err != nil {
		return fmt.Errorf("error updating plan tokens: %v", err)
	}

	return nil
}

func GetPlan(planId string) (*Plan, error) {
	var plan Plan

	err := Conn.Get(&plan, "SELECT * FROM plans WHERE id = $1", planId)

	if err != nil {
		return nil, fmt.Errorf("error getting plan: %v", err)
	}

	return &plan, nil
}

func SetPlanStatus(planId, branch string, status shared.PlanStatus, errStr string) error {
	_, err := Conn.Exec("UPDATE branches SET status = $1, error = $2 WHERE plan_id = $3 AND name = $4", status, errStr, planId, branch)

	if err != nil {
		return fmt.Errorf("error setting plan status: %v", err)
	}

	return nil
}

func RenamePlan(planId string, name string, tx *sqlx.Tx) error {
	var err error
	if tx == nil {
		_, err = Conn.Exec("UPDATE plans SET name = $1 WHERE id = $2", name, planId)
	} else {
		_, err = tx.Exec("UPDATE plans SET name = $1 WHERE id = $2", name, planId)
	}

	if err != nil {
		return fmt.Errorf("error renaming plan: %v", err)
	}

	return nil
}

func IncActiveBranches(planId string, inc int, tx *sqlx.Tx) error {
	_, err := tx.Exec("UPDATE plans SET active_branches = active_branches + $1 WHERE id = $2", inc, planId)

	if err != nil {
		return fmt.Errorf("error updating plan active branches: %v", err)
	}

	return nil
}

func IncNumNonDraftPlans(userId string, tx *sqlx.Tx) error {
	_, err := tx.Exec("UPDATE users SET num_non_draft_plans = num_non_draft_plans + 1 WHERE id = $1", userId)

	if err != nil {
		return fmt.Errorf("error updating user num_non_draft_plans: %v", err)
	}

	return nil
}

func StoreDescription(description *ConvoMessageDescription) error {
	descriptionsDir := getPlanDescriptionsDir(description.OrgId, description.PlanId)

	err := os.MkdirAll(descriptionsDir, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error creating convo message descriptions dir: %v", err)
	}

	for _, op := range description.Operations {
		if op.Content != "" {
			quoted := strconv.Quote(op.Content)
			op.Content = quoted[1 : len(quoted)-1]
		}
		if op.Description != "" {
			quoted := strconv.Quote(op.Description)
			op.Description = quoted[1 : len(quoted)-1]
		}
	}

	now := time.Now()

	if description.Id == "" {
		description.Id = uuid.New().String()
		description.CreatedAt = now
	}
	description.UpdatedAt = now

	bytes, err := json.Marshal(description)

	if err != nil {
		return fmt.Errorf("error marshalling convo message description: %v", err)
	}

	err = os.WriteFile(filepath.Join(descriptionsDir, description.Id+".json"), bytes, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error writing convo message description: %v", err)
	}

	return nil
}

func DeleteDraftPlans(orgId, projectId, userId string) error {
	res, err := Conn.Query("DELETE FROM plans WHERE project_id = $1 AND owner_id = $2 AND name = 'draft' RETURNING id;", projectId, userId)
	if err != nil {
		return fmt.Errorf("error deleting draft plans: %v", err)
	}

	defer res.Close()

	// get ids
	var ids []string

	for res.Next() {
		var id string
		err := res.Scan(&id)
		if err != nil {
			return fmt.Errorf("error scanning deleted draft plan id: %v", err)
		}
		ids = append(ids, id)
	}

	errCh := make(chan error, len(ids))
	for _, planId := range ids {
		go func(planId string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in DeleteDraftPlans: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in DeleteDraftPlans: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			errCh <- DeletePlanDir(orgId, planId)
		}(planId)
	}

	for i := 0; i < len(ids); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error deleting draft plan dir: %v", err)
		}
	}

	if len(ids) > 0 {
		log.Println("Deleted", len(ids), "draft plans")
	}

	return nil
}

func DeleteOwnerPlans(orgId, projectId, userId string) error {
	res, err := Conn.Query("DELETE FROM plans WHERE project_id = $1 AND owner_id = $2 RETURNING id;", projectId, userId)
	if err != nil {
		return fmt.Errorf("error deleting plans: %v", err)
	}

	defer res.Close()

	// get ids
	var ids []string

	for res.Next() {
		var id string
		err := res.Scan(&id)
		if err != nil {
			return fmt.Errorf("error scanning deleted draft plan id: %v", err)
		}
		ids = append(ids, id)
	}

	errCh := make(chan error, len(ids))
	for _, planId := range ids {
		go func(planId string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in DeleteOwnerPlans: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in DeleteOwnerPlans: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			errCh <- DeletePlanDir(orgId, planId)
		}(planId)
	}

	for i := 0; i < len(ids); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error deleting plan dir: %v", err)
		}
	}

	if len(ids) > 0 {
		log.Println("Deleted", len(ids), "plans")
	}

	return nil
}

func ValidatePlanAccess(planId, userId, orgId string) (*Plan, error) {
	// get plan
	plan, err := GetPlan(planId)

	if err != nil {
		return nil, fmt.Errorf("error getting plan: %v", err)
	}

	if plan == nil {
		return nil, nil
	}

	if plan.OrgId != orgId {
		return nil, nil
	}

	hasProjectAccess, err := ProjectExists(orgId, plan.ProjectId)

	if err != nil {
		return nil, fmt.Errorf("error validating project membership: %v", err)
	}

	if !hasProjectAccess {
		return nil, nil
	}

	// owner has access
	if plan.OwnerId == userId {
		return plan, nil
	}

	// plan is shared with org
	if plan.SharedWithOrgAt != nil {
		return plan, nil
	}

	return nil, nil
}

func BumpPlanUpdatedAt(planId string, t time.Time) error {
	_, err := Conn.Exec("UPDATE plans SET updated_at = $1 WHERE id = $2", t, planId)

	if err != nil {
		return fmt.Errorf("error updating plan updated at: %v", err)
	}

	return nil
}

func GetPlanIdsForProject(projectId string) ([]string, error) {
	var ids []string
	err := Conn.Select(&ids, "SELECT id FROM plans WHERE project_id = $1", projectId)
	if err != nil {
		return nil, fmt.Errorf("error getting plan ids for project: %v", err)
	}
	return ids, nil
}


================================================
FILE: app/server/db/project_helpers.go
================================================
package db

import (
	"fmt"

	"github.com/jmoiron/sqlx"
)

func ProjectExists(orgId, projectId string) (bool, error) {
	var count int
	err := Conn.QueryRow("SELECT COUNT(*) FROM projects WHERE org_id = $1 AND id = $2", orgId, projectId).Scan(&count)

	if err != nil {
		return false, fmt.Errorf("error checking if project exists: %v", err)
	}

	return count > 0, nil
}

func CreateProject(orgId, name string, tx *sqlx.Tx) (string, error) {
	var projectId string
	err := tx.QueryRow("INSERT INTO projects (org_id, name) VALUES ($1, $2) RETURNING id", orgId, name).Scan(&projectId)

	if err != nil {
		return "", fmt.Errorf("error creating project: %v", err)
	}

	return projectId, nil
}


================================================
FILE: app/server/db/queue.go
================================================
package db

import (
	"context"
	"fmt"
	"log"
	"runtime/debug"
	"sync"

	"github.com/google/uuid"
)

type repoOpFn func(repo *GitRepo) error

type repoOperation struct {
	orgId          string
	userId         string
	planId         string
	branch         string
	scope          LockScope
	planBuildId    string
	id             string
	reason         string
	op             repoOpFn
	ctx            context.Context
	cancelFn       context.CancelFunc
	done           chan error
	clearRepoOnErr bool
}

type repoQueue struct {
	ops          []*repoOperation
	mu           sync.Mutex
	isProcessing bool
}

type repoQueueMap map[string]*repoQueue

var queuesMu sync.Mutex
var repoQueues = make(repoQueueMap)

func (m repoQueueMap) getQueue(planId string) *repoQueue {
	queuesMu.Lock()
	defer queuesMu.Unlock()

	if locksVerboseLogging {
		log.Printf("[Queue] Getting queue for plan %s", planId)
	}

	q, ok := m[planId]
	if !ok {
		if locksVerboseLogging {
			log.Printf("[Queue] Creating new queue for plan %s", planId)
		}
		q = &repoQueue{}
		m[planId] = q
	}
	return q
}

func (m repoQueueMap) add(op *repoOperation) int {
	if locksVerboseLogging {
		log.Printf("[Queue] Adding operation %s (%s) to queue for plan %s", op.id, op.reason, op.planId)
	}
	q := m.getQueue(op.planId)
	return q.add(op)
}

// Add enqueues an operation, and then kicks off processing if needed.
func (q *repoQueue) add(op *repoOperation) int {
	var numOps int
	q.mu.Lock()
	q.ops = append(q.ops, op)
	numOps = len(q.ops)

	if locksVerboseLogging {
		log.Printf("[Queue] Operation %s (%s) enqueued, queue length now %d", op.id, op.reason, numOps)
	}

	// If nobody else is processing, we'll start
	if !q.isProcessing {
		if locksVerboseLogging {
			log.Printf("[Queue] Starting queue processing for operation %s (%s)", op.id, op.reason)
		}
		q.isProcessing = true
		go q.runQueue() // run in the background
	} else if locksVerboseLogging {
		log.Printf("[Queue] Queue already processing, operation %s (%s) will wait", op.id, op.reason)
	}
	q.mu.Unlock()

	return numOps
}

func (q *repoQueue) nextBatch() []*repoOperation {
	q.mu.Lock()
	defer q.mu.Unlock()

	if len(q.ops) == 0 {
		if locksVerboseLogging {
			log.Printf("[Queue] No operations in queue")
		}
		return nil
	}

	firstOp := q.ops[0]
	res := []*repoOperation{firstOp}

	if locksVerboseLogging {
		log.Printf("[Queue] Processing first operation %s (%s) with scope %s, branch %s",
			firstOp.id, firstOp.reason, firstOp.scope, firstOp.branch)
	}

	q.ops = q.ops[1:]

	// writes always go one at a time, blocking everything else, as do read locks on the root plan (no branch)
	if firstOp.scope == LockScopeWrite || firstOp.branch == "" {
		if locksVerboseLogging {
			log.Printf("[Queue] Operation %s is write or root branch read, processing alone", firstOp.id)
		}
		return res
	}

	// reads go in parallel as long as they are on the same branch
	for len(q.ops) > 0 {
		op := q.ops[0]
		if op.scope == LockScopeRead && op.branch == firstOp.branch {
			if locksVerboseLogging {
				log.Printf("[Queue] Batching compatible read operation %s (%s) with same branch %s",
					op.id, op.reason, op.branch)
			}
			res = append(res, op)
			q.ops = q.ops[1:]
		} else {
			if locksVerboseLogging {
				log.Printf("[Queue] Operation %s (%s) with scope %s, branch %s not compatible with batch, stopping",
					op.id, op.reason, op.scope, op.branch)
			}
			break
		}
	}

	if locksVerboseLogging {
		log.Printf("[Queue] Created batch of %d operations", len(res))
	}

	return res
}

func (q *repoQueue) runQueue() {
	if locksVerboseLogging {
		log.Printf("[Queue] Starting queue processing")
	}

	for {
		// get the next batch
		ops := q.nextBatch()
		if len(ops) == 0 {
			// Nothing left in the queue, so mark not processing and return
			if locksVerboseLogging {
				log.Printf("[Queue] Queue empty, stopping processing")
			}
			q.mu.Lock()
			q.isProcessing = false
			q.mu.Unlock()
			return
		}

		firstOp := ops[0]

		func() {

			if locksVerboseLogging {
				log.Printf("[Queue] Attempting to acquire DB lock for plan %s, branch %s, scope %s",
					firstOp.planId, firstOp.branch, firstOp.scope)
			}

			lockId, err := lockRepoDB(LockRepoParams{
				OrgId:       firstOp.orgId,
				UserId:      firstOp.userId,
				PlanId:      firstOp.planId,
				Branch:      firstOp.branch,
				Scope:       firstOp.scope,
				PlanBuildId: firstOp.planBuildId,
				Reason:      firstOp.reason,
				Ctx:         firstOp.ctx,
				CancelFn:    firstOp.cancelFn,
			}, 0)

			if lockId != "" {
				log.Printf("[Queue] Acquired DB lock %s", lockId)

				defer func() {
					log.Printf("[Queue] Releasing DB lock %s for plan %s", lockId, firstOp.planId)
					releaseErr := deleteRepoLockDB(lockId, firstOp.planId, firstOp.reason, 0)
					if releaseErr != nil {
						log.Printf("[Queue] Failed to release DB lock: %v", releaseErr)
					} else {
						log.Printf("[Queue] DB lock %s released successfully", lockId)
					}
				}()
			}

			if err != nil {
				log.Printf("[Queue] Failed to get DB lock: %v", err)
				for _, op := range ops {
					if locksVerboseLogging {
						log.Printf("[Queue] Notifying operation %s (%s) of lock failure", op.id, op.reason)
					}
					op.done <- fmt.Errorf("failed to get DB lock: %w", err)
				}
				// we still need to process the rest of the queue
				// if the error is critical, caller will handle it
				return
			}

			if locksVerboseLogging {
				log.Printf("[Queue] Acquired DB lock %s, processing batch of %d operations", lockId, len(ops))
			}

			repo := getGitRepo(firstOp.orgId, firstOp.planId)
			var needsRollback bool

			// Process the batch
			// If it's a writer => single op
			// If multiple same‐branch readers => do them in parallel
			var wg sync.WaitGroup
			for _, op := range ops {
				wg.Add(1)
				go func(op *repoOperation) {
					defer wg.Done()
					select {
					case <-op.ctx.Done():
						if locksVerboseLogging {
							log.Printf("[Queue] Operation %s (%s) context canceled", op.id, op.reason)
						}
						op.done <- op.ctx.Err()
					default:
						if locksVerboseLogging {
							log.Printf("[Queue] Starting operation %s (%s)", op.id, op.reason)
						}
						// actually do the operation

						var opErr error

						func() {
							defer func() {
								panicErr := recover()
								if panicErr != nil {
									log.Printf("[Queue] Panic in operation %s (%s): %v", op.id, op.reason, panicErr)
									log.Printf("[Queue] Stack trace: %s", string(debug.Stack()))
									opErr = fmt.Errorf("panic in operation: %v\n%s", panicErr, string(debug.Stack()))
								}

								if opErr != nil && op.scope == LockScopeWrite && op.clearRepoOnErr {
									if locksVerboseLogging {
										log.Printf("[Queue] Operation %s (%s) failed with error, marking for rollback: %v",
											op.id, op.reason, opErr)
									}
									needsRollback = true
								}
							}()

							if locksVerboseLogging {
								log.Printf("[Queue] Executing operation %s (%s)", op.id, op.reason)
							}
							opErr = op.op(repo)
							if locksVerboseLogging {
								if opErr != nil {
									log.Printf("[Queue] Operation %s (%s) failed with error: %v", op.id, op.reason, opErr)
								} else {
									log.Printf("[Queue] Operation %s (%s) completed successfully", op.id, op.reason)
								}
							}
						}()

						// signal to the caller via op.done
						if locksVerboseLogging {
							log.Printf("[Queue] Notifying caller of operation %s (%s) completion", op.id, op.reason)
						}
						op.done <- opErr
					}
				}(op)
			}
			wg.Wait()

			if needsRollback {
				log.Printf("[Queue] Performing rollback for plan %s branch %s", firstOp.planId, firstOp.branch)
				rollbackErr := repo.GitClearUncommittedChanges(firstOp.branch)
				if rollbackErr != nil {
					log.Printf("[Queue] Failed to rollback: %v", rollbackErr)
				} else if locksVerboseLogging {
					log.Printf("[Queue] Rollback completed successfully")
				}
			}
		}()
	}
}

type ExecRepoOperationParams struct {
	OrgId          string
	UserId         string
	PlanId         string
	Branch         string
	Scope          LockScope
	PlanBuildId    string
	Reason         string
	Ctx            context.Context
	CancelFn       context.CancelFunc
	ClearRepoOnErr bool
}

func ExecRepoOperation(
	params ExecRepoOperationParams,
	op repoOpFn,
) error {
	id := uuid.New().String()

	log.Printf("[Queue] ExecRepoOperation called for plan %s, branch %s, scope %s, reason %s",
		params.PlanId, params.Branch, params.Scope, params.Reason)

	done := make(chan error, 1)
	numOps := repoQueues.add(&repoOperation{
		id:             id,
		orgId:          params.OrgId,
		planId:         params.PlanId,
		branch:         params.Branch,
		scope:          params.Scope,
		reason:         params.Reason,
		planBuildId:    params.PlanBuildId,
		op:             op,
		done:           done,
		ctx:            params.Ctx,
		cancelFn:       params.CancelFn,
		clearRepoOnErr: params.ClearRepoOnErr,
	})

	if numOps > 1 {
		if locksVerboseLogging {
			log.Printf("[Queue] Operation %s (%s) queued behind %d operations", id, params.Reason, numOps-1)
			for i, op := range repoQueues.getQueue(params.PlanId).ops {
				log.Printf("[Queue] Operation %d: %s - %s\n", i, op.id, op.reason)
			}
		}
	}

	select {
	case err := <-done:
		if locksVerboseLogging {
			if err != nil {
				log.Printf("[Queue] Operation %s (%s) completed with error: %v", id, params.Reason, err)
			} else {
				log.Printf("[Queue] Operation %s (%s) completed successfully", id, params.Reason)
			}
		}
		return err
	case <-params.Ctx.Done():
		if locksVerboseLogging {
			log.Printf("[Queue] Operation %s (%s) context canceled while waiting", id, params.Reason)
		}
		return params.Ctx.Err()
	}
}


================================================
FILE: app/server/db/rbac_helpers.go
================================================
package db

import (
	"fmt"
	"log"
)

var orgOwnerRoleId string
var orgMemberRoleId string

func GetOrgOwnerRoleId() (string, error) {
	if orgOwnerRoleId == "" {
		err := cacheOrgOwnerRoleId()
		if err != nil {
			return "", fmt.Errorf("error getting org owner role id: %v", err)
		}
	}

	if orgOwnerRoleId == "" {
		return "", fmt.Errorf("org owner role id is empty")
	}

	return orgOwnerRoleId, nil
}

func GetOrgMemberRoleId() (string, error) {
	if orgMemberRoleId == "" {
		err := cacheOrgMemberRoleId()
		if err != nil {
			return "", fmt.Errorf("error getting org member role id: %v", err)
		}
	}

	if orgMemberRoleId == "" {
		return "", fmt.Errorf("org member role id is empty")
	}

	return orgMemberRoleId, nil
}

func GetOrgOwners(orgId string) ([]*User, error) {
	var users []*User
	err := Conn.Select(&users, "SELECT * FROM users WHERE id IN (SELECT user_id FROM orgs_users WHERE org_id = $1 AND org_role_id = $2)", orgId, orgOwnerRoleId)

	if err != nil {
		return nil, fmt.Errorf("error getting org owners: %v", err)
	}

	return users, nil
}

func CacheOrgRoleIds() error {
	err := cacheOrgOwnerRoleId()
	if err != nil {
		return fmt.Errorf("error getting org owner role id: %v", err)

	}

	if orgOwnerRoleId == "" {
		log.Println("org owner role id is empty at startup")
	}

	err = cacheOrgMemberRoleId()
	if err != nil {
		return fmt.Errorf("error getting org member role id: %v", err)
	}

	if orgMemberRoleId == "" {
		log.Println("org member role id is empty at startup")
	}

	return nil
}

func cacheOrgOwnerRoleId() error {
	var roleId string
	err := Conn.Get(&roleId, "SELECT id FROM org_roles WHERE name = 'owner'")

	if err != nil {
		return fmt.Errorf("error getting owner role id: %v", err)
	}

	orgOwnerRoleId = roleId

	return nil
}

func cacheOrgMemberRoleId() error {
	var roleId string
	err := Conn.Get(&roleId, "SELECT id FROM org_roles WHERE name = 'member'")

	if err != nil {
		return fmt.Errorf("error getting member role id: %v", err)
	}

	orgMemberRoleId = roleId

	return nil
}


================================================
FILE: app/server/db/result_helpers.go
================================================
package db

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"runtime/debug"
	"sort"
	"strings"
	"sync"
	"time"

	shared "plandex-shared"

	"github.com/google/uuid"
)

func StorePlanResult(result *PlanFileResult) error {
	now := time.Now()
	if result.Id == "" {
		result.Id = uuid.New().String()
		result.CreatedAt = now
	}
	result.UpdatedAt = now

	bytes, err := json.MarshalIndent(result, "", "  ")

	if err != nil {
		return fmt.Errorf("error marshalling result: %v", err)
	}

	resultsDir := getPlanResultsDir(result.OrgId, result.PlanId)

	err = os.MkdirAll(resultsDir, 0755)

	if err != nil {
		return fmt.Errorf("error creating results dir: %v", err)
	}

	log.Printf("Storing plan result: %s - %s", result.Path, result.Id)

	err = os.WriteFile(filepath.Join(resultsDir, result.Id+".json"), bytes, 0644)

	if err != nil {
		return fmt.Errorf("error writing result file: %v", err)
	}

	return nil

}

type CurrentPlanStateParams struct {
	OrgId                    string
	PlanId                   string
	PlanFileResults          []*PlanFileResult
	ConvoMessageDescriptions []*ConvoMessageDescription
	Contexts                 []*Context
}

func GetFullCurrentPlanStateParams(orgId, planId string) (CurrentPlanStateParams, error) {
	errCh := make(chan error, 3)

	var results []*PlanFileResult
	var convoMessageDescriptions []*ConvoMessageDescription
	var contexts []*Context

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()

		res, err := GetPlanFileResults(orgId, planId)
		if err != nil {
			errCh <- fmt.Errorf("error getting plan file results: %v", err)
			return
		}
		results = res
		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		res, err := GetConvoMessageDescriptions(orgId, planId)
		if err != nil {
			errCh <- fmt.Errorf("error getting latest plan build description: %v", err)
			return
		}
		convoMessageDescriptions = res
		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetFullCurrentPlanStateParams: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		res, err := GetPlanContexts(orgId, planId, true, false)
		if err != nil {
			errCh <- fmt.Errorf("error getting contexts: %v", err)
			return
		}

		contexts = res

		errCh <- nil
	}()

	for i := 0; i < 3; i++ {
		err := <-errCh
		if err != nil {
			return CurrentPlanStateParams{}, err
		}
	}

	return CurrentPlanStateParams{
		OrgId:                    orgId,
		PlanId:                   planId,
		PlanFileResults:          results,
		ConvoMessageDescriptions: convoMessageDescriptions,
		Contexts:                 contexts,
	}, nil
}

func GetCurrentPlanState(params CurrentPlanStateParams) (*shared.CurrentPlanState, error) {
	orgId := params.OrgId
	planId := params.PlanId

	var dbPlanFileResults []*PlanFileResult
	var convoMessageDescriptions []*shared.ConvoMessageDescription
	contextsByPath := map[string]*Context{}
	planApplies := []*shared.PlanApply{}
	errCh := make(chan error, 4)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		if params.PlanFileResults == nil {
			res, err := GetPlanFileResults(orgId, planId)
			dbPlanFileResults = res

			if err != nil {
				errCh <- fmt.Errorf("error getting plan file results: %v", err)
				return
			}
		} else {
			dbPlanFileResults = params.PlanFileResults
		}

		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		if params.ConvoMessageDescriptions == nil {
			res, err := GetConvoMessageDescriptions(orgId, planId)
			if err != nil {
				errCh <- fmt.Errorf("error getting latest plan build description: %v", err)
				return
			}

			for _, desc := range res {
				convoMessageDescriptions = append(convoMessageDescriptions, desc.ToApi())
			}
		} else {
			for _, desc := range params.ConvoMessageDescriptions {
				convoMessageDescriptions = append(convoMessageDescriptions, desc.ToApi())
			}
		}

		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		var contexts []*Context
		if params.Contexts == nil {
			res, err := GetPlanContexts(orgId, planId, true, false)
			if err != nil {
				errCh <- fmt.Errorf("error getting contexts: %v", err)
				return
			}
			contexts = res

			log.Println("Got contexts:", len(contexts))
		} else {
			contexts = params.Contexts
		}

		for _, context := range contexts {
			if context.FilePath != "" {
				contextsByPath[context.FilePath] = context
			}
		}

		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in GetCurrentPlanState: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		res, err := GetPlanApplies(orgId, planId)
		if err != nil {
			errCh <- fmt.Errorf("error getting plan applies: %v", err)
			return
		}

		for _, apply := range res {
			planApplies = append(planApplies, apply.ToApi())
		}

		errCh <- nil
	}()

	for i := 0; i < 4; i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	var apiPlanFileResults []*shared.PlanFileResult
	pendingResultPaths := map[string]bool{}

	for _, dbPlanFileResult := range dbPlanFileResults {
		// log.Printf("Plan file result: %s", dbPlanFileResult.Id)

		apiResult := dbPlanFileResult.ToApi()
		apiPlanFileResults = append(apiPlanFileResults, apiResult)

		if apiResult.IsPending() {
			// log.Printf("Pending result: %s", dbPlanFileResult.Id)

			pendingResultPaths[apiResult.Path] = true
		} else {
			// log.Printf("Not pending result: %s", apiResult.Id)
			// log.Printf("Applied at: %v", apiResult.AppliedAt)
			// log.Printf("Rejected at: %v", apiResult.RejectedAt)
			// log.Printf("Content: %v", apiResult.Content != "")
			// log.Printf("Num Replacement: %d", len(apiResult.Replacements))
			// log.Printf("Num Pending Replacements: %v", apiResult.NumPendingReplacements())
		}
	}
	planResult := GetPlanResult(apiPlanFileResults)

	pendingContextsByPath := map[string]*shared.Context{}
	for path, context := range contextsByPath {
		pendingContextsByPath[path] = context.ToApi()
	}

	// log.Println("Pending contexts by path:", len(pendingContextsByPath))

	planState := &shared.CurrentPlanState{
		PlanResult:               planResult,
		ConvoMessageDescriptions: convoMessageDescriptions,
		ContextsByPath:           pendingContextsByPath,
		PlanApplies:              planApplies,
	}

	currentPlanFiles, err := planState.GetFiles()

	if err != nil {
		return nil, fmt.Errorf("error getting current plan files: %v", err)
	}

	planState.CurrentPlanFiles = currentPlanFiles

	return planState, nil
}

func GetConvoMessageDescriptions(orgId, planId string) ([]*ConvoMessageDescription, error) {
	var descriptions []*ConvoMessageDescription
	descriptionsDir := getPlanDescriptionsDir(orgId, planId)
	files, err := os.ReadDir(descriptionsDir)

	if err != nil {

		if os.IsNotExist(err) {
			return descriptions, nil
		}

		return nil, fmt.Errorf("error reading descriptions dir: %v", err)
	}

	errCh := make(chan error, len(files))
	descCh := make(chan *ConvoMessageDescription, len(files))

	for _, file := range files {
		go func(file os.DirEntry) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetConvoMessageDescriptions: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetConvoMessageDescriptions: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			path := filepath.Join(descriptionsDir, file.Name())

			bytes, err := os.ReadFile(path)

			if err != nil {
				errCh <- fmt.Errorf("error reading description file %s: %v", file.Name(), err)
				return
			}

			var description ConvoMessageDescription
			err = json.Unmarshal(bytes, &description)

			if err != nil {
				log.Println("Error unmarshalling description file:", path)
				log.Println("bytes:")
				log.Println(string(bytes))

				errCh <- fmt.Errorf("error unmarshalling description file %s: %v", path, err)
				return
			}

			descCh <- &description
		}(file)
	}

	for i := 0; i < len(files); i++ {
		select {
		case err := <-errCh:
			return nil, fmt.Errorf("error reading description files: %v", err)
		case description := <-descCh:
			if description.WroteFiles && description.AppliedAt == nil {
				descriptions = append(descriptions, description)
			}
		}
	}

	sort.Slice(descriptions, func(i, j int) bool {
		return descriptions[i].CreatedAt.Before(descriptions[j].CreatedAt)
	})

	return descriptions, nil
}

func GetPlanFileResults(orgId, planId string) ([]*PlanFileResult, error) {
	var results []*PlanFileResult

	resultsDir := getPlanResultsDir(orgId, planId)

	files, err := os.ReadDir(resultsDir)

	if err != nil {
		if os.IsNotExist(err) {
			return results, nil
		}

		return nil, fmt.Errorf("error reading results dir: %v", err)
	}

	errCh := make(chan error, len(files))
	resultCh := make(chan *PlanFileResult, len(files))

	for _, file := range files {
		// log.Printf("Result file: %s", file.Name())

		go func(file os.DirEntry) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanFileResults: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanFileResults: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			bytes, err := os.ReadFile(filepath.Join(resultsDir, file.Name()))

			if err != nil {
				errCh <- fmt.Errorf("error reading result file: %v", err)
				return
			}

			var result PlanFileResult
			err = json.Unmarshal(bytes, &result)

			if err != nil {
				errCh <- fmt.Errorf("error unmarshalling result file: %v", err)
				return
			}

			resultCh <- &result
		}(file)
	}

	for i := 0; i < len(files); i++ {
		select {
		case err := <-errCh:
			return nil, fmt.Errorf("error reading result files: %v", err)
		case result := <-resultCh:
			results = append(results, result)
		}
	}

	sort.Slice(results, func(i, j int) bool {
		return results[i].CreatedAt.Before(results[j].CreatedAt)
	})

	return results, nil
}

func GetPlanFileResultById(orgId, planId, resultId string) (*PlanFileResult, error) {
	resultsDir := getPlanResultsDir(orgId, planId)

	bytes, err := os.ReadFile(filepath.Join(resultsDir, resultId+".json"))

	if err != nil {
		return nil, fmt.Errorf("error reading result file: %v", err)
	}

	var result PlanFileResult
	err = json.Unmarshal(bytes, &result)

	if err != nil {
		return nil, fmt.Errorf("error unmarshalling result file: %v", err)
	}

	return &result, nil
}

func GetPlanResult(planFileResults []*shared.PlanFileResult) *shared.PlanResult {
	resByPath := make(shared.PlanFileResultsByPath)
	replacementsByPath := make(map[string][]*shared.Replacement)
	var paths []string

	for _, planFileRes := range planFileResults {
		if planFileRes.IsPending() {
			_, hasPath := resByPath[planFileRes.Path]

			resByPath[planFileRes.Path] = append(resByPath[planFileRes.Path], planFileRes)

			if !hasPath {
				// log.Printf("Adding res path: %s", planFileRes.Path)
				paths = append(paths, planFileRes.Path)
			}
		}
	}

	for _, results := range resByPath {
		for _, planRes := range results {
			replacementsByPath[planRes.Path] = append(replacementsByPath[planRes.Path], planRes.Replacements...)
		}
	}

	// sort paths ascending
	sort.Slice(paths, func(i, j int) bool {
		return paths[i] < paths[j]
	})

	return &shared.PlanResult{
		FileResultsByPath:  resByPath,
		SortedPaths:        paths,
		ReplacementsByPath: replacementsByPath,
		Results:            planFileResults,
	}
}

type ApplyPlanParams struct {
	OrgId                  string
	UserId                 string
	BranchName             string
	Plan                   *Plan
	CurrentPlanState       *shared.CurrentPlanState
	CurrentPlanStateParams *CurrentPlanStateParams
	CommitMsg              string
}

func ApplyPlan(repo *GitRepo, ctx context.Context, params ApplyPlanParams) error {
	orgId := params.OrgId
	userId := params.UserId
	branchName := params.BranchName
	plan := params.Plan
	currentPlanState := params.CurrentPlanState
	currentPlanParams := params.CurrentPlanStateParams
	planId := plan.Id
	resultsDir := getPlanResultsDir(orgId, planId)

	var pendingDbResults []*PlanFileResult

	planFileResults := currentPlanParams.PlanFileResults
	convoMessageDescriptions := currentPlanParams.ConvoMessageDescriptions
	contexts := currentPlanParams.Contexts

	contextsByPath := make(map[string]*Context)
	for _, context := range contexts {
		if context.FilePath != "" {
			contextsByPath[context.FilePath] = context
		}
	}

	for _, result := range planFileResults {
		apiResult := result.ToApi()
		if apiResult.IsPending() {
			pendingDbResults = append(pendingDbResults, result)
		}
	}

	log.Printf("Pending db results: %d", len(pendingDbResults))

	pendingNewFilesSet := make(map[string]bool)
	pendingUpdatedFilesSet := make(map[string]bool)
	for _, result := range pendingDbResults {
		if result.Path == "_apply.sh" {
			continue
		}

		if len(result.Replacements) == 0 && result.Content != "" {
			pendingNewFilesSet[result.Path] = true
		} else if !pendingNewFilesSet[result.Path] {
			pendingUpdatedFilesSet[result.Path] = true
		}
	}

	var loadContextRes *shared.LoadContextResponse
	var updateContextRes *shared.UpdateContextResponse

	numRoutines := len(pendingDbResults) +
		len(convoMessageDescriptions)

	if len(pendingNewFilesSet) > 0 {
		numRoutines++
	}
	if len(pendingUpdatedFilesSet) > 0 {
		numRoutines++
	}

	errCh := make(chan error, numRoutines)
	now := time.Now()

	for _, result := range pendingDbResults {
		go func(result *PlanFileResult) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			result.AppliedAt = &now

			bytes, err := json.MarshalIndent(result, "", "  ")

			if err != nil {
				errCh <- fmt.Errorf("error marshalling result: %v", err)
				return
			}

			err = os.WriteFile(filepath.Join(resultsDir, result.Id+".json"), bytes, 0644)

			if err != nil {
				errCh <- fmt.Errorf("error writing result file: %v", err)
				return
			}

			errCh <- nil

		}(result)
	}

	for _, description := range convoMessageDescriptions {
		go func(description *ConvoMessageDescription) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			description.AppliedAt = &now

			err := StoreDescription(description)

			if err != nil {
				errCh <- fmt.Errorf("error storing convo message description: %v", err)
				return
			}

			errCh <- nil
		}(description)
	}

	if len(pendingNewFilesSet) > 0 {
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			loadReq := shared.LoadContextRequest{}
			for path := range pendingNewFilesSet {
				loadReq = append(loadReq, &shared.LoadContextParams{
					ContextType: shared.ContextFileType,
					Name:        path,
					FilePath:    path,
					Body:        currentPlanState.CurrentPlanFiles.Files[path],
				})
			}

			if len(loadReq) > 0 {
				res, _, err := LoadContexts(
					ctx,
					LoadContextsParams{
						OrgId:                    orgId,
						UserId:                   userId,
						Plan:                     plan,
						BranchName:               branchName,
						Req:                      &loadReq,
						SkipConflictInvalidation: true, // no need to invalidate conflicts when applying plan--and fixes race condition since invalidation check loads description
						AutoLoaded:               true,
					},
				)

				if err != nil {
					errCh <- fmt.Errorf("error loading context: %v", err)
					return
				}

				loadContextRes = res
			}

			errCh <- nil
		}()
	}

	if len(pendingUpdatedFilesSet) > 0 {
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in ApplyPlan: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			updateReq := shared.UpdateContextRequest{}
			for path := range pendingUpdatedFilesSet {
				context := contextsByPath[path]
				updateReq[context.Id] = &shared.UpdateContextParams{
					Body: currentPlanState.CurrentPlanFiles.Files[path],
				}
			}

			if len(updateReq) > 0 {
				res, err := UpdateContexts(
					UpdateContextsParams{
						OrgId:                    orgId,
						Plan:                     plan,
						BranchName:               branchName,
						Req:                      &updateReq,
						SkipConflictInvalidation: true, // no need to invalidate conflicts when applying plan--and fixes race condition since invalidation check loads description
					},
				)

				if err != nil {
					errCh <- fmt.Errorf("error updating context: %v", err)
					return
				}

				updateContextRes = res
			}
			errCh <- nil

		}()

	}

	for i := 0; i < numRoutines; i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error applying plan: %v", err)
		}
	}

	// Store the PlanApply record
	planApply := &PlanApply{
		Id:        uuid.New().String(),
		OrgId:     orgId,
		PlanId:    planId,
		UserId:    userId,
		CommitMsg: params.CommitMsg,
		CreatedAt: now,
	}

	// Collect the IDs from the pending results and descriptions
	var resultIds []string
	var descriptionIds []string
	var messageIds []string

	for _, result := range pendingDbResults {
		resultIds = append(resultIds, result.Id)
	}
	for _, desc := range convoMessageDescriptions {
		descriptionIds = append(descriptionIds, desc.Id)
		messageIds = append(messageIds, desc.ConvoMessageId)
	}

	planApply.PlanFileResultIds = resultIds
	planApply.ConvoMessageDescriptionIds = descriptionIds
	planApply.ConvoMessageIds = messageIds

	// Store the PlanApply object
	bytes, err := json.MarshalIndent(planApply, "", "  ")
	if err != nil {
		return fmt.Errorf("error marshalling plan apply: %v", err)
	}

	appliesDir := getPlanAppliesDir(orgId, planId)
	err = os.MkdirAll(appliesDir, 0755)
	if err != nil {
		return fmt.Errorf("error creating applies dir: %v", err)
	}

	err = os.WriteFile(filepath.Join(appliesDir, planApply.Id+".json"), bytes, 0644)
	if err != nil {
		return fmt.Errorf("error writing plan apply file: %v", err)
	}

	msg := "✅ Marked pending results as applied"

	currentFiles := currentPlanState.CurrentPlanFiles.Files
	var sortedFiles []string
	for path := range currentFiles {
		sortedFiles = append(sortedFiles, path)
	}
	sort.Strings(sortedFiles)
	for _, path := range sortedFiles {
		msg += fmt.Sprintf("\n • 📄 %s", path)
	}
	msg += "\n" + "✏️  " + params.CommitMsg

	if loadContextRes != nil && !loadContextRes.MaxTokensExceeded {
		msg += "\n\n" + loadContextRes.Msg
	}

	if updateContextRes != nil && !updateContextRes.MaxTokensExceeded {
		msg += "\n\n" + updateContextRes.Msg
	}

	err = repo.GitAddAndCommit(branchName, msg)

	if err != nil {
		return fmt.Errorf("error committing plan: %v", err)
	}

	return nil
}

func RejectAllResults(orgId, planId string) error {
	resultsDir := getPlanResultsDir(orgId, planId)

	files, err := os.ReadDir(resultsDir)

	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}

		return fmt.Errorf("error reading results dir: %v", err)
	}

	errCh := make(chan error, len(files))
	now := time.Now()

	for _, file := range files {
		resultId := strings.TrimSuffix(file.Name(), ".json")

		go func(resultId string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in RejectAllResults: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in RejectAllResults: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			err := RejectPlanFile(orgId, planId, resultId, now)

			if err != nil {
				errCh <- fmt.Errorf("error rejecting result: %v", err)
				return
			}

			errCh <- nil
		}(resultId)
	}

	for i := 0; i < len(files); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error rejecting plan: %v", err)
		}
	}

	return nil
}

func DeletePendingResultsForPaths(orgId, planId string, paths map[string]bool) error {
	// log.Println("Deleting pending results for paths")
	resultsDir := getPlanResultsDir(orgId, planId)
	files, err := os.ReadDir(resultsDir)

	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}

		return fmt.Errorf("error reading results dir: %v", err)
	}

	errCh := make(chan error, len(files))

	for _, file := range files {
		resultId := strings.TrimSuffix(file.Name(), ".json")

		go func(resultId string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in DeletePendingResultsForPaths: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in DeletePendingResultsForPaths: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			bytes, err := os.ReadFile(filepath.Join(resultsDir, resultId+".json"))

			if err != nil {
				errCh <- fmt.Errorf("error reading result file: %v", err)
				return
			}

			var result PlanFileResult
			err = json.Unmarshal(bytes, &result)

			if err != nil {
				errCh <- fmt.Errorf("error unmarshalling result file: %v", err)
				return
			}

			// log.Printf("Checking pending result: %s", resultId)

			if result.ToApi().IsPending() && paths[result.Path] {
				log.Printf("Deleting pending result: %s", resultId)

				err = os.Remove(filepath.Join(resultsDir, resultId+".json"))

				if err != nil {
					errCh <- fmt.Errorf("error deleting result file: %v", err)
					return
				}
			}

			errCh <- nil
		}(resultId)
	}

	for i := 0; i < len(files); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error deleting pending results: %v", err)
		}
	}

	return nil
}

func RejectPlanFiles(orgId, planId string, files []string, now time.Time) error {
	errCh := make(chan error, len(files))

	for _, file := range files {
		go func(file string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in RejectPlanFiles: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in RejectPlanFiles: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			err := RejectPlanFile(orgId, planId, file, now)

			if err != nil {
				errCh <- err
				return
			}

			errCh <- nil
		}(file)
	}

	for i := 0; i < len(files); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error rejecting plan files: %v", err)
		}
	}

	return nil
}

func RejectPlanFile(orgId, planId, filePathOrResultId string, now time.Time) error {
	resultsDir := getPlanResultsDir(orgId, planId)
	results, err := GetPlanFileResults(orgId, planId)

	if err != nil {
		return fmt.Errorf("error getting plan file results: %v", err)
	}

	errCh := make(chan error, len(results))

	for _, result := range results {
		go func(result *PlanFileResult) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in RejectPlanFile: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in RejectPlanFile: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			if (result.Path == filePathOrResultId || result.Id == filePathOrResultId) && result.AppliedAt == nil && result.RejectedAt == nil {
				result.RejectedAt = &now
			} else {
				errCh <- nil
				return
			}

			bytes, err := json.MarshalIndent(result, "", "  ")

			if err != nil {
				errCh <- fmt.Errorf("error marshalling result: %v", err)
			}

			err = os.WriteFile(filepath.Join(resultsDir, result.Id+".json"), bytes, 0644)

			if err != nil {
				errCh <- fmt.Errorf("error writing result file: %v", err)
			}

			errCh <- nil
		}(result)
	}

	for i := 0; i < len(results); i++ {
		err := <-errCh
		if err != nil {
			return fmt.Errorf("error rejecting plan: %v", err)
		}
	}

	return nil
}

func RejectReplacement(orgId, planId, resultId, replacementId string) error {
	resultsDir := getPlanResultsDir(orgId, planId)

	bytes, err := os.ReadFile(filepath.Join(resultsDir, resultId+".json"))

	if err != nil {
		return fmt.Errorf("error reading result file: %v", err)
	}

	var result PlanFileResult
	err = json.Unmarshal(bytes, &result)

	if err != nil {
		return fmt.Errorf("error unmarshalling result file: %v", err)
	}

	if result.RejectedAt != nil {
		return nil
	}

	now := time.Now()

	foundReplacement := false
	for _, replacement := range result.Replacements {
		if replacement.Id == replacementId {
			replacement.RejectedAt = &now
			foundReplacement = true
			break
		}
	}

	if !foundReplacement {
		return fmt.Errorf("replacement not found: %s", replacementId)
	}

	return nil
}

func GetPlanApplies(orgId, planId string) ([]*PlanApply, error) {
	appliesDir := getPlanAppliesDir(orgId, planId)
	files, err := os.ReadDir(appliesDir)

	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}

		return nil, fmt.Errorf("error reading applies dir: %v", err)
	}

	planApplies := []*PlanApply{}
	var mu sync.Mutex

	errCh := make(chan error, len(files))

	for _, file := range files {
		go func(file os.DirEntry) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in GetPlanApplies: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in GetPlanApplies: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			bytes, err := os.ReadFile(filepath.Join(appliesDir, file.Name()))

			if err != nil {
				errCh <- fmt.Errorf("error reading apply file: %v", err)
				return
			}

			var apply PlanApply
			err = json.Unmarshal(bytes, &apply)

			if err != nil {
				errCh <- fmt.Errorf("error unmarshalling apply file: %v", err)
				return
			}

			mu.Lock()
			planApplies = append(planApplies, &apply)
			mu.Unlock()

			errCh <- nil
		}(file)
	}

	for i := 0; i < len(files); i++ {
		err := <-errCh
		if err != nil {
			return nil, fmt.Errorf("error getting plan applies: %v", err)
		}
	}

	return planApplies, nil
}


================================================
FILE: app/server/db/settings_helpers.go
================================================
package db

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"time"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
)

func GetPlanSettings(plan *Plan) (settings *shared.PlanSettings, err error) {
	planDir := getPlanDir(plan.OrgId, plan.Id)
	settingsPath := filepath.Join(planDir, "settings.json")

	result, err := GetApiCustomModels(plan.OrgId)
	if err != nil {
		return nil, fmt.Errorf("error getting custom models: %v", err)
	}

	defer func() {
		if settings != nil {
			settings.Configure(result.CustomModelPacks, result.CustomModels, result.CustomProviders, os.Getenv("PLANDEX_CLOUD") != "")
		}
	}()

	bytes, err := os.ReadFile(settingsPath)

	if os.IsNotExist(err) || len(bytes) == 0 {
		log.Printf("GetPlanSettings - no settings file found for plan %s - checking org defaults", plan.Id)
		// see if org has default settings
		defaultSettings, err := GetOrgDefaultSettings(plan.OrgId)

		if err != nil {
			return nil, fmt.Errorf("error getting org default settings: %v", err)
		}

		if defaultSettings != nil {
			log.Printf("GetPlanSettings - found org default settings for plan %s", plan.Id)
			return defaultSettings, nil
		} else {
			log.Printf("GetPlanSettings - no org default settings found for plan %s", plan.Id)
		}

		log.Println("GetPlanSettings - no default settings found, returning default settings object")
		// if it doesn't exist, return default settings object
		settings = &shared.PlanSettings{
			UpdatedAt:     plan.CreatedAt,
			ModelPackName: shared.DefaultModelPack.Name,
		}
		return settings, nil
	} else if err != nil {
		return nil, fmt.Errorf("error reading settings file: %v", err)
	}

	log.Printf("GetPlanSettings - settings found in file")

	err = json.Unmarshal(bytes, &settings)

	if err != nil {
		return nil, fmt.Errorf("error unmarshalling settings: %v", err)
	}

	return settings, nil
}

func StorePlanSettings(plan *Plan, settings shared.PlanSettings) error {
	planDir := getPlanDir(plan.OrgId, plan.Id)
	settingsPath := filepath.Join(planDir, "settings.json")

	settings.UpdatedAt = time.Now()
	settings.CustomModelPacks = nil
	settings.CustomModels = nil
	settings.CustomModelsById = nil
	settings.CustomProviders = nil
	settings.UsesCustomProviderByModelId = nil
	settings.IsCloud = false
	settings.Configured = false

	bytes, err := json.Marshal(settings)

	if err != nil {
		return fmt.Errorf("error marshalling settings: %v", err)
	}

	err = os.WriteFile(settingsPath, bytes, 0644)

	if err != nil {
		return fmt.Errorf("error writing settings file: %v", err)
	}

	err = BumpPlanUpdatedAt(plan.Id, settings.UpdatedAt)

	if err != nil {
		return fmt.Errorf("error bumping plan updated at: %v", err)
	}

	return nil
}

func GetOrgDefaultSettings(orgId string) (settings *shared.PlanSettings, err error) {
	result, err := GetApiCustomModels(orgId)
	if err != nil {
		return nil, fmt.Errorf("error getting custom models: %v", err)
	}

	defer func() {
		if settings != nil {
			settings.Configure(result.CustomModelPacks, result.CustomModels, result.CustomProviders, os.Getenv("PLANDEX_CLOUD") != "")
		}
	}()

	query := "SELECT * FROM default_plan_settings WHERE org_id = $1"

	var defaults DefaultPlanSettings

	err = Conn.Get(&defaults, query, orgId)

	if err != nil {
		if err == sql.ErrNoRows {
			log.Println("GetOrgDefaultSettings - no rows - returning default settings")
			// if it doesn't exist, return default settings object
			settings := &shared.PlanSettings{
				UpdatedAt:     time.Time{},
				ModelPackName: shared.DefaultModelPack.Name,
			}
			return settings, nil
		}
		return nil, fmt.Errorf("error getting default plan settings: %v", err)
	}

	return &defaults.PlanSettings, nil
}

func GetOrgDefaultSettingsForUpdate(orgId string, tx *sqlx.Tx) (settings *shared.PlanSettings, err error) {
	result, err := GetApiCustomModels(orgId)
	if err != nil {
		return nil, fmt.Errorf("error getting custom models: %v", err)
	}

	defer func() {
		if settings != nil {
			settings.Configure(result.CustomModelPacks, result.CustomModels, result.CustomProviders, os.Getenv("PLANDEX_CLOUD") != "")
		}
	}()

	query := "SELECT * FROM default_plan_settings WHERE org_id = $1 FOR UPDATE"

	var defaults DefaultPlanSettings

	err = tx.Get(&defaults, query, orgId)

	if err != nil {
		if err == sql.ErrNoRows {
			// if it doesn't exist, return default settings object
			settings := &shared.PlanSettings{
				UpdatedAt:     time.Time{},
				ModelPackName: shared.DefaultModelPack.Name,
			}
			return settings, nil
		}
		return nil, fmt.Errorf("error getting default plan settings: %v", err)
	}

	return &defaults.PlanSettings, nil
}

func StoreOrgDefaultSettings(orgId string, settings *shared.PlanSettings, tx *sqlx.Tx) error {
	settings.UpdatedAt = time.Now()

	query := `INSERT INTO default_plan_settings (org_id, plan_settings) 
	VALUES ($1, $2) 
	ON CONFLICT (org_id) DO UPDATE SET plan_settings = excluded.plan_settings
	`

	_, err := tx.Exec(query, orgId, settings)

	if err != nil {
		return fmt.Errorf("error storing default plan settings: %v", err)
	}

	return nil
}

type GetCustomModelsResult struct {
	CustomModels     []*shared.CustomModel
	CustomProviders  []*shared.CustomProvider
	CustomModelPacks []*shared.ModelPack
}

func GetApiCustomModels(orgId string) (result *GetCustomModelsResult, err error) {
	var customModels []*CustomModel
	var customProviders []*CustomProvider
	var customModelPacks []*ModelPack

	errCh := make(chan error, 3)

	go func() {
		res, err := ListModelPacks(orgId)
		if err != nil {
			errCh <- fmt.Errorf("error getting custom model packs: %v", err)
		}
		customModelPacks = res
		errCh <- nil
	}()

	go func() {
		res, err := ListCustomModels(orgId)
		if err != nil {
			errCh <- fmt.Errorf("error getting custom models: %v", err)
		}
		customModels = res
		errCh <- nil
	}()

	go func() {
		res, err := ListCustomProviders(orgId)
		if err != nil {
			errCh <- fmt.Errorf("error getting custom providers: %v", err)
		}
		customProviders = res
		errCh <- nil
	}()

	for i := 0; i < 3; i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	apiModelPacks := make([]*shared.ModelPack, len(customModelPacks))
	for i, modelPack := range customModelPacks {
		apiModelPacks[i] = modelPack.ToApi()
	}

	apiCustomModels := make([]*shared.CustomModel, len(customModels))
	for i, model := range customModels {
		apiCustomModels[i] = model.ToApi()
	}

	apiCustomProviders := make([]*shared.CustomProvider, len(customProviders))
	for i, provider := range customProviders {
		apiCustomProviders[i] = provider.ToApi()
	}

	result = &GetCustomModelsResult{
		CustomModels:     apiCustomModels,
		CustomProviders:  apiCustomProviders,
		CustomModelPacks: apiModelPacks,
	}

	return result, nil
}


================================================
FILE: app/server/db/stream_helpers.go
================================================
package db

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"plandex-server/notify"
	"runtime/debug"
	"time"

	shared "plandex-shared"

	"github.com/lib/pq"
)

const modelStreamHeartbeatInterval = 1 * time.Second
const modelStreamHeartbeatTimeout = 5 * time.Second

func StoreModelStream(stream *ModelStream, ctx context.Context, cancelFn context.CancelFunc) error {
	query := `INSERT INTO model_streams (org_id, plan_id, internal_ip, branch) VALUES (:org_id, :plan_id, :internal_ip, :branch) RETURNING id, created_at`

	row, err := Conn.NamedQuery(query, stream)

	if err != nil {
		return fmt.Errorf("error storing model stream: %v", err)
	}

	defer row.Close()

	if row.Next() {
		var createdAt time.Time
		var id string
		if err := row.Scan(&id, &createdAt); err != nil {
			return fmt.Errorf("error storing model stream: %v", err)
		}

		stream.Id = id
		stream.CreatedAt = createdAt
	}

	// Start a goroutine to keep the lock alive
	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in StoreModelStream: %v\n%s", r, debug.Stack())
				cancelFn()
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in StoreModelStream: %v\n%s", r, debug.Stack()))
			}
		}()

		numErrors := 0
		for {
			select {
			case <-ctx.Done():
				err := SetModelStreamFinished(stream.Id)
				if err != nil {
					log.Printf("Error setting model stream %s finished: %v\n", stream.Id, err)
				}
				return

			default:
				_, err := Conn.Exec("UPDATE model_streams SET last_heartbeat_at = NOW() WHERE id = $1", stream.Id)

				if err != nil {
					log.Printf("Error updating model stream last heartbeat: %v\n", err)
					numErrors++

					if numErrors > 5 {
						log.Printf("Too many errors updating model stream last heartbeat: %v\n", err)
						cancelFn()
						return
					}
				}

				time.Sleep(modelStreamHeartbeatInterval)
			}

		}
	}()

	return nil
}

func SetModelStreamFinished(id string) error {
	log.Println("Setting model stream finished:", id)

	_, err := Conn.Exec("UPDATE model_streams SET finished_at = NOW() WHERE id = $1", id)

	if err != nil {
		return fmt.Errorf("error setting model stream finished: %v", err)
	}

	log.Println("Set model stream finished successfully:", id)

	return nil
}

func GetActiveModelStream(planId, branch string) (*ModelStream, error) {
	var stream ModelStream
	err := Conn.Get(&stream, "SELECT * FROM model_streams WHERE plan_id = $1 AND branch = $2 AND finished_at IS NULL", planId, branch)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting active model stream: %v", err)
	}

	if time.Now().Add(-modelStreamHeartbeatTimeout).After(stream.LastHeartbeatAt) {
		log.Printf("Model stream %s has not sent a heartbeat in %s\n", stream.Id, modelStreamHeartbeatTimeout)

		err := SetModelStreamFinished(stream.Id)

		if err != nil {
			return nil, fmt.Errorf("error setting model stream finished: %v", err)
		}

		err = SetPlanStatus(planId, branch, shared.PlanStatusError, "Model stream has not sent a heartbeat in 5 seconds")

		if err != nil {
			return nil, fmt.Errorf("error setting plan status to error: %v", err)
		}

		return nil, nil
	} else {
		log.Printf("Model stream %s sent heartbeat %d seconds ago\n", stream.Id, int(time.Since(stream.LastHeartbeatAt).Seconds()))
	}

	return &stream, nil
}

func GetActiveOrRecentModelStreams(planIds []string) ([]*ModelStream, error) {
	var streams []*ModelStream
	err := Conn.Select(&streams, "SELECT * FROM model_streams WHERE plan_id = ANY($1) AND (finished_at IS NULL OR finished_at > NOW() - INTERVAL '1 hour') ORDER BY created_at", pq.Array(planIds))

	if err != nil {
		return nil, fmt.Errorf("error getting active or recent model streams: %v", err)
	}

	return streams, nil
}

func GetActiveModelStreams(planIds []string) ([]*ModelStream, error) {
	var streams []*ModelStream
	err := Conn.Select(&streams, "SELECT * FROM model_streams WHERE plan_id = ANY($1) AND finished_at IS NULL ORDER BY created_at", pq.Array(planIds))

	if err != nil {
		return nil, fmt.Errorf("error getting active  model streams: %v", err)
	}

	return streams, nil
}

// func StoreModelStreamSubscription(subscription *ModelStreamSubscription) error {
// 	query := `INSERT INTO model_stream_subscriptions (model_stream_id, org_id, plan_id, user_id, user_ip) VALUES (:model_stream_id, :org_id, :plan_id, :user_id, :user_ip) RETURNING id, created_at`

// 	row, err := Conn.NamedQuery(query, subscription)

// 	if err != nil {
// 		return fmt.Errorf("error storing model stream subscription: %v", err)
// 	}

// 	defer row.Close()

// 	if row.Next() {
// 		var createdAt time.Time
// 		var id string
// 		if err := row.Scan(&id, &createdAt); err != nil {
// 			return fmt.Errorf("error storing model stream subscription: %v", err)
// 		}

// 		subscription.Id = id
// 		subscription.CreatedAt = createdAt
// 	}

// 	return nil
// }

// func SetModelStreamSubscriptionFinished(id string) error {
// 	_, err := Conn.Exec("UPDATE model_stream_subscriptions SET finished_at = NOW() WHERE id = $1", id)

// 	if err != nil {
// 		return fmt.Errorf("error setting model stream subscription finished: %v", err)
// 	}

// 	return nil
// }


================================================
FILE: app/server/db/subtask_helpers.go
================================================
package db

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
)

func GetPlanSubtasks(orgId, planId string) ([]*Subtask, error) {
	planDir := getPlanDir(orgId, planId)
	subtasksPath := filepath.Join(planDir, "subtasks.json")

	bytes, err := os.ReadFile(subtasksPath)

	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}

		return nil, fmt.Errorf("error reading subtasks: %v", err)
	}

	var subtasks []*Subtask
	err = json.Unmarshal(bytes, &subtasks)

	if err != nil {
		return nil, fmt.Errorf("error unmarshalling subtasks: %v", err)
	}

	return subtasks, nil
}

func StorePlanSubtasks(orgId, planId string, subtasks []*Subtask) error {
	planDir := getPlanDir(orgId, planId)

	bytes, err := json.Marshal(subtasks)

	if err != nil {
		return fmt.Errorf("error marshalling subtasks: %v", err)
	}

	err = os.WriteFile(filepath.Join(planDir, "subtasks.json"), bytes, os.ModePerm)

	if err != nil {
		return fmt.Errorf("error writing subtasks: %v", err)
	}

	return nil
}


================================================
FILE: app/server/db/summary_helpers.go
================================================
package db

import (
	"fmt"
	"time"

	"github.com/lib/pq"
)

func GetPlanSummaries(planId string, convoMessageIds []string) ([]*ConvoSummary, error) {
	var summaries []*ConvoSummary

	err := Conn.Select(&summaries, "SELECT * FROM convo_summaries WHERE plan_id = $1 AND latest_convo_message_id = ANY($2) ORDER BY created_at", planId, pq.Array(convoMessageIds))

	if err != nil {
		return nil, fmt.Errorf("error getting plan summaries: %v", err)
	}
	return summaries, nil
}

func StoreSummary(summary *ConvoSummary) error {
	query := "INSERT INTO convo_summaries (org_id, plan_id, latest_convo_message_id, latest_convo_message_created_at, summary, tokens, num_messages) VALUES (:org_id, :plan_id, :latest_convo_message_id, :latest_convo_message_created_at, :summary, :tokens, :num_messages) RETURNING id, created_at"

	row, err := Conn.NamedQuery(query, summary)

	if err != nil {
		return fmt.Errorf("error storing summary: %v", err)
	}

	defer row.Close()

	if row.Next() {
		var createdAt time.Time
		var id string
		if err := row.Scan(&id, &createdAt); err != nil {
			return fmt.Errorf("error storing summary: %v", err)
		}

		summary.Id = id
		summary.CreatedAt = createdAt
	}

	return nil
}


================================================
FILE: app/server/db/transactions.go
================================================
package db

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"runtime/debug"

	"github.com/jmoiron/sqlx"
)

func WithTx(ctx context.Context, reason string, fn func(tx *sqlx.Tx) error) error {
	return withTx(ctx, nil, reason, fn)
}

func WithTxOpts(ctx context.Context, opts *sql.TxOptions, reason string, fn func(tx *sqlx.Tx) error) error {
	return withTx(ctx, opts, reason, fn)
}

func withTx(ctx context.Context, opts *sql.TxOptions, reason string, fn func(tx *sqlx.Tx) error) error {
	log.Printf("starting transaction: (%s)", reason)

	tx, err := Conn.BeginTxx(ctx, opts)
	if err != nil {
		return fmt.Errorf("error starting transaction: %v", err)
	}

	var committed bool

	// Ensure that rollback is attempted in case of failure
	defer func() {
		panicErr := recover()
		if panicErr != nil {
			log.Printf("panic in WithTx (%s): %v\n%s", reason, panicErr, debug.Stack())
			log.Printf("stack trace (panic - %s):\n%s", reason, debug.Stack())
		}

		if committed {
			return
		}

		if rbErr := tx.Rollback(); rbErr != nil {
			if rbErr == sql.ErrTxDone {
				log.Printf("attempted to roll back transaction, but it was already committed: (%s)", reason)
			} else {
				log.Printf("transaction rollback error: (%s) %v\n", reason, rbErr)
			}
		} else {
			log.Printf("transaction rolled back: (%s)", reason)
		}
	}()

	err = fn(tx)

	if err != nil {
		log.Printf("error in WithTx (%s): %v", reason, err)
		return err
	}

	err = tx.Commit()
	if err != nil {
		log.Printf("error committing transaction: (%s) %v", reason, err)
		return fmt.Errorf("error committing transaction: %v", err)
	}

	committed = true

	log.Printf("committed transaction: (%s)", reason)

	return nil
}


================================================
FILE: app/server/db/user_helpers.go
================================================
package db

import (
	"database/sql"
	"fmt"
	shared "plandex-shared"
	"strings"

	"github.com/jmoiron/sqlx"
	"github.com/lib/pq"
)

func GetUser(userId string) (*User, error) {
	var user User
	err := Conn.Get(&user, "SELECT * FROM users WHERE id = $1", userId)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting user: %v", err)
	}

	return &user, nil
}

func GetUserByEmail(email string) (*User, error) {
	var user User
	err := Conn.Get(&user, "SELECT * FROM users WHERE email = $1", email)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting user: %v", err)
	}

	return &user, nil
}

func GetUsersForDomain(domain string) ([]*User, error) {
	var users []*User
	err := Conn.Select(&users, "SELECT * FROM users WHERE domain = $1", domain)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting users for domain: %v", err)
	}

	return users, nil
}

func GetOrgUser(userId, orgId string) (*OrgUser, error) {
	var orgUser OrgUser
	err := Conn.Get(&orgUser, "SELECT * FROM orgs_users WHERE user_id = $1 AND org_id = $2", userId, orgId)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting org user: %v", err)
	}

	return &orgUser, nil
}

func GetOrgUserConfig(userId, orgId string) (*shared.OrgUserConfig, error) {
	var orgUserConfig shared.OrgUserConfig
	err := Conn.Get(&orgUserConfig, "SELECT config FROM orgs_users WHERE user_id = $1 AND org_id = $2", userId, orgId)

	if err != nil {
		if err == sql.ErrNoRows {
			return nil, nil
		}

		return nil, fmt.Errorf("error getting org user config: %v", err)
	}

	return &orgUserConfig, nil
}

func UpdateOrgUserConfig(userId, orgId string, config *shared.OrgUserConfig) error {
	_, err := Conn.Exec("UPDATE orgs_users SET config = $1 WHERE user_id = $2 AND org_id = $3", config, userId, orgId)

	if err != nil {
		return fmt.Errorf("error updating org user config: %v", err)
	}

	return nil
}

func ListOrgUsers(orgId string) ([]*OrgUser, error) {
	var orgUsers []*OrgUser
	err := Conn.Select(&orgUsers, "SELECT * FROM orgs_users WHERE org_id = $1", orgId)

	if err != nil {
		return nil, fmt.Errorf("error listing org users: %v", err)
	}

	return orgUsers, nil
}

func ListUsers(orgId string) ([]*User, error) {
	var users []*User

	orgUsers, err := ListOrgUsers(orgId)

	if err != nil {
		return nil, fmt.Errorf("error listing users: %v", err)
	}

	userIds := make([]string, len(orgUsers))
	for i, ou := range orgUsers {
		userIds[i] = ou.UserId
	}

	err = Conn.Select(&users, "SELECT * FROM users WHERE id = ANY($1)", pq.Array(userIds))

	if err != nil {
		return nil, fmt.Errorf("error listing users: %v", err)
	}

	return users, nil
}

func CreateUser(name, email string, tx *sqlx.Tx) (*User, error) {
	emailSplit := strings.Split(email, "@")
	if len(emailSplit) != 2 {
		return nil, fmt.Errorf("invalid email: %v", email)
	}
	domain := emailSplit[1]

	user := User{
		Name:   name,
		Email:  email,
		Domain: domain,
	}

	err := tx.QueryRow("INSERT INTO users (name, email, domain) VALUES ($1, $2, $3) RETURNING id", user.Name, user.Email, user.Domain).Scan(&user.Id)

	if err != nil {
		if IsNonUniqueErr(err) {
			return nil, fmt.Errorf("user already exists for email: %v", email)
		}
		return nil, fmt.Errorf("error creating user: %v", err)
	}

	return &user, nil
}

func NumUsersWithRole(orgId, roleId string) (int, error) {
	var count int
	err := Conn.Get(&count, "SELECT COUNT(*) FROM orgs_users WHERE org_id = $1 AND org_role_id = $2", orgId, roleId)

	if err != nil {
		return 0, fmt.Errorf("error counting users with role: %v", err)
	}

	return count, nil
}


================================================
FILE: app/server/db/utils.go
================================================
package db

import (
	"github.com/lib/pq"
)

func IsNonUniqueErr(err error) bool {
	if err, ok := err.(*pq.Error); ok {
		if err.Code == "23505" {
			return true
		}
	}
	return false
}


================================================
FILE: app/server/diff/diff.go
================================================
package diff

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/google/uuid"
)

func GetDiffs(original, updated string) (string, error) {
	// create temp directory
	tempDirPath, err := os.MkdirTemp("", "tmp-diffs-*")

	if err != nil {
		return "", fmt.Errorf("error creating temp dir: %v", err)
	}

	defer func() {
		go os.RemoveAll(tempDirPath)
	}()

	// write the original file to the temp dir
	err = os.WriteFile(filepath.Join(tempDirPath, "original"), []byte(original), 0644)
	if err != nil {
		return "", fmt.Errorf("error writing original file: %v", err)
	}

	// write the updated file to the temp dir
	err = os.WriteFile(filepath.Join(tempDirPath, "updated"), []byte(updated), 0644)
	if err != nil {
		return "", fmt.Errorf("error writing updated file: %v", err)
	}

	cmd := exec.Command("git", "-C", tempDirPath, "diff", "--no-color", "--no-index", "original", "updated")

	res, err := cmd.CombinedOutput()

	if err != nil {
		exitError, ok := err.(*exec.ExitError)
		if ok && exitError.ExitCode() == 1 {
			// Exit status 1 means diffs were found, which is expected
		} else {
			log.Printf("Error getting diffs: %v\n", err)
			log.Printf("Diff output: %s\n", res)
			return "", fmt.Errorf("error getting diffs: %v", err)
		}
	}

	return string(res), nil
}

type change struct {
	Old    string
	New    string
	Line   int
	Length int
}

func GetDiffReplacements(original, updated string) ([]*shared.Replacement, error) {
	diff, err := GetDiffs(original, updated)
	if err != nil {
		return nil, fmt.Errorf("error getting git diffs: %v", err)
	}

	var changes []*change
	scanner := bufio.NewScanner(strings.NewReader(diff))

	var currentHunk *change
	var oldLines, newLines []string

	for scanner.Scan() {
		line := scanner.Text()

		// Parse hunk header
		if strings.HasPrefix(line, "@@") {
			// If we have a previous hunk, process it
			if currentHunk != nil {
				change := processHunk(oldLines, newLines, currentHunk.Line)
				if change != nil {
					changes = append(changes, change)
				}
			}

			// Parse the new hunk header
			lineInfo := strings.Split(line, " ")[1:] // Skip @@ part
			oldInfo := strings.Split(lineInfo[0], ",")
			startLine, _ := strconv.Atoi(strings.TrimPrefix(oldInfo[0], "-"))

			currentHunk = &change{
				Line: startLine,
			}
			oldLines = []string{}
			newLines = []string{}
			continue
		}

		if currentHunk == nil {
			continue // Skip until we find a hunk
		}

		// Process the lines within a hunk
		switch {
		case strings.HasPrefix(line, "-"):
			oldLines = append(oldLines, strings.TrimPrefix(line, "-"))
		case strings.HasPrefix(line, "+"):
			newLines = append(newLines, strings.TrimPrefix(line, "+"))
		case strings.HasPrefix(line, " "):
			// Context lines - add to both
			line = strings.TrimPrefix(line, " ")
			oldLines = append(oldLines, line)
			newLines = append(newLines, line)
		}
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error scanning diff: %v", err)
	}

	// Process the last hunk if exists
	if currentHunk != nil {
		change := processHunk(oldLines, newLines, currentHunk.Line)
		if change != nil {
			changes = append(changes, change)
		}
	}

	replacements := make([]*shared.Replacement, len(changes))
	for i, change := range changes {
		replacements[i] = &shared.Replacement{
			Id:  uuid.New().String(),
			Old: change.Old,
			New: change.New,
		}
	}

	return replacements, nil
}

func processHunk(oldLines, newLines []string, startLine int) *change {
	if len(oldLines) == 0 && len(newLines) == 0 {
		return nil
	}

	return &change{
		Old:    strings.Join(oldLines, "\n"),
		New:    strings.Join(newLines, "\n"),
		Line:   startLine,
		Length: len(oldLines),
	}
}


================================================
FILE: app/server/email/email.go
================================================
package email

import (
	"fmt"
	"net/smtp"
	"os"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ses"
)

// SendEmailViaSES sends an email using AWS SES
func SendEmailViaSES(recipient, subject, htmlBody, textBody string) error {
	sess, err := session.NewSession()
	if err != nil {
		return fmt.Errorf("error creating AWS session: %v", err)
	}

	// Create an SES session.
	svc := ses.New(sess)

	// Assemble the email.
	input := &ses.SendEmailInput{
		Destination: &ses.Destination{
			ToAddresses: []*string{
				aws.String(recipient),
			},
		},
		Message: &ses.Message{
			Body: &ses.Body{
				Html: &ses.Content{
					Charset: aws.String("UTF-8"),
					Data:    aws.String(htmlBody),
				},
				Text: &ses.Content{
					Charset: aws.String("UTF-8"),
					Data:    aws.String(textBody),
				},
			},
			Subject: &ses.Content{
				Charset: aws.String("UTF-8"),
				Data:    aws.String(subject),
			},
		},
		Source: aws.String("Plandex <support@plandex.ai>"),
	}

	// Attempt to send the email.
	_, err = svc.SendEmail(input)

	return err
}

func sendEmailViaSMTP(recipient, subject, htmlBody, textBody string) error {
	smtpHost := os.Getenv("SMTP_HOST")
	smtpPort := os.Getenv("SMTP_PORT")
	smtpUser := os.Getenv("SMTP_USER")
	smtpPassword := os.Getenv("SMTP_PASSWORD")
	smtpFrom := os.Getenv("SMTP_FROM")

	if smtpHost == "" || smtpPort == "" || smtpUser == "" || smtpPassword == "" {
		return fmt.Errorf("SMTP settings not found in environment variables")
	}

	if smtpFrom == "" {
		smtpFrom = smtpUser
	}

	smtpAddress := fmt.Sprintf("%s:%s", smtpHost, smtpPort)

	auth := smtp.PlainAuth("", smtpUser, smtpPassword, smtpHost)

	// Generate a MIME boundary
	boundary := "BOUNDARY1234567890"
	header := fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: %s\r\nMIME-Version: 1.0\r\nContent-Type: multipart/alternative; boundary=\"%s\"\r\n\r\n", smtpFrom, recipient, subject, boundary)

	// Prepare the text body part
	textPart := fmt.Sprintf("--%s\r\nContent-Type: text/plain; charset=\"UTF-8\"\r\n\r\n%s\r\n", boundary, textBody)

	// Prepare the HTML body part
	htmlPart := fmt.Sprintf("--%s\r\nContent-Type: text/html; charset=\"UTF-8\"\r\n\r\n%s\r\n", boundary, htmlBody)

	// End marker for the boundary
	endBoundary := fmt.Sprintf("--%s--", boundary)

	// Combine the parts to form the full email message
	message := []byte(header + textPart + htmlPart + endBoundary)

	err := smtp.SendMail(smtpAddress, auth, smtpFrom, []string{recipient}, message)
	if err != nil {
		return fmt.Errorf("error sending email via SMTP: %v", err)
	}

	return nil
}


================================================
FILE: app/server/email/invite.go
================================================
package email

import (
	"fmt"
	"os"

	"github.com/gen2brain/beeep"
)

func SendInviteEmail(email, inviteeFirstName, inviterName, orgName string) error {
	// Check if the environment is production
	if os.Getenv("GOENV") == "production" {
		// Production environment - send email using AWS SES
		subject := fmt.Sprintf("%s, you've been invited to join %s on Plandex", inviteeFirstName, orgName)

		htmlBody := fmt.Sprintf(`<p>Hi %s,</p><p>%s has invited you to join the org <strong>%s</strong> on <a href="https://plandex.ai">Plandex.</a></p><p>Plandex is a terminal-based AI programming engine for complex tasks.</p><p>To accept the invite, first <a href="https://docs.plandex.ai/install/">install Plandex</a>, then open a terminal and run 'plandex sign-in'. Enter '%s' when asked for your email and follow the prompts from there.</p><p>If you have questions, feedback, or run into a problem, you can reply directly to this email, <a href="https://github.com/plandex-ai/plandex/discussions">start a discussion</a>, or <a href="https://github.com/plandex-ai/plandex/issues">open an issue.</a></p>`, inviteeFirstName, inviterName, orgName, email)

		textBody := fmt.Sprintf(`Hi %s,\n\n%s has invited you to join the org %s on Plandex.\n\nPlandex is a terminal-based AI programming engine for complex tasks.\n\nTo accept the invite, first install Plandex (https://docs.plandex.ai/install/), then open a terminal and run 'plandex sign-in'. Enter '%s' when asked for your email and follow the prompts from there.\n\nIf you have questions, feedback, or run into a problem, you can reply directly to this email, start a discussion (https://github.com/plandex-ai/plandex/discussions), or open an issue (https://github.com/plandex-ai/plandex/issues).`, inviteeFirstName, inviterName, orgName, email)

		if os.Getenv("IS_CLOUD") == "" {
			return sendEmailViaSMTP(email, subject, htmlBody, textBody)
		} else {
			return SendEmailViaSES(email, subject, htmlBody, textBody)
		}
	} else {
		// Send notification
		err := beeep.Notify("Invite Sent", fmt.Sprintf("Invite sent to %s (email not sent in development)", email), "")
		if err != nil {
			return fmt.Errorf("error sending notification in dev: %v", err)
		}
	}

	return nil
}


================================================
FILE: app/server/email/verification.go
================================================
package email

import (
	"fmt"
	"log"
	"os"

	"github.com/atotto/clipboard"
	"github.com/gen2brain/beeep"
)

func SendVerificationEmail(email string, pin string) error {
	// Check if the environment is production
	if os.Getenv("GOENV") == "production" {
		// Production environment - send email using AWS SES
		subject := "Your Plandex Pin"
		htmlBody := fmt.Sprintf(`<p>Hi there,</p>
<p>Welcome to Plandex! Your pin is:<br><br>
<strong style="font-size: 18px;">%s</strong></p>
<p>It will be valid for the next 5 minutes.</p>
<p style="color: #666; font-size: 12px; margin-top: 20px;">If you didn't request this, you can safely ignore the email.</p>`, pin)
		textBody := fmt.Sprintf("Hi there,\n\nWelcome to Plandex! Your pin is:\n\n%s\n\nIt will be valid for the next 5 minutes.\n\nIf you didn't request this, you can safely ignore the email.", pin)

		if os.Getenv("IS_CLOUD") == "" {
			return sendEmailViaSMTP(email, subject, htmlBody, textBody)
		} else {
			return SendEmailViaSES(email, subject, htmlBody, textBody)
		}
	}

	if os.Getenv("GOENV") == "development" {
		// Development environment
		log.Printf("Development mode: Verification pin is %s for email %s", pin, email)

		// Copy pin to clipboard
		clipboard.WriteAll(pin) // ignore error

		// Send notification
		beeep.Notify("Verification Pin", fmt.Sprintf("Verification pin %s copied to clipboard %s", pin, email), "") // ignore error
	}

	return nil
}


================================================
FILE: app/server/go.mod
================================================
module plandex-server

go 1.23.3

require (
	github.com/davecgh/go-spew v1.1.1
	github.com/google/uuid v1.6.0
	github.com/gorilla/mux v1.8.1
	github.com/pkg/errors v0.9.1
	github.com/sashabaranov/go-openai v1.40.0
	plandex-shared v0.0.0-00010101000000-000000000000
)

require (
	github.com/dlclark/regexp2 v1.11.5 // indirect
	github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4 // indirect
	github.com/godbus/dbus/v5 v5.1.0 // indirect
	github.com/google/go-cmp v0.7.0 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/jinzhu/copier v0.4.0 // indirect
	github.com/jmespath/go-jmespath v0.4.0 // indirect
	github.com/mattn/go-colorable v0.1.14 // indirect
	github.com/mattn/go-isatty v0.0.20 // indirect
	github.com/mattn/go-runewidth v0.0.16 // indirect
	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
	github.com/olekukonko/tablewriter v0.0.5 // indirect
	github.com/pkoukk/tiktoken-go v0.1.7 // indirect
	github.com/pmezard/go-difflib v1.0.0 // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/shopspring/decimal v1.4.0 // indirect
	github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af // indirect
	go.uber.org/atomic v1.11.0 // indirect
	golang.org/x/image v0.27.0 // indirect
	golang.org/x/sys v0.33.0 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
)

require (
	github.com/atotto/clipboard v0.1.4
	github.com/aws/aws-sdk-go v1.55.7
	github.com/fatih/color v1.18.0
	github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4
	github.com/golang-migrate/migrate/v4 v4.18.3
	github.com/jmoiron/sqlx v1.4.0
	github.com/lib/pq v1.10.9
	github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82
	github.com/stretchr/testify v1.10.0
	golang.org/x/mod v0.21.0
	golang.org/x/net v0.40.0
)

replace plandex-shared => ../shared


================================================
FILE: app/server/go.sum
================================================
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
github.com/aws/aws-sdk-go v1.55.7 h1:UJrkFq7es5CShfBwlWAC8DA077vp8PyVbQd3lqLiztE=
github.com/aws/aws-sdk-go v1.55.7/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dhui/dktest v0.4.5 h1:uUfYBIVREmj/Rw6MvgmqNAYzTiKOHJak+enB5Di73MM=
github.com/dhui/dktest v0.4.5/go.mod h1:tmcyeHDKagvlDrz7gDKq4UAJOLIfVZYkfD5OnHDwcCo=
github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/docker/docker v27.2.0+incompatible h1:Rk9nIVdfH3+Vz4cyI/uhbINhEZ/oLmc+CBXmH6fbNk4=
github.com/docker/docker v27.2.0+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4 h1:ygs9POGDQpQGLJPlq4+0LBUmMBNox1N4JSpw+OETcvI=
github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4/go.mod h1:0W7dI87PvXJ1Sjs0QPvWXKcQmNERY77e8l7GFhZB/s4=
github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4 h1:qZNfIGkIANxGv/OqtnntR4DfOY2+BgwR60cAcu/i3SE=
github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4/go.mod h1:kW3HQ4UdaAyrUCSSDR4xUzBKW6O2iA4uHhk7AtyYp10=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang-migrate/migrate/v4 v4.18.3 h1:EYGkoOsvgHHfm5U/naS1RP/6PL/Xv3S4B/swMiAmDLs=
github.com/golang-migrate/migrate/v4 v4.18.3/go.mod h1:99BKpIi6ruaaXRM1A77eqZ+FWPQ3cfRa+ZVy5bmWMaY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/sashabaranov/go-openai v1.40.0 h1:Peg9Iag5mUJtPW00aYatlsn97YML0iNULiLNe74iPrU=
github.com/sashabaranov/go-openai v1.40.0/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82 h1:6C8qej6f1bStuePVkLSFxoU22XBS165D3klxlzRg8F4=
github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82/go.mod h1:xe4pgH49k4SsmkQq5OT8abwhWmnzkhpgnXeekbx2efw=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af h1:6yITBqGTE2lEeTPG04SN9W+iWHCRyHqlVYILiSXziwk=
github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af/go.mod h1:4F09kP5F+am0jAwlQLddpoMDM+iewkxxt6nxUQ5nq5o=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 h1:TT4fX+nBOA/+LUkobKGW1ydGcn+G3vRw9+g5HwCphpk=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0/go.mod h1:L7UH0GbB0p47T4Rri3uHjbpCFYrVrwc1I25QhNPiGK8=
go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw=
go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8=
go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc=
go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8=
go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4=
go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0=
golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=


================================================
FILE: app/server/handlers/accounts.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/types"
	"strings"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
)

func CreateAccountHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateAccountHandler")

	if os.Getenv("IS_CLOUD") != "" {
		log.Println("Creating accounts is not supported in cloud mode")
		http.Error(w, "Creating accounts is not supported in cloud mode", http.StatusNotImplemented)
		return
	}

	isLocalMode := (os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1")

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.CreateAccountRequest
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}
	req.Email = strings.ToLower(req.Email)

	var emailVerificationId string

	// skipping email verification in dev/local mode
	if !isLocalMode {
		emailVerificationId, err = db.ValidateEmailVerification(req.Email, req.Pin)

		if err != nil {
			log.Printf("Error validating email verification: %v\n", err)
			http.Error(w, "Error validating email verification: "+err.Error(), http.StatusInternalServerError)
			return
		}
	}

	var apiErr *shared.ApiError
	var user *db.User
	var userId string
	var token string
	var orgId string

	err = db.WithTx(r.Context(), "create account", func(tx *sqlx.Tx) error {
		res, err := db.CreateAccount(req.UserName, req.Email, emailVerificationId, tx)

		if err != nil {
			return fmt.Errorf("error creating account: %v", err)
		}

		user = res.User
		userId = user.Id
		token = res.Token
		orgId = res.OrgId

		_, apiErr = hooks.ExecHook(hooks.CreateAccount, hooks.HookParams{
			Auth: &types.ServerAuth{
				User:  user,
				OrgId: orgId,
			},
		})

		return nil
	})

	if apiErr != nil {
		writeApiError(w, *apiErr)
		return
	}

	if err != nil {
		log.Printf("Error creating account: %v\n", err)
		http.Error(w, "Error creating account: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// get orgs
	orgs, err := db.GetAccessibleOrgsForUser(user)

	if err != nil {
		log.Printf("Error getting orgs for user: %v\n", err)
		http.Error(w, "Error getting orgs for user: "+err.Error(), http.StatusInternalServerError)
		return
	}

	apiOrgs, apiErr := toApiOrgs(orgs)

	if apiErr != nil {
		log.Printf("Error converting orgs to API orgs: %v\n", apiErr)
		writeApiError(w, *apiErr)
		return
	}

	resp := shared.SessionResponse{
		UserId:      userId,
		Token:       token,
		Email:       req.Email,
		UserName:    req.UserName,
		Orgs:        apiOrgs,
		IsLocalMode: os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1",
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created account")

	w.Write(bytes)
}


================================================
FILE: app/server/handlers/auth_helpers.go
================================================
package handlers

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/types"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
	"golang.org/x/mod/semver"
)

func Authenticate(w http.ResponseWriter, r *http.Request, requireOrg bool) *types.ServerAuth {
	return execAuthenticate(w, r, requireOrg, true)
}

func AuthenticateOptional(w http.ResponseWriter, r *http.Request, requireOrg bool) *types.ServerAuth {
	return execAuthenticate(w, r, requireOrg, false)
}

func GetAuthHeader(r *http.Request) (*shared.AuthHeader, error) {
	authHeader := r.Header.Get("Authorization")

	// check for a cookie as well for ui requests
	if authHeader == "" {
		log.Println("no auth header - checking for cookie")

		// Try to get auth token from a cookie as a fallback
		cookie, err := r.Cookie("authToken")
		if err != nil {
			if err == http.ErrNoCookie {
				log.Println("no auth cookie")
				return nil, nil
			}
			return nil, fmt.Errorf("error retrieving auth cookie: %v", err)
		}
		// Use the token from the cookie as the fallback authorization header
		authHeader = cookie.Value
		log.Println("got auth header from cookie")
	}

	if authHeader == "" {
		return nil, nil
	}

	if !strings.HasPrefix(authHeader, "Bearer ") {
		return nil, fmt.Errorf("invalid auth header")
	}

	// strip off the "Bearer " prefix
	encoded := strings.TrimPrefix(authHeader, "Bearer ")

	// decode the base64-encoded credentials
	bytes, err := base64.URLEncoding.DecodeString(encoded)

	if err != nil {
		return nil, fmt.Errorf("error decoding auth token: %v", err)
	}

	// parse the credentials
	var parsed shared.AuthHeader
	err = json.Unmarshal(bytes, &parsed)

	if err != nil {
		return nil, fmt.Errorf("error parsing auth token: %v", err)
	}

	return &parsed, nil
}

func ClearAuthCookieIfBrowser(w http.ResponseWriter, r *http.Request) error {
	acceptHeader := r.Header.Get("Accept")
	if acceptHeader == "" {
		// no accept header, not a browser request
		return nil
	}

	// Check for existing auth cookie
	_, err := r.Cookie("authToken")
	if err == http.ErrNoCookie {
		// No auth cookie, nothing to clear
		return nil
	}
	if err != nil {
		return fmt.Errorf("error retrieving auth cookie: %v", err)
	}

	var domain string
	if os.Getenv("GOENV") == "production" {
		domain = os.Getenv("APP_SUBDOMAIN") + ".plandex.ai"
	}

	// Clear the authToken cookie
	http.SetCookie(w, &http.Cookie{
		Name:     "authToken",
		Path:     "/",
		Value:    "",
		MaxAge:   -1,
		Secure:   os.Getenv("GOENV") != "development",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		Domain:   domain,
	})

	log.Println("cleared auth cookie")

	return nil
}

func ClearAccountFromCookies(w http.ResponseWriter, r *http.Request, userId string) error {
	// Get stored accounts
	storedAccounts, err := GetAccountsFromCookie(r)
	if err != nil {
		return fmt.Errorf("error getting accounts from cookie: %v", err)
	}

	// Remove the account with the given userId
	for i, account := range storedAccounts {
		if account.UserId == userId {
			storedAccounts = append(storedAccounts[:i], storedAccounts[i+1:]...)
			break
		}
	}

	// Marshal the updated accounts
	updatedAccountsBytes, err := json.Marshal(storedAccounts)
	if err != nil {
		return fmt.Errorf("error marshalling updated accounts: %v", err)
	}

	// Encode to base64
	encodedAccounts := base64.URLEncoding.EncodeToString(updatedAccountsBytes)

	// Set the updated accounts cookie
	var domain string
	if os.Getenv("GOENV") == "production" {
		domain = os.Getenv("APP_SUBDOMAIN") + ".plandex.ai"
	}
	http.SetCookie(w, &http.Cookie{
		Name:     "accounts",
		Path:     "/",
		Value:    encodedAccounts,
		Secure:   os.Getenv("GOENV") != "development",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		Domain:   domain,
	})

	return nil
}

func SetAuthCookieIfBrowser(w http.ResponseWriter, r *http.Request, user *db.User, token, orgId string) error {
	log.Println("setting auth cookie if browser")

	acceptHeader := r.Header.Get("Accept")
	if acceptHeader == "" {
		// no accept header, not a browser request
		log.Println("not a browser request")
		return nil
	}

	log.Println("is browser - setting auth cookie")

	if token == "" {
		authHeader, err := GetAuthHeader(r)
		if err != nil {
			return fmt.Errorf("error getting auth header: %v", err)
		}
		token = authHeader.Token
	}

	if token == "" {
		return fmt.Errorf("no token")
	}

	// set authToken cookie
	authHeader := shared.AuthHeader{
		Token: token,
		OrgId: orgId,
	}

	bytes, err := json.Marshal(authHeader)

	if err != nil {
		return fmt.Errorf("error marshalling auth header: %v", err)
	}

	// base64 encode
	token = base64.URLEncoding.EncodeToString(bytes)

	var domain string
	if os.Getenv("GOENV") == "production" {
		domain = os.Getenv("APP_SUBDOMAIN") + ".plandex.ai"
	}

	cookie := &http.Cookie{
		Name:     "authToken",
		Path:     "/",
		Value:    "Bearer " + token,
		Secure:   os.Getenv("GOENV") != "development",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		Domain:   domain,
		Expires:  time.Now().Add(time.Hour * 24 * 90),
	}

	log.Println("setting auth cookie", cookie)

	http.SetCookie(w, cookie)

	storedAccounts, err := GetAccountsFromCookie(r)

	if err != nil {
		return fmt.Errorf("error getting accounts from cookie: %v", err)
	}

	found := false
	for _, account := range storedAccounts {
		if account.UserId == user.Id {
			found = true

			account.Token = token
			account.Email = user.Email
			account.UserName = user.Name
			break
		}
	}

	if !found {
		storedAccounts = append(storedAccounts, &shared.ClientAccount{
			Email:    user.Email,
			UserName: user.Name,
			UserId:   user.Id,
			Token:    token,
		})
	}

	bytes, err = json.Marshal(storedAccounts)

	if err != nil {
		return fmt.Errorf("error marshalling accounts: %v", err)
	}

	// base64 encode
	accounts := base64.URLEncoding.EncodeToString(bytes)

	http.SetCookie(w, &http.Cookie{
		Name:     "accounts",
		Path:     "/",
		Value:    accounts,
		Secure:   os.Getenv("GOENV") != "development",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
		Domain:   domain,
		Expires:  time.Now().Add(time.Hour * 24 * 90),
	})

	return nil
}

func GetAccountsFromCookie(r *http.Request) ([]*shared.ClientAccount, error) {
	accountsCookie, err := r.Cookie("accounts")

	if err == http.ErrNoCookie {
		return []*shared.ClientAccount{}, nil
	} else if err != nil {
		return nil, fmt.Errorf("error getting accounts cookie: %v", err)
	}

	bytes, err := base64.URLEncoding.DecodeString(accountsCookie.Value)
	if err != nil {
		return nil, fmt.Errorf("error decoding accounts cookie: %v", err)
	}

	var accounts []*shared.ClientAccount
	err = json.Unmarshal(bytes, &accounts)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling accounts cookie: %v", err)
	}

	return accounts, nil
}

func ValidateAndSignIn(w http.ResponseWriter, r *http.Request, req shared.SignInRequest) (*shared.SessionResponse, error) {
	var user *db.User
	var emailVerificationId string
	var signInCodeId string
	var signInCodeOrgId string
	var err error

	isLocalMode := (os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1")

	if req.IsSignInCode {
		res, err := db.ValidateSignInCode(req.Pin)

		if err != nil {
			log.Printf("Error validating sign in code: %v\n", err)
			return nil, fmt.Errorf("error validating sign in code: %v", err)
		}

		user, err = db.GetUser(res.UserId)

		if err != nil {
			log.Printf("Error getting user: %v\n", err)
			return nil, fmt.Errorf("error getting user: %v", err)
		}

		if user == nil {
			log.Printf("User not found for id: %v\n", res.UserId)
			return nil, fmt.Errorf("user not found")
		}

		signInCodeId = res.Id
		signInCodeOrgId = res.OrgId
	} else {
		req.Email = strings.ToLower(req.Email)
		user, err = db.GetUserByEmail(req.Email)

		if err != nil {
			log.Printf("Error getting user: %v\n", err)
			return nil, fmt.Errorf("error getting user: %v", err)
		}

		if user == nil {
			log.Printf("User not found for email: %v\n", req.Email)
			return nil, fmt.Errorf("not found")
		}

		// only validate email in non-local mode
		if !isLocalMode {
			emailVerificationId, err = db.ValidateEmailVerification(req.Email, req.Pin)

			if err != nil {
				log.Printf("Error validating email verification: %v\n", err)
				return nil, fmt.Errorf("error validating email verification: %v", err)
			}

			log.Println("Email verification successful")
		}
	}

	var token string
	var authTokenId string

	err = db.WithTx(r.Context(), "validate and sign in", func(tx *sqlx.Tx) error {
		var err error
		// create auth token
		token, authTokenId, err = db.CreateAuthToken(user.Id, tx)

		if err != nil {
			log.Printf("Error creating auth token: %v\n", err)
			return fmt.Errorf("error creating auth token: %v", err)
		}

		if req.IsSignInCode {
			// update sign in code with auth token id
			_, err = tx.Exec("UPDATE sign_in_codes SET auth_token_id = $1 WHERE id = $2", authTokenId, signInCodeId)

			if err != nil {
				log.Printf("Error updating sign in code: %v\n", err)
				return fmt.Errorf("error updating sign in code: %v", err)
			}
		} else if !isLocalMode { // only update email verification in non-local mode
			// update email verification with user and auth token ids
			_, err = tx.Exec("UPDATE email_verifications SET user_id = $1, auth_token_id = $2 WHERE id = $3", user.Id, authTokenId, emailVerificationId)

			if err != nil {
				log.Printf("Error updating email verification: %v\n", err)
				return fmt.Errorf("error updating email verification: %v", err)
			}

			log.Println("Email verification updated")
		}

		return nil
	})

	if err != nil {
		return nil, fmt.Errorf("error validating and signing in: %v", err)
	}

	// get orgs
	orgs, err := db.GetAccessibleOrgsForUser(user)

	if err != nil {
		log.Printf("Error getting orgs for user: %v\n", err)
		return nil, fmt.Errorf("error getting orgs for user: %v", err)
	}

	if req.IsSignInCode {
		filteredOrgs := []*db.Org{}
		for _, org := range orgs {
			if org.Id == signInCodeOrgId {
				filteredOrgs = append(filteredOrgs, org)
			}
		}
		orgs = filteredOrgs
	}

	// with a single org, set the orgId in the cookie
	// otherwise, the user will be prompted to select an org
	var orgId string
	if len(orgs) == 1 {
		orgId = orgs[0].Id
	}

	log.Println("Setting auth cookie if browser")
	err = SetAuthCookieIfBrowser(w, r, user, token, orgId)
	if err != nil {
		log.Printf("Error setting auth cookie: %v\n", err)
		return nil, fmt.Errorf("error setting auth cookie: %v", err)
	}

	apiOrgs, apiErr := toApiOrgs(orgs)

	if apiErr != nil {
		log.Printf("Error converting orgs to api orgs: %v\n", apiErr)
		return nil, fmt.Errorf("error converting orgs to api orgs: %v", apiErr)
	}

	resp := shared.SessionResponse{
		UserId:      user.Id,
		Token:       token,
		Email:       user.Email,
		UserName:    user.Name,
		Orgs:        apiOrgs,
		IsLocalMode: os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1",
	}

	return &resp, nil
}

func requireMinClientVersion(w http.ResponseWriter, r *http.Request, minVersion string) bool {
	msg := fmt.Sprintf("Client version is too old for this endpoint. Please upgrade to version %s or later.", minVersion)

	version := r.Header.Get("X-Client-Version")
	if version == "" {
		http.Error(w, msg, http.StatusBadRequest)
		return false
	}

	if version == "development" {
		return true
	}

	if semver.Compare(version, minVersion) < 0 {
		http.Error(w, msg, http.StatusBadRequest)
		return false
	}

	return true
}

func execAuthenticate(w http.ResponseWriter, r *http.Request, requireOrg bool, raiseErr bool) *types.ServerAuth {
	log.Println("authenticating request")

	parsed, err := GetAuthHeader(r)

	if err != nil {
		log.Printf("error getting auth header: %v\n", err)
		if raiseErr {
			http.Error(w, "error getting auth header", http.StatusInternalServerError)
		}
		return nil
	}

	if parsed == nil {
		log.Println("no auth header")
		if raiseErr {
			http.Error(w, "no auth header", http.StatusUnauthorized)
		}
		return nil
	}

	// validate the token
	authToken, err := db.ValidateAuthToken(parsed.Token)

	if err != nil {
		log.Printf("error validating auth token: %v\n", err)

		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeInvalidToken,
			Status: http.StatusUnauthorized,
			Msg:    "Invalid auth token",
		})
		return nil
	}

	user, err := db.GetUser(authToken.UserId)

	if err != nil {
		log.Printf("error getting user: %v\n", err)
		if raiseErr {
			http.Error(w, "error getting user", http.StatusInternalServerError)
		}
		return nil
	}

	if !requireOrg {
		return &types.ServerAuth{
			AuthToken: authToken,
			User:      user,
		}
	}

	if parsed.OrgId == "" {
		log.Println("no org id")
		if raiseErr {
			http.Error(w, "no org id", http.StatusUnauthorized)
		}
		return nil
	}

	// validate the org membership
	isMember, err := db.ValidateOrgMembership(authToken.UserId, parsed.OrgId)

	if err != nil {
		log.Printf("error validating org membership: %v\n", err)
		if raiseErr {
			http.Error(w, "error validating org membership", http.StatusInternalServerError)
		}
		return nil
	}

	if !isMember {
		// check if there's an invite for this user and accept it if so (adds the user to the org)
		invite, err := db.GetActiveInviteByEmail(parsed.OrgId, user.Email)

		if err != nil {
			log.Printf("error getting invite for org user: %v\n", err)
			if raiseErr {
				http.Error(w, "error getting invite for org user", http.StatusInternalServerError)
			}
			return nil
		}

		if invite != nil {
			log.Println("accepting invite")

			err := db.AcceptInvite(r.Context(), invite, authToken.UserId)

			if err != nil {
				log.Printf("error accepting invite: %v\n", err)
				if raiseErr {
					http.Error(w, "error accepting invite", http.StatusInternalServerError)
				}
				return nil
			}

		} else {
			log.Println("user is not a member of the org")
			if raiseErr {
				http.Error(w, "not a member of org", http.StatusUnauthorized)
			}
			return nil
		}
	}

	// get user permissions
	permissions, err := db.GetUserPermissions(authToken.UserId, parsed.OrgId)

	if err != nil {
		log.Printf("error getting user permissions: %v\n", err)
		if raiseErr {
			http.Error(w, "error getting user permissions", http.StatusInternalServerError)
		}
		return nil
	}

	// build the permissions map
	permissionsMap := make(shared.Permissions)
	for _, permission := range permissions {
		permissionsMap[permission] = true
	}

	auth := &types.ServerAuth{
		AuthToken:   authToken,
		User:        user,
		OrgId:       parsed.OrgId,
		Permissions: permissionsMap,
	}

	// don't send hash for org-session requests
	var hash string
	if r.URL.Path != "/orgs/session" {
		hash = parsed.Hash
	}

	_, apiErr := hooks.ExecHook(hooks.Authenticate, hooks.HookParams{
		Auth: auth,
		AuthenticateHookRequestParams: &hooks.AuthenticateHookRequestParams{
			Path: r.URL.Path,
			Hash: hash,
		},
	})

	if apiErr != nil {
		writeApiError(w, *apiErr)
		return nil
	}

	log.Printf("UserId: %s, Email: %s, OrgId: %s\n", authToken.UserId, user.Email, parsed.OrgId)

	return auth

}

func authorizeProject(w http.ResponseWriter, projectId string, auth *types.ServerAuth) bool {
	return authorizeProjectOptional(w, projectId, auth, true)
}

func authorizeProjectOptional(w http.ResponseWriter, projectId string, auth *types.ServerAuth, shouldErr bool) bool {
	log.Println("authorizing project")

	projectExists, err := db.ProjectExists(auth.OrgId, projectId)

	if err != nil {
		log.Printf("error validating project: %v\n", err)
		http.Error(w, "error validating project", http.StatusInternalServerError)
		return false
	}

	if !projectExists && shouldErr {
		log.Println("project does not exist in org")
		http.Error(w, "project does not exist in org", http.StatusNotFound)
		return false
	}

	return projectExists
}

func authorizeProjectRename(w http.ResponseWriter, projectId string, auth *types.ServerAuth) bool {
	if !authorizeProject(w, projectId, auth) {
		return false
	}

	if !auth.HasPermission(shared.PermissionRenameAnyProject) {
		log.Println("User does not have permission to rename project")
		http.Error(w, "User does not have permission to rename project", http.StatusForbidden)
		return false
	}

	return true
}

func authorizeProjectDelete(w http.ResponseWriter, projectId string, auth *types.ServerAuth) bool {
	if !authorizeProject(w, projectId, auth) {
		return false
	}

	if !auth.HasPermission(shared.PermissionDeleteAnyProject) {
		log.Println("User does not have permission to delete project")
		http.Error(w, "User does not have permission to delete project", http.StatusForbidden)
		return false
	}

	return true
}

func authorizePlan(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	log.Println("authorizing plan")

	plan, err := db.ValidatePlanAccess(planId, auth.User.Id, auth.OrgId)

	if err != nil {
		log.Printf("error validating plan membership: %v\n", err)
		http.Error(w, "error validating plan membership", http.StatusInternalServerError)
		return nil
	}

	if plan == nil {
		log.Println("user doesn't have access the plan")
		http.Error(w, "no access to plan", http.StatusUnauthorized)
		return nil
	}

	return plan
}

func authorizePlanUpdate(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return nil
	}

	if plan.OwnerId != auth.User.Id && !auth.HasPermission(shared.PermissionUpdateAnyPlan) {
		log.Println("User does not have permission to update plan")
		http.Error(w, "User does not have permission to update plan", http.StatusForbidden)
		return nil
	}

	return plan
}

func authorizePlanDelete(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return nil
	}

	if plan.OwnerId != auth.User.Id && !auth.HasPermission(shared.PermissionDeleteAnyPlan) {
		log.Println("User does not have permission to delete plan")
		http.Error(w, "User does not have permission to delete plan", http.StatusForbidden)
		return nil
	}

	return plan
}

func authorizePlanRename(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return nil
	}

	if plan.OwnerId != auth.User.Id && !auth.HasPermission(shared.PermissionRenameAnyPlan) {
		log.Println("User does not have permission to rename plan")
		http.Error(w, "User does not have permission to rename plan", http.StatusForbidden)
		return nil
	}

	return plan
}

func authorizePlanArchive(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return nil
	}

	if plan.OwnerId != auth.User.Id && !auth.HasPermission(shared.PermissionArchiveAnyPlan) {
		log.Println("User does not have permission to archive plan")
		http.Error(w, "User does not have permission to archive plan", http.StatusForbidden)
		return nil
	}

	return plan
}


================================================
FILE: app/server/handlers/branches.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func ListBranchesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListBranchesHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	var err error

	ctx, cancel := context.WithCancel(r.Context())
	var branches []*db.Branch

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   "main",
		Reason:   "list branches",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.ListPlanBranches(repo, planId)

		if err != nil {
			return err
		}

		branches = res

		return nil
	})

	if err != nil {
		log.Printf("Error getting branches: %v\n", err)
		http.Error(w, "Error getting branches: "+err.Error(), http.StatusInternalServerError)
		return
	}

	jsonBytes, err := json.Marshal(branches)

	if err != nil {
		log.Printf("Error marshalling branches: %v\n", err)
		http.Error(w, "Error marshalling branches: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully retrieved branches")

	w.Write(jsonBytes)
}

func CreateBranchHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateBranchHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer func() {
		log.Println("Closing request body")
		r.Body.Close()
	}()

	var req shared.CreateBranchRequest
	if err := json.Unmarshal(body, &req); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body ", http.StatusBadRequest)
		return
	}

	parentBranch, err := db.GetDbBranch(planId, branch)

	if err != nil {
		log.Printf("Error getting parent branch: %v\n", err)
		http.Error(w, "Error getting parent branch: "+err.Error(), http.StatusInternalServerError)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   "main",
		Reason:   "create branch",
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {

		err := db.WithTx(ctx, "create branch", func(tx *sqlx.Tx) error {
			_, err = db.CreateBranch(repo, plan, parentBranch, req.Name, tx)

			if err != nil {
				return fmt.Errorf("error creating branch: %v", err)
			}

			return nil
		})

		return err
	})

	if err != nil {
		log.Printf("Error creating branch: %v\n", err)
		http.Error(w, "Error creating branch: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created branch")
}

func DeleteBranchHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for DeleteBranchHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	if branch == "main" {
		log.Println("Cannot delete main branch")
		http.Error(w, "Cannot delete main branch", http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   "main",
		Reason:   "delete branch",
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		err := repo.GitDeleteBranch(branch)
		return err
	})

	if err != nil {
		log.Printf("Error deleting branch: %v\n", err)
		http.Error(w, "Error deleting branch: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully deleted branch")
}


================================================
FILE: app/server/handlers/client_helper.go
================================================
package handlers

import (
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/model"
	"plandex-server/types"
	shared "plandex-shared"
)

type initClientsParams struct {
	w    http.ResponseWriter
	auth *types.ServerAuth

	apiKeys     map[string]string // deprecated
	openAIOrgId string            // deprecated

	authVars map[string]string

	plan          *db.Plan
	settings      *shared.PlanSettings
	orgUserConfig *shared.OrgUserConfig
}

type initClientsResult struct {
	clients  map[string]model.ClientInfo
	authVars map[string]string
}

func initClients(params initClientsParams) initClientsResult {
	w := params.w
	settings := params.settings
	orgUserConfig := params.orgUserConfig

	authVars := map[string]string{}
	if params.authVars != nil {
		authVars = params.authVars
	} else if params.apiKeys != nil {
		authVars = map[string]string{}
		for envVar, apiKey := range params.apiKeys {
			authVars[envVar] = apiKey
		}
		if params.openAIOrgId != "" {
			authVars["OPENAI_ORG_ID"] = params.openAIOrgId
		}
	}

	hookResult, apiErr := hooks.ExecHook(hooks.GetIntegratedModels, hooks.HookParams{
		Auth: params.auth,
		Plan: params.plan,
	})

	if apiErr != nil {
		log.Printf("Error getting integrated models: %v\n", apiErr)
		http.Error(w, "Error getting integrated models", http.StatusInternalServerError)
		return initClientsResult{}
	}

	if hookResult.GetIntegratedModelsResult != nil && hookResult.GetIntegratedModelsResult.IntegratedModelsMode {
		merged := map[string]string{}
		for k, v := range hookResult.GetIntegratedModelsResult.AuthVars {
			merged[k] = v
		}
		if authVars[shared.AnthropicClaudeMaxTokenEnvVar] != "" {
			merged[shared.AnthropicClaudeMaxTokenEnvVar] = authVars[shared.AnthropicClaudeMaxTokenEnvVar]
		}
		authVars = merged
	}
	if len(authVars) == 0 && os.Getenv("IS_CLOUD") != "" {
		log.Println("No api keys/credentials provided for models")
		http.Error(w, "No api keys/credentials provided for models", http.StatusBadRequest)
		return initClientsResult{}
	}

	clients := model.InitClients(authVars, settings, orgUserConfig)

	return initClientsResult{
		clients:  clients,
		authVars: authVars,
	}
}


================================================
FILE: app/server/handlers/context_helper.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/types"
	"runtime"
	"runtime/debug"

	shared "plandex-shared"
)

type loadContextsParams struct {
	w                http.ResponseWriter
	r                *http.Request
	auth             *types.ServerAuth
	loadReq          *shared.LoadContextRequest
	plan             *db.Plan
	branchName       string
	cachedMapsByPath map[string]*db.CachedMap
	autoLoaded       bool
}

func loadContexts(
	params loadContextsParams,
) (*shared.LoadContextResponse, []*db.Context) {
	w := params.w
	r := params.r
	auth := params.auth
	loadReq := params.loadReq
	plan := params.plan
	branchName := params.branchName
	cachedMapsByPath := params.cachedMapsByPath
	autoLoaded := params.autoLoaded

	log.Printf("[ContextHelper] Starting loadContexts with %d contexts, cachedMapsByPath: %v, autoLoaded: %v", len(*loadReq), cachedMapsByPath != nil, autoLoaded)

	// check file count and size limits
	// this is all a sanity check - we should have already checked these limits in the client
	totalFiles := 0
	mapFilesCount := 0
	for _, context := range *loadReq {
		totalFiles++
		if context.ContextType == shared.ContextMapType {
			mapFilesCount++
			log.Printf("[ContextHelper] Found map file: %s with %d map bodies", context.FilePath, len(context.MapBodies))

			if len(context.MapBodies) > shared.MaxContextMapPaths {
				log.Printf("Error: Too many map files to load (found %d, limit is %d)\n", len(context.MapBodies), shared.MaxContextMapPaths)
				http.Error(w, fmt.Sprintf("Too many map files to load (found %d, limit is %d)", len(context.MapBodies), shared.MaxContextMapPaths), http.StatusBadRequest)
				return nil, nil
			}

			// these are already mapped, so they shouldn't be anywhere close to the input limit, but we'll use it for the sanity check
			for _, body := range context.MapBodies {
				if len(body) > shared.MaxContextMapSingleInputSize {
					log.Printf("Error: Map file %s exceeds size limit (size %d, limit %d)\n", context.FilePath, len(body), shared.MaxContextMapSingleInputSize)
					http.Error(w, fmt.Sprintf("Map file %s exceeds size limit (size %d, limit %d)", context.FilePath, len(body), shared.MaxContextMapSingleInputSize), http.StatusBadRequest)
					return nil, nil
				}
			}
		}

		if totalFiles > shared.MaxContextCount {
			log.Printf("Error: Too many contexts to load (found %d, limit is %d)\n", totalFiles, shared.MaxContextCount)
			http.Error(w, fmt.Sprintf("Too many contexts to load (found %d, limit is %d)", totalFiles, shared.MaxContextCount), http.StatusBadRequest)
			return nil, nil
		}

		fileSize := int64(len(context.Body))
		if fileSize > shared.MaxContextBodySize {
			log.Printf("Error: Context %s exceeds size limit (size %.2f MB, limit %d MB)\n", context.Name, float64(fileSize)/1024/1024, int(shared.MaxContextBodySize)/1024/1024)
			http.Error(w, fmt.Sprintf("Context %s exceeds size limit (size %.2f MB, limit %d MB)", context.Name, float64(fileSize)/1024/1024, int(shared.MaxContextBodySize)/1024/1024), http.StatusBadRequest)
			return nil, nil
		}

	}

	if mapFilesCount > 0 {
		log.Printf("[ContextHelper] Processing %d map files out of %d total contexts", mapFilesCount, totalFiles)
	}

	var err error

	var settings *shared.PlanSettings
	var clients map[string]model.ClientInfo
	var authVars map[string]string
	var orgUserConfig *shared.OrgUserConfig

	for _, context := range *loadReq {
		if context.ContextType == shared.ContextPipedDataType || context.ContextType == shared.ContextNoteType || context.ContextType == shared.ContextImageType {

			settings, err = db.GetPlanSettings(plan)

			if err != nil {
				log.Printf("Error getting plan settings: %v\n", err)
				http.Error(w, "Error getting plan settings: "+err.Error(), http.StatusInternalServerError)
				return nil, nil
			}

			orgUserConfig, err = db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
			if err != nil {
				log.Printf("Error getting org user config: %v\n", err)
				http.Error(w, "Error getting org user config: "+err.Error(), http.StatusInternalServerError)
				return nil, nil
			}

			res := initClients(
				initClientsParams{
					w:           w,
					auth:        auth,
					apiKeys:     context.ApiKeys,
					openAIOrgId: context.OpenAIOrgId,
					authVars:    context.AuthVars,
					plan:        plan,
					settings:    settings,
				},
			)

			clients = res.clients
			authVars = res.authVars

			break
		}
	}

	// ensure image compatibility if we're loading an image
	for _, context := range *loadReq {
		if context.ContextType == shared.ContextImageType {
			if !settings.GetModelPack().Planner.GetSharedBaseConfig(settings).HasImageSupport {
				log.Printf("Error loading context: %s does not support images in context\n", settings.GetModelPack().Planner.ModelId)
				http.Error(w, fmt.Sprintf("Error loading context: %s does not support images in context", settings.GetModelPack().Planner.ModelId), http.StatusBadRequest)
				return nil, nil
			}
		}
	}

	// get name for piped data or notes if present
	num := 0
	errCh := make(chan error, len(*loadReq))
	for _, context := range *loadReq {
		if context.ContextType == shared.ContextPipedDataType {
			num++

			go func(context *shared.LoadContextParams) {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in GenPipedDataName: %v\n%s", r, debug.Stack())
						errCh <- fmt.Errorf("panic in GenPipedDataName: %v\n%s", r, debug.Stack())
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()

				name, err := model.GenPipedDataName(model.GenPipedDataNameParams{
					Ctx:           r.Context(),
					Auth:          auth,
					Plan:          plan,
					Settings:      settings,
					AuthVars:      authVars,
					SessionId:     context.SessionId,
					Clients:       clients,
					PipedContent:  context.Body,
					OrgUserConfig: orgUserConfig,
				})

				if err != nil {
					errCh <- fmt.Errorf("error generating name for piped data: %v", err)
					return
				}

				context.Name = name
				errCh <- nil
			}(context)
		} else if context.ContextType == shared.ContextNoteType {
			num++

			go func(context *shared.LoadContextParams) {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in GenNoteName: %v\n%s", r, debug.Stack())
						errCh <- fmt.Errorf("panic in GenNoteName: %v\n%s", r, debug.Stack())
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()

				name, err := model.GenNoteName(r.Context(), auth, plan, settings, orgUserConfig, clients, authVars, context.Body, context.SessionId)

				if err != nil {
					errCh <- fmt.Errorf("error generating name for note: %v", err)
					return
				}

				context.Name = name
				errCh <- nil
			}(context)
		}
	}
	if num > 0 {
		for i := 0; i < num; i++ {
			err := <-errCh
			if err != nil {
				log.Printf("Error: %v\n", err)
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return nil, nil
			}
		}
	}

	ctx, cancel := context.WithCancel(r.Context())

	var loadRes *shared.LoadContextResponse
	var dbContexts []*db.Context

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         plan.Id,
		Branch:         branchName,
		Reason:         "load contexts",
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		log.Printf("[ContextHelper] Calling db.LoadContexts with %d contexts, %d cached maps", len(*loadReq), len(cachedMapsByPath))
		for path := range cachedMapsByPath {
			log.Printf("[ContextHelper] Using cached map for path: %s", path)
		}

		res, dbContextsRes, err := db.LoadContexts(ctx, db.LoadContextsParams{
			OrgId:            auth.OrgId,
			Plan:             plan,
			BranchName:       branchName,
			Req:              loadReq,
			UserId:           auth.User.Id,
			CachedMapsByPath: cachedMapsByPath,
			AutoLoaded:       autoLoaded,
		})

		if err != nil {
			return err
		}

		loadRes = res
		dbContexts = dbContextsRes

		log.Printf("[ContextHelper] db.LoadContexts completed successfully, loaded %d contexts", len(dbContexts))

		// Log information about loaded map contexts
		mapContextsCount := 0
		for _, context := range dbContexts {
			if context.ContextType == shared.ContextMapType {
				mapContextsCount++
				log.Printf("[ContextHelper] Loaded map context: %s, path: %s, tokens: %d", context.Name, context.FilePath, context.NumTokens)
			}
		}
		if mapContextsCount > 0 {
			log.Printf("[ContextHelper] Successfully loaded %d map contexts out of %d total contexts", mapContextsCount, len(dbContexts))
		}

		if loadRes.MaxTokensExceeded {
			return nil
		}

		log.Printf("[ContextHelper] Committing changes to branch %s", branchName)
		err = repo.GitAddAndCommit(branchName, res.Msg)

		if err != nil {
			return fmt.Errorf("error committing changes: %v", err)
		}

		log.Printf("[ContextHelper] Committing changes to branch %s completed successfully", branchName)

		return nil
	})

	if err != nil {
		log.Printf("Error loading contexts: %v\n", err)
		http.Error(w, "Error loading contexts: "+err.Error(), http.StatusInternalServerError)
		return nil, nil
	}

	if loadRes.MaxTokensExceeded {
		log.Printf("The total number of tokens (%d) exceeds the maximum allowed (%d)", loadRes.TotalTokens, loadRes.MaxTokens)
		bytes, err := json.Marshal(loadRes)

		if err != nil {
			log.Printf("Error marshalling response: %v\n", err)
			http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
			return nil, nil
		}

		w.Write(bytes)
		return nil, nil
	}

	return loadRes, dbContexts
}


================================================
FILE: app/server/handlers/err_helper.go
================================================
package handlers

import (
	"encoding/json"
	"log"
	"net/http"

	shared "plandex-shared"
)

func writeApiError(w http.ResponseWriter, apiErr shared.ApiError) {
	bytes, err := json.Marshal(apiErr)
	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		// If marshalling fails, fall back to a simpler error message
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	log.Printf("API Error: %v\n", apiErr.Msg)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(apiErr.Status)

	_, writeErr := w.Write(bytes)
	if writeErr != nil {
		log.Printf("Error writing response: %v\n", writeErr)
	}
}


================================================
FILE: app/server/handlers/file_maps.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"runtime"
	"runtime/debug"
	"sync"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func GetFileMapHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetFileMapHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		log.Println("GetFileMapHandler: auth failed")
		return
	}

	var req shared.GetFileMapRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, fmt.Sprintf("Error decoding request: %v", err), http.StatusBadRequest)
		return
	}

	log.Println("GetFileMapHandler: checking limits")

	if len(req.MapInputs) > shared.MaxContextMapPaths {
		http.Error(w, fmt.Sprintf("Too many files to map: %d (max %d)", len(req.MapInputs), shared.MaxContextMapPaths), http.StatusBadRequest)
		return
	}

	totalSize := 0
	for path, input := range req.MapInputs {
		// the client should be truncating inputs to the max size, but we'll check here too
		if len(input) > shared.MaxContextMapSingleInputSize {
			http.Error(w, fmt.Sprintf("File %s is too large: %d (max %d)", path, len(input), shared.MaxContextMapSingleInputSize), http.StatusBadRequest)
			return
		}
		totalSize += len(input)
	}

	// On the client, once the total size limit is exceeded, we send empty file maps for remaining files
	if totalSize > shared.MaxContextMapTotalInputSize+10000 {
		http.Error(w, fmt.Sprintf("Max map size exceeded: %d (max %d)", totalSize, shared.MaxContextMapTotalInputSize), http.StatusBadRequest)
		return
	}

	// Check batch size limits
	if len(req.MapInputs) > shared.ContextMapMaxBatchSize {
		http.Error(w, fmt.Sprintf("Batch contains too many files: %d (max %d)", len(req.MapInputs), shared.ContextMapMaxBatchSize), http.StatusBadRequest)
		return
	}

	if int64(totalSize) > shared.ContextMapMaxBatchBytes {
		http.Error(w, fmt.Sprintf("Batch size too large: %d bytes (max %d bytes)", totalSize, shared.ContextMapMaxBatchBytes), http.StatusBadRequest)
		return
	}

	results := make(chan shared.FileMapBodies, 1)

	err := queueProjectMapJob(projectMapJob{
		inputs:  req.MapInputs,
		ctx:     r.Context(),
		results: results,
	})
	if err != nil {
		log.Println("GetFileMapHandler: map queue is full")
		http.Error(w, "Too many project map jobs, please try again later", http.StatusTooManyRequests)
		return
	}

	select {
	case <-r.Context().Done():
		http.Error(w, "Request was cancelled", http.StatusRequestTimeout)
		return
	case maps := <-results:
		if maps == nil {
			http.Error(w, "Mapping timed out", http.StatusRequestTimeout)
			return
		}

		resp := shared.GetFileMapResponse{
			MapBodies: maps,
		}
		respBytes, err := json.Marshal(resp)
		if err != nil {
			http.Error(w, fmt.Sprintf("Error marshalling response: %v", err), http.StatusInternalServerError)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.Write(respBytes)

		log.Printf("GetFileMapHandler success - writing response bytes: %d", len(respBytes))
	}
}

func LoadCachedFileMapHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for LoadCachedFileMapHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branchName := vars["branch"]
	log.Println("planId: ", planId, "branchName: ", branchName)

	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return
	}

	var req shared.LoadCachedFileMapRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, fmt.Sprintf("Error decoding request: %v", err), http.StatusBadRequest)
		return
	}

	cachedMetaByPath := map[string]*shared.Context{}
	cachedMapsByPath := map[string]*db.CachedMap{}
	var mu sync.Mutex
	errCh := make(chan error, len(req.FilePaths))

	for _, path := range req.FilePaths {
		go func(path string) {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in LoadCachedFileMapHandler: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic in LoadCachedFileMapHandler: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			cachedContext, err := db.GetCachedMap(plan.OrgId, plan.ProjectId, path)
			if err != nil {
				errCh <- fmt.Errorf("error getting cached map: %v", err)
				return
			}
			if cachedContext != nil {
				mu.Lock()
				cachedMetaByPath[path] = cachedContext.ToMeta().ToApi()
				cachedMapsByPath[path] = &db.CachedMap{
					MapParts:  cachedContext.MapParts,
					MapShas:   cachedContext.MapShas,
					MapTokens: cachedContext.MapTokens,
					MapSizes:  cachedContext.MapSizes,
				}
				mu.Unlock()
			}
			errCh <- nil
		}(path)
	}

	for range req.FilePaths {
		err := <-errCh
		if err != nil {
			log.Printf("Error getting cached map: %v", err)
			http.Error(w, fmt.Sprintf("Error getting cached map: %v", err), http.StatusInternalServerError)
			return
		}
	}

	resp := shared.LoadCachedFileMapResponse{}

	var loadRes *shared.LoadContextResponse
	if len(cachedMetaByPath) == 0 {
		log.Println("no cached maps found")
	} else {
		log.Println("cached map found")

		cachedByPath := map[string]bool{}
		for _, cachedContext := range cachedMetaByPath {
			cachedByPath[cachedContext.FilePath] = true
		}
		resp.CachedByPath = cachedByPath

		var loadReq shared.LoadContextRequest
		for _, cachedContext := range cachedMetaByPath {
			loadReq = append(loadReq, &shared.LoadContextParams{
				ContextType: shared.ContextMapType,
				Name:        cachedContext.Name,
				FilePath:    cachedContext.FilePath,
				Body:        cachedContext.Body,
			})
		}

		loadRes, _ = loadContexts(loadContextsParams{
			w:                w,
			r:                r,
			auth:             auth,
			loadReq:          &loadReq,
			plan:             plan,
			branchName:       branchName,
			cachedMapsByPath: cachedMapsByPath,
		})

		if loadRes == nil {
			log.Println("LoadCachedFileMapHandler - loadRes is nil")
			return
		}

		resp.LoadRes = loadRes
	}

	bytes, err := json.Marshal(resp)
	if err != nil {
		log.Printf("Error marshalling response: %v", err)
		http.Error(w, fmt.Sprintf("Error marshalling response: %v", err), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}


================================================
FILE: app/server/handlers/file_maps_queue.go
================================================
package handlers

import (
	"context"
	"errors"
	"log"
	"math"
	"plandex-server/syntax/file_map"
	shared "plandex-shared"
	"runtime"
	"sync"
	"time"
)

// simple in-memory per-instance queue for file map jobs
// ensures mapping doesn't take over all available CPUs

const fileMapMaxQueueSize = 20 // caller errors out if this is exceeded
var fileMapMaxConcurrency = 3  // set to 3/4 of available CPUs below
const mapJobTimeout = 60 * time.Second

type projectMapJob struct {
	inputs  shared.FileMapInputs
	ctx     context.Context
	results chan shared.FileMapBodies
}

var projectMapQueue = make(chan projectMapJob, fileMapMaxQueueSize)

var mapCPUSem chan struct{}

func init() {
	// Use 3/4 of available CPUs for mapping workers
	cpus := runtime.NumCPU()
	fileMapMaxConcurrency = int(math.Ceil(float64(cpus) * 0.75))
	if fileMapMaxConcurrency < 1 {
		fileMapMaxConcurrency = 1
	}

	log.Printf("fileMapMaxConcurrency: %d", fileMapMaxConcurrency)

	mapCPUSem = make(chan struct{}, fileMapMaxConcurrency)

	// start workers, one per CPU
	for i := 0; i < fileMapMaxConcurrency; i++ {
		go processProjectMapQueue()
	}
}

func processProjectMapQueue() {
	for job := range projectMapQueue {
		if job.ctx.Err() != nil {
			if job.ctx.Err() == context.DeadlineExceeded {
				log.Printf("processProjectMapQueue: job context deadline exceeded: %v", job.ctx.Err())
				safeSend(job.results, nil)
				continue
			}
			log.Printf("processProjectMapQueue: job context cancelled: %v", job.ctx.Err())
			safeSend(job.results, nil)
			continue
		}
		ctxWithTimeout, cancel := context.WithTimeout(job.ctx, mapJobTimeout)
		mapWorker(projectMapJob{
			inputs:  job.inputs,
			ctx:     ctxWithTimeout,
			results: job.results,
		})
		cancel()
	}
}

func queueProjectMapJob(job projectMapJob) error {
	log.Printf("queueProjectMapJob: len(projectMapQueue): %d", len(projectMapQueue))
	select {
	case projectMapQueue <- job:
		return nil
	default:
		return errors.New("queue is full")
	}
}

func mapWorker(job projectMapJob) {
	maps := make(shared.FileMapBodies)
	wg := sync.WaitGroup{}
	var mu sync.Mutex

	log.Printf("mapWorker: len(job.inputs): %d", len(job.inputs))

	for path, input := range job.inputs {
		if !shared.HasFileMapSupport(path) {
			mu.Lock()
			maps[path] = "[NO MAP]"
			mu.Unlock()
			continue
		}

		wg.Add(1)
		go func(path string, input string) {
			if job.ctx.Err() != nil {
				wg.Done()
				return
			}

			mapCPUSem <- struct{}{}
			defer func() { <-mapCPUSem }()
			defer wg.Done()

			fileMap, err := file_map.MapFile(job.ctx, path, []byte(input))
			if err != nil {
				// Skip files that can't be parsed, just log the error
				log.Printf("Error mapping file %s: %v", path, err)
				mu.Lock()
				maps[path] = "[NO MAP]"
				mu.Unlock()
				return
			}
			mu.Lock()
			maps[path] = fileMap.String()
			mu.Unlock()
		}(path, input)
	}

	wg.Wait()

	if job.ctx.Err() != nil {
		safeSend(job.results, nil)
		return
	}

	safeSend(job.results, maps)
}

func safeSend(ch chan shared.FileMapBodies, v shared.FileMapBodies) {
	// never block, never panic
	select {
	case ch <- v:
	default: // buffer already full – receiver must have gone away
	}
}


================================================
FILE: app/server/handlers/invites.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/email"
	"strings"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func InviteUserHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for InviteUserHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for invites",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)

	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't invite other users",
		})

		return
	}

	currentUserId := auth.User.Id

	var req shared.InviteRequest
	err = json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}
	req.Email = strings.ToLower(req.Email)

	// ensure current user can invite target user
	permission := shared.Permission(strings.Join([]string{string(shared.PermissionInviteUser), req.OrgRoleId}, "|"))

	if !auth.HasPermission(permission) {
		log.Printf("User does not have permission to invite user with role: %v\n", req.OrgRoleId)
		http.Error(w, "User does not have permission to invite user with role: "+req.OrgRoleId, http.StatusForbidden)
		return
	}

	// ensure user doesn't already have access to org via domain
	split := strings.Split(req.Email, "@")
	if len(split) != 2 {
		log.Printf("Invalid email: %v\n", req.Email)
		http.Error(w, "Invalid email: "+req.Email, http.StatusBadRequest)
		return
	}
	domain := &split[1]

	if org.AutoAddDomainUsers && org.Domain == domain {
		log.Printf("User already has access to org via domain: %v\n", domain)
		http.Error(w, "User already has access to org via domain: "+*domain, http.StatusBadRequest)
	}

	// ensure user with this email isn't already in the org
	user, err := db.GetUserByEmail(req.Email)

	if err != nil {
		log.Printf("Error getting user: %v\n", err)
		http.Error(w, "Error getting user: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if user != nil {
		isMember, err := db.ValidateOrgMembership(user.Id, auth.OrgId)

		if err != nil {
			log.Printf("Error validating org membership: %v\n", err)
			http.Error(w, "Error validating org membership: "+err.Error(), http.StatusInternalServerError)
			return
		}

		if isMember {
			log.Println("User is already a member of org")
			http.Error(w, "User is already a member of org", http.StatusBadRequest)
			return
		}
	}

	// ensure invite isn't already active
	invite, err := db.GetActiveInviteByEmail(auth.OrgId, req.Email)

	if err != nil {
		log.Printf("Error getting invite: %v\n", err)
		http.Error(w, "Error getting invite: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if invite != nil {
		log.Println("Invite already exists")
		http.Error(w, "Invite already exists", http.StatusBadRequest)
		return
	}

	err = db.WithTx(r.Context(), "invite user", func(tx *sqlx.Tx) error {

		err = db.CreateInvite(&db.Invite{
			OrgId:     auth.OrgId,
			OrgRoleId: req.OrgRoleId,
			Email:     req.Email,
			Name:      req.Name,
			InviterId: currentUserId,
		}, tx)

		if err != nil {
			log.Printf("Error creating invite: %v\n", err)
			return fmt.Errorf("error creating invite: %v", err)
		}

		err = email.SendInviteEmail(req.Email, req.Name, auth.User.Name, org.Name)

		if err != nil {
			log.Printf("Error sending invite email: %v\n", err)
			return fmt.Errorf("error sending invite email: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error inviting user: %v\n", err)
		http.Error(w, "Error inviting user: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created invite")
}

func ListPendingInvitesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for ListInvitesHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for invites",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't list invites",
		})
		return
	}

	invites, err := db.ListPendingInvites(auth.OrgId)

	if err != nil {
		log.Printf("Error listing invites: %v\n", err)
		http.Error(w, "Error listing invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiInvites []*shared.Invite
	for _, invite := range invites {
		apiInvites = append(apiInvites, invite.ToApi())
	}

	bytes, err := json.Marshal(apiInvites)

	if err != nil {
		log.Printf("Error marshalling invites: %v\n", err)
		http.Error(w, "Error marshalling invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
	log.Println("Successfully processed request for ListPendingInvitesHandler")
}

func ListAcceptedInvitesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for ListAcceptedInvitesHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for invites",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't list invites",
		})
		return
	}

	invites, err := db.ListAcceptedInvites(auth.OrgId)

	if err != nil {
		log.Printf("Error listing invites: %v\n", err)
		http.Error(w, "Error listing invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiInvites []*shared.Invite
	for _, invite := range invites {
		apiInvites = append(apiInvites, invite.ToApi())
	}

	bytes, err := json.Marshal(apiInvites)

	if err != nil {
		log.Printf("Error marshalling invites: %v\n", err)
		http.Error(w, "Error marshalling invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
	log.Println("Successfully processed request for ListAcceptedInvitesHandler")
}

func ListAllInvitesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for ListAllInvitesHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for invites",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't list invites",
		})
		return
	}

	invites, err := db.ListAllInvites(auth.OrgId)

	if err != nil {
		log.Printf("Error listing invites: %v\n", err)
		http.Error(w, "Error listing invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiInvites []*shared.Invite
	for _, invite := range invites {
		apiInvites = append(apiInvites, invite.ToApi())
	}

	bytes, err := json.Marshal(apiInvites)

	if err != nil {
		log.Printf("Error marshalling invites: %v\n", err)
		http.Error(w, "Error marshalling invites: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
	log.Println("Successfully processed request for ListAllInvitesHandler")
}

func DeleteInviteHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for DeleteInviteHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for invites",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't delete invites",
		})
		return
	}

	vars := mux.Vars(r)
	inviteId := vars["inviteId"]

	invite, err := db.GetInvite(inviteId)

	if err != nil {
		log.Printf("Error getting invite: %v\n", err)
		http.Error(w, "Error getting invite: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if invite == nil || invite.OrgId != auth.OrgId {
		log.Printf("Invite not found: %v\n", inviteId)
		http.Error(w, "Invite not found: "+inviteId, http.StatusNotFound)
		return
	}

	// ensure current user can remove target invite
	removePermission := shared.Permission(strings.Join([]string{string(shared.PermissionRemoveUser), invite.OrgRoleId}, "|"))

	invitePermission := shared.Permission(strings.Join([]string{string(shared.PermissionInviteUser), invite.OrgRoleId}, "|"))

	if !(auth.HasPermission(removePermission) ||
		(auth.User.Id == invite.InviterId && auth.HasPermission(invitePermission))) {
		log.Printf("User does not have permission to remove invite with role: %v\n", invite.OrgRoleId)
		http.Error(w, "User does not have permission to remove invite with role: "+invite.OrgRoleId, http.StatusForbidden)
		return
	}

	err = db.DeleteInvite(inviteId, nil)

	if err != nil {
		log.Printf("Error deleting invite: %v\n", err)
		http.Error(w, "Error deleting invite: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully deleted invite")
}


================================================
FILE: app/server/handlers/models.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

const CustomModelsMinClientVersion = "2.2.0"

func UpsertCustomModelsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateCustomModelHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !requireMinClientVersion(w, r, CustomModelsMinClientVersion) {
		return
	}

	var modelsInput shared.ModelsInput
	if err := json.NewDecoder(r.Body).Decode(&modelsInput); err != nil {
		log.Printf("Error decoding request body: %v\n", err)
		http.Error(w, "Invalid request body: "+err.Error(), http.StatusBadRequest)
		return
	}

	if len(modelsInput.CustomProviders) > 0 {
		if os.Getenv("IS_CLOUD") != "" {
			http.Error(w, "Custom model providers are not supported on Plandex Cloud", http.StatusBadRequest)
			return
		}
	}

	if len(modelsInput.CustomModels) > 0 {
		if os.Getenv("IS_CLOUD") != "" {
			apiOrg, err := getApiOrg(auth.OrgId)
			if err != nil {
				log.Printf("Error fetching org: %v\n", err)
				http.Error(w, "Failed to create custom model: "+err.Error(), http.StatusInternalServerError)
				return
			}

			if apiOrg.IntegratedModelsMode {
				http.Error(w, "Custom models are not supported on Plandex Cloud in Integrated Models mode", http.StatusBadRequest)
				return
			}
		}
	}

	hasDuplicates, errMsg := modelsInput.CheckNoDuplicates()
	if !hasDuplicates {
		http.Error(w, "Has duplicates: "+errMsg, http.StatusBadRequest)
		return
	}

	for _, provider := range modelsInput.CustomProviders {
		if provider.Name == "" {
			msg := "Provider name is required"
			log.Println(msg)
			http.Error(w, msg, http.StatusBadRequest)
			return
		}
	}

	for _, model := range modelsInput.CustomModels {
		if model.ModelId == "" {
			msg := "Model id is required"
			log.Println(msg)
			http.Error(w, msg, http.StatusBadRequest)
			return
		}

		if shared.BuiltInBaseModelsById[model.ModelId] != nil {
			msg := fmt.Sprintf("%s is a built-in base model id, so it can't be used for a custom model", model.ModelId)
			log.Println(msg)
			http.Error(w, msg, http.StatusUnprocessableEntity)
			return
		}
	}

	for _, modelPack := range modelsInput.CustomModelPacks {
		if modelPack.Name == "" {
			msg := "Model pack name is required"
			log.Println(msg)
			http.Error(w, msg, http.StatusBadRequest)
			return
		}

		if shared.BuiltInModelPacksByName[modelPack.Name] != nil {
			msg := fmt.Sprintf("%s is a built-in model pack name, so it can't be used for a custom model pack", modelPack.Name)
			log.Println(msg)
			http.Error(w, msg, http.StatusUnprocessableEntity)
			return
		}
	}

	var existingCustomModelIds = make(map[shared.ModelId]bool)
	var existingCustomProviderNames = make(map[string]bool)

	customModels, err := db.ListCustomModels(auth.OrgId)
	if err != nil {
		log.Printf("Error fetching custom models: %v\n", err)
		http.Error(w, "Failed to create custom model: "+err.Error(), http.StatusInternalServerError)
		return
	}

	customModelPacks, err := db.ListModelPacks(auth.OrgId)
	if err != nil {
		log.Printf("Error fetching custom model packs: %v\n", err)
		http.Error(w, "Failed to create custom model: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var customProviders []*db.CustomProvider

	if os.Getenv("IS_CLOUD") == "" {
		customProviders, err = db.ListCustomProviders(auth.OrgId)
		if err != nil {
			log.Printf("Error fetching custom providers: %v\n", err)
			http.Error(w, "Failed to create custom model: "+err.Error(), http.StatusInternalServerError)
			return
		}
	}

	apiCustomModels := make([]*shared.CustomModel, len(customModels))
	for i, model := range customModels {
		apiCustomModels[i] = model.ToApi()
	}

	apiCustomProviders := make([]*shared.CustomProvider, len(customProviders))
	for i, provider := range customProviders {
		apiCustomProviders[i] = provider.ToApi()
	}

	apiCustomModelPacks := make([]*shared.ModelPackSchema, len(customModelPacks))
	for i, modelPack := range customModelPacks {
		apiCustomModelPacks[i] = modelPack.ToApi().ToModelPackSchema()
	}

	updatedModelsInput := modelsInput.FilterUnchanged(&shared.ModelsInput{
		CustomModels:     apiCustomModels,
		CustomProviders:  apiCustomProviders,
		CustomModelPacks: apiCustomModelPacks,
	})

	for _, model := range customModels {
		existingCustomModelIds[model.ModelId] = true
	}

	for _, provider := range customProviders {
		existingCustomProviderNames[provider.Name] = true
	}

	inputModelIds := make(map[string]bool)
	inputProviderNames := make(map[string]bool)
	inputModelPackNames := make(map[string]bool)

	for _, model := range modelsInput.CustomModels {
		inputModelIds[string(model.ModelId)] = true
	}

	for _, provider := range modelsInput.CustomProviders {
		inputProviderNames[provider.Name] = true
	}

	for _, modelPack := range modelsInput.CustomModelPacks {
		inputModelPackNames[modelPack.Name] = true
	}

	var toUpsertCustomModels []*db.CustomModel
	var toUpsertCustomProviders []*db.CustomProvider
	var toUpsertModelPacks []*db.ModelPack

	for _, provider := range updatedModelsInput.CustomProviders {
		dbProvider := db.CustomProviderFromApi(provider)
		dbProvider.Id = provider.Id
		dbProvider.OrgId = auth.OrgId

		toUpsertCustomProviders = append(toUpsertCustomProviders, dbProvider)
	}

	for _, model := range updatedModelsInput.CustomModels {
		// ensure that providers to upsert are either built-in, being imported, or already exist
		for _, provider := range model.Providers {
			if provider.Provider == shared.ModelProviderCustom {
				_, exists := existingCustomProviderNames[*provider.CustomProvider]
				_, creating := inputProviderNames[*provider.CustomProvider]
				if !exists && !creating {
					msg := fmt.Sprintf("'%s' is not a custom model provider that exists or is being imported", *provider.CustomProvider)
					log.Println(msg)
					http.Error(w, msg, http.StatusUnprocessableEntity)
					return
				}
			} else {
				pc, builtIn := shared.BuiltInModelProviderConfigs[provider.Provider]
				if !builtIn {
					msg := fmt.Sprintf("'%s' is not a built-in model provider", provider.Provider)
					log.Println(msg)
					http.Error(w, msg, http.StatusUnprocessableEntity)
					return
				}
				if os.Getenv("IS_CLOUD") != "" && pc.LocalOnly {
					msg := fmt.Sprintf("'%s' is a local-only model provider, so it can't be used on Plandex Cloud", provider.Provider)
					log.Println(msg)
					http.Error(w, msg, http.StatusUnprocessableEntity)
					return
				}
			}
		}

		dbModel := db.CustomModelFromApi(model)
		dbModel.Id = model.Id
		dbModel.OrgId = auth.OrgId

		toUpsertCustomModels = append(toUpsertCustomModels, dbModel)
	}

	for _, modelPack := range updatedModelsInput.CustomModelPacks {
		// ensure that all models are either built-in, being imported, or already exist
		allModelIds := modelPack.AllModelIds()

		for _, modelId := range allModelIds {
			_, exists := existingCustomModelIds[modelId]
			_, creating := inputModelIds[string(modelId)]
			bm, builtIn := shared.BuiltInBaseModelsById[modelId]

			if !exists && !creating && !builtIn {
				msg := fmt.Sprintf("'%s' is not built-in, not being imported, and not an existing custom model", modelId)
				log.Println(msg)
				http.Error(w, msg, http.StatusUnprocessableEntity)
				return
			}

			if builtIn && os.Getenv("IS_CLOUD") != "" && bm.IsLocalOnly() {
				msg := fmt.Sprintf("'%s' is a local-only built-in model, so it can't be used on Plandex Cloud", modelId)
				log.Println(msg)
				http.Error(w, msg, http.StatusUnprocessableEntity)
				return
			}
		}

		mp := modelPack.ToModelPack()
		dbMp := db.ModelPackFromApi(&mp)
		dbMp.OrgId = auth.OrgId
		dbMp.Id = mp.Id

		toUpsertModelPacks = append(toUpsertModelPacks, dbMp)
	}

	toDeleteCustomModelIds := []string{}
	toDeleteCustomProviderIds := []string{}
	toDeleteModelPackIds := []string{}

	for _, model := range customModels {
		if _, exists := inputModelIds[string(model.ModelId)]; !exists {
			toDeleteCustomModelIds = append(toDeleteCustomModelIds, model.Id)
		}
	}

	for _, provider := range customProviders {
		if _, exists := inputProviderNames[provider.Name]; !exists {
			toDeleteCustomProviderIds = append(toDeleteCustomProviderIds, provider.Id)
		}
	}

	for _, modelPack := range customModelPacks {
		if _, exists := inputModelPackNames[modelPack.Name]; !exists {
			toDeleteModelPackIds = append(toDeleteModelPackIds, modelPack.Id)
		}
	}

	numChanges := len(toUpsertCustomModels) + len(toUpsertCustomProviders) + len(toUpsertModelPacks) + len(toDeleteCustomModelIds) + len(toDeleteCustomProviderIds) + len(toDeleteModelPackIds)
	if numChanges == 0 {
		w.WriteHeader(http.StatusOK)
		log.Println("No changes to custom models/providers/model packs")
		return
	}

	err = db.WithTx(r.Context(), "create custom models/providers/model packs", func(tx *sqlx.Tx) error {
		for _, model := range toUpsertCustomModels {
			if err := db.UpsertCustomModel(tx, model); err != nil {
				return fmt.Errorf("error creating custom model: %w", err)
			}
		}

		for _, provider := range toUpsertCustomProviders {
			if err := db.UpsertCustomProvider(tx, provider); err != nil {
				return fmt.Errorf("error creating custom provider: %w", err)
			}
		}

		for _, modelPack := range toUpsertModelPacks {
			if err := db.UpsertModelPack(tx, modelPack); err != nil {
				return fmt.Errorf("error creating model pack: %w", err)
			}
		}

		if len(toDeleteCustomModelIds) > 0 {
			if err := db.DeleteCustomModels(tx, auth.OrgId, toDeleteCustomModelIds); err != nil {
				return fmt.Errorf("error deleting custom models: %w", err)
			}
		}

		if len(toDeleteCustomProviderIds) > 0 {
			if err := db.DeleteCustomProviders(tx, auth.OrgId, toDeleteCustomProviderIds); err != nil {
				return fmt.Errorf("error deleting custom providers: %w", err)
			}
		}

		if len(toDeleteModelPackIds) > 0 {
			if err := db.DeleteModelPacks(tx, auth.OrgId, toDeleteModelPackIds); err != nil {
				return fmt.Errorf("error deleting model packs: %w", err)
			}
		}

		return nil
	})

	if err != nil {
		log.Printf("Error: %v\n", err)
		http.Error(w, "Failed to import custom models/providers/model packs: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusOK)

	log.Println("Successfully imported custom models/providers/model packs")
}

func GetCustomModelHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetCustomModelHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	id := mux.Vars(r)["modelId"]

	res, err := db.GetCustomModel(auth.OrgId, id)
	if err != nil {
		log.Printf("Error fetching custom model: %v\n", err)
		http.Error(w, "Failed to fetch custom model: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if res == nil {
		http.Error(w, "Custom model not found", http.StatusNotFound)
		return
	}

	err = json.NewEncoder(w).Encode(res.ToApi())
	if err != nil {
		log.Printf("Error encoding custom model: %v\n", err)
		http.Error(w, fmt.Sprintf("Error encoding custom model: %v", err), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully fetched custom model")
}

func ListCustomModelsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListCustomModelsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !requireMinClientVersion(w, r, CustomModelsMinClientVersion) {
		return
	}

	models, err := db.ListCustomModels(auth.OrgId)
	if err != nil {
		log.Printf("Error fetching custom models: %v\n", err)
		http.Error(w, "Failed to fetch custom models: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiList []*shared.CustomModel
	for _, m := range models {
		apiList = append(apiList, m.ToApi())
	}

	err = json.NewEncoder(w).Encode(apiList)
	if err != nil {
		log.Printf("Error encoding custom models: %v\n", err)
		http.Error(w, fmt.Sprintf("Error encoding custom models: %v", err), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully fetched custom models")
}

func GetCustomProviderHandler(w http.ResponseWriter, r *http.Request) {
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	id := mux.Vars(r)["providerId"]

	res, err := db.GetCustomProvider(auth.OrgId, id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	err = json.NewEncoder(w).Encode(res.ToApi())
	if err != nil {
		log.Printf("Error encoding custom provider: %v\n", err)
		http.Error(w, fmt.Sprintf("Error encoding custom provider: %v", err), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully fetched custom provider")
}

func ListCustomProvidersHandler(w http.ResponseWriter, r *http.Request) {
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if os.Getenv("IS_CLOUD") != "" {
		http.Error(w, "Custom model providers are not supported on Plandex Cloud", http.StatusBadRequest)
		return
	}

	list, err := db.ListCustomProviders(auth.OrgId)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	var apiList []*shared.CustomProvider
	for _, p := range list {
		apiList = append(apiList, p.ToApi())
	}

	err = json.NewEncoder(w).Encode(apiList)
	if err != nil {
		log.Printf("Error encoding custom providers: %v\n", err)
		http.Error(w, fmt.Sprintf("Error encoding custom providers: %v", err), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully fetched custom providers")
}

func CreateModelPackHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateModelPackHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !requireMinClientVersion(w, r, CustomModelsMinClientVersion) {
		return
	}

	http.Error(w, "Use POST /custom_models instead to create model packs", http.StatusBadRequest)
}

func UpdateModelPackHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateModelPackHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !requireMinClientVersion(w, r, CustomModelsMinClientVersion) {
		return
	}

	http.Error(w, "Use POST /custom_models instead to update model packs", http.StatusBadRequest)
}

func ListModelPacksHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListModelPacksHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !requireMinClientVersion(w, r, CustomModelsMinClientVersion) {
		return
	}

	sets, err := db.ListModelPacks(auth.OrgId)
	if err != nil {
		log.Printf("Error fetching model packs: %v\n", err)
		http.Error(w, "Failed to fetch model packs: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiPacks []*shared.ModelPack

	for _, mp := range sets {
		apiPacks = append(apiPacks, mp.ToApi())
	}

	json.NewEncoder(w).Encode(apiPacks)

	log.Println("Successfully fetched model packs")
}


================================================
FILE: app/server/handlers/org_helpers.go
================================================
package handlers

import (
	"log"
	"plandex-server/db"
	"plandex-server/hooks"

	shared "plandex-shared"
)

func toApiOrgs(orgs []*db.Org) ([]*shared.Org, *shared.ApiError) {
	var orgIds []string
	for _, org := range orgs {
		orgIds = append(orgIds, org.Id)
	}

	hookRes, apiErr := hooks.ExecHook(hooks.GetApiOrgs, hooks.HookParams{
		GetApiOrgIds: orgIds,
	})

	if apiErr != nil {
		log.Printf("Error getting integrated models mode by org id: %v\n", apiErr)
		return nil, apiErr
	}

	var apiOrgs []*shared.Org
	for _, org := range orgs {
		if hookRes.ApiOrgsById != nil {
			hookApiOrg := hookRes.ApiOrgsById[org.Id]
			apiOrgs = append(apiOrgs, hookApiOrg)
		} else {
			apiOrgs = append(apiOrgs, org.ToApi())
		}
	}

	return apiOrgs, nil
}

func getApiOrg(orgId string) (*shared.Org, *shared.ApiError) {
	org, err := db.GetOrg(orgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		return nil, &shared.ApiError{
			Type: shared.ApiErrorTypeOther,
			Msg:  "Error getting org",
		}
	}

	hookRes, apiErr := hooks.ExecHook(hooks.GetApiOrgs, hooks.HookParams{
		GetApiOrgIds: []string{org.Id},
	})

	if apiErr != nil {
		log.Printf("Error getting integrated models mode by org id: %v\n", apiErr)
		return nil, apiErr
	}

	if hookRes.ApiOrgsById != nil {
		return hookRes.ApiOrgsById[org.Id], nil
	}

	return org.ToApi(), nil
}


================================================
FILE: app/server/handlers/orgs.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/hooks"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
)

func ListOrgsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListOrgsHandler")

	auth := Authenticate(w, r, false)
	if auth == nil {
		return
	}

	orgs, err := db.GetAccessibleOrgsForUser(auth.User)

	if err != nil {
		log.Printf("Error listing orgs: %v\n", err)
		http.Error(w, "Error listing orgs: "+err.Error(), http.StatusInternalServerError)
		return
	}

	apiOrgs, apiErr := toApiOrgs(orgs)

	if apiErr != nil {
		log.Printf("Error converting orgs to api: %v\n", apiErr)
		writeApiError(w, *apiErr)
		return
	}

	bytes, err := json.Marshal(apiOrgs)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully listed orgs")

	w.Write(bytes)
}

func CreateOrgHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateOrgHandler")

	if os.Getenv("IS_CLOUD") != "" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Plandex Cloud orgs can only be created by starting a trial",
		})
		return
	}

	auth := Authenticate(w, r, false)
	if auth == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.CreateOrgRequest
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiErr *shared.ApiError
	var org *db.Org
	err = db.WithTx(r.Context(), "create org", func(tx *sqlx.Tx) error {
		var err error
		var domain *string
		if req.AutoAddDomainUsers {
			if shared.IsEmailServiceDomain(auth.User.Domain) {
				log.Printf("Invalid domain: %v\n", auth.User.Domain)
				return fmt.Errorf("invalid domain: %v", auth.User.Domain)
			}

			domain = &auth.User.Domain
		}

		// create a new org
		org, err = db.CreateOrg(&req, auth.AuthToken.UserId, domain, tx)

		if err != nil {
			log.Printf("Error creating org: %v\n", err)
			return fmt.Errorf("error creating org: %v", err)
		}

		if org.AutoAddDomainUsers && org.Domain != nil {
			err = db.AddOrgDomainUsers(org.Id, *org.Domain, tx)

			if err != nil {
				log.Printf("Error adding org domain users: %v\n", err)
				return fmt.Errorf("error adding org domain users: %v", err)
			}
		}

		_, apiErr = hooks.ExecHook(hooks.CreateOrg, hooks.HookParams{
			Auth: auth,
			Tx:   tx,

			CreateOrgHookRequestParams: &hooks.CreateOrgHookRequestParams{
				Org: org,
			},
		})

		return nil
	})

	if apiErr != nil {
		writeApiError(w, *apiErr)
		return
	}

	if err != nil {
		log.Printf("Error creating org: %v\n", err)
		http.Error(w, "Error creating org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	resp := shared.CreateOrgResponse{
		Id: org.Id,
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = SetAuthCookieIfBrowser(w, r, auth.User, "", org.Id)
	if err != nil {
		log.Printf("Error setting auth cookie: %v\n", err)
		http.Error(w, "Error setting auth cookie: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created org")

	w.Write(bytes)
}

func GetOrgSessionHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetOrgSessionHandler")

	auth := Authenticate(w, r, true)

	if auth == nil {
		return
	}

	org, apiErr := getApiOrg(auth.OrgId)

	if apiErr != nil {
		log.Printf("Error converting org to api: %v\n", apiErr)
		writeApiError(w, *apiErr)
		return
	}

	bytes, err := json.Marshal(org)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = SetAuthCookieIfBrowser(w, r, auth.User, "", org.Id)
	if err != nil {
		log.Printf("Error setting auth cookie: %v\n", err)
		http.Error(w, "Error setting auth cookie: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("Successfully got org session")
}

func ListOrgRolesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListOrgRolesHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't list org roles",
		})
		return
	}

	if !auth.HasPermission(shared.PermissionListOrgRoles) {
		log.Println("User cannot list org roles")
		http.Error(w, "User cannot list org roles", http.StatusForbidden)
		return
	}

	roles, err := db.ListOrgRoles(auth.OrgId)

	if err != nil {
		log.Printf("Error listing org roles: %v\n", err)
		http.Error(w, "Error listing org roles: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiRoles []*shared.OrgRole
	for _, role := range roles {
		apiRoles = append(apiRoles, role.ToApi())
	}

	bytes, err := json.Marshal(apiRoles)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully listed org roles")

	w.Write(bytes)
}


================================================
FILE: app/server/handlers/plan_config.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func GetPlanConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetPlanConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	config, err := db.GetPlanConfig(planId)
	if err != nil {
		log.Println("Error getting plan config: ", err)
		http.Error(w, "Error getting plan config", http.StatusInternalServerError)
		return
	}

	res := shared.GetPlanConfigResponse{
		Config: config,
	}

	bytes, err := json.Marshal(res)
	if err != nil {
		log.Println("Error marshalling response: ", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
	log.Println("GetPlanConfigHandler processed successfully")
}

func UpdatePlanConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdatePlanConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	var req shared.UpdatePlanConfigRequest
	err := json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		log.Println("Error decoding request body: ", err)
		http.Error(w, "Error decoding request body", http.StatusBadRequest)
		return
	}

	err = db.StorePlanConfig(planId, req.Config)
	if err != nil {
		log.Println("Error storing plan config: ", err)
		http.Error(w, "Error storing plan config", http.StatusInternalServerError)
		return
	}

	log.Println("UpdatePlanConfigHandler processed successfully")
}

func GetDefaultPlanConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetDefaultPlanConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	config, err := db.GetDefaultPlanConfig(auth.User.Id)
	if err != nil {
		log.Println("Error getting default plan config: ", err)
		http.Error(w, "Error getting default plan config", http.StatusInternalServerError)
		return
	}

	res := shared.GetDefaultPlanConfigResponse{
		Config: config,
	}

	bytes, err := json.Marshal(res)
	if err != nil {
		log.Println("Error marshalling response: ", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
	log.Println("GetDefaultPlanConfigHandler processed successfully")
}

func UpdateDefaultPlanConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateDefaultPlanConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	var req shared.UpdateDefaultPlanConfigRequest
	err := json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		log.Println("Error decoding request body: ", err)
		http.Error(w, "Error decoding request body", http.StatusBadRequest)
		return
	}

	err = db.WithTx(r.Context(), "update default plan config", func(tx *sqlx.Tx) error {

		err := db.StoreDefaultPlanConfig(auth.User.Id, req.Config, tx)
		if err != nil {
			log.Println("Error storing default plan config: ", err)
			return fmt.Errorf("error storing default plan config: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Println("Error updating default plan config: ", err)
		http.Error(w, "Error updating default plan config", http.StatusInternalServerError)
		return
	}

	log.Println("UpdateDefaultPlanConfigHandler processed successfully")
}


================================================
FILE: app/server/handlers/plans_changes.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"
	modelPlan "plandex-server/model/plan"
	"time"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func CurrentPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CurrentPlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	sha := vars["sha"]

	log.Println("planId: ", planId, "branch: ", branch, "sha: ", sha)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	// Just in case this was sent immediately after a stream finished, wait a little before locking to allow for cleanup
	time.Sleep(100 * time.Millisecond)

	ctx, cancel := context.WithCancel(r.Context())
	scope := db.LockScopeRead
	if sha != "" {
		scope = db.LockScopeWrite
	}
	log.Printf("locking with scope: %s", scope)

	var planState *shared.CurrentPlanState

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Scope:    scope,
		Ctx:      ctx,
		CancelFn: cancel,
		Reason:   "get current plan state",
	}, func(repo *db.GitRepo) error {
		var err error
		if sha != "" {
			err = repo.GitCheckoutSha(sha)
			if err != nil {
				return fmt.Errorf("error checking out sha: %v", err)
			}

			defer func() {
				checkoutErr := repo.GitCheckoutBranch(branch)
				if checkoutErr != nil {
					log.Printf("Error checking out branch: %v\n", checkoutErr)
				}
			}()
		}

		planState, err = db.GetCurrentPlanState(db.CurrentPlanStateParams{
			OrgId:  auth.OrgId,
			PlanId: planId,
		})

		if err != nil {
			return fmt.Errorf("error getting current plan state: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error getting current plan state: %v\n", err)
		http.Error(w, "Error getting current plan state: "+err.Error(), http.StatusInternalServerError)
		return
	}

	jsonBytes, err := json.Marshal(planState)

	if err != nil {
		log.Printf("Error marshalling plan state: %v\n", err)
		http.Error(w, "Error marshalling plan state: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully retrieved current plan state")

	w.Write(jsonBytes)
}

func ApplyPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ApplyPlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId, "branch: ", branch)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	var err error

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.ApplyPlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	// Just in case this was sent immediately after a stream finished, wait a little before locking to allow for cleanup
	time.Sleep(100 * time.Millisecond)

	ctx, cancel := context.WithCancel(r.Context())

	var settings *shared.PlanSettings
	var currentPlanParams db.CurrentPlanStateParams
	var currentPlan *shared.CurrentPlanState

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		var err error
		settings, err = db.GetPlanSettings(plan)
		if err != nil {
			return fmt.Errorf("error getting plan settings: %v", err)
		}

		currentPlanParams, err = db.GetFullCurrentPlanStateParams(auth.OrgId, planId)
		if err != nil {
			return fmt.Errorf("error getting current plan state params: %v", err)
		}

		currentPlan, err = db.GetCurrentPlanState(currentPlanParams)
		if err != nil {
			return fmt.Errorf("error getting current plan state: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error getting current plan state: %v\n", err)
		http.Error(w, "Error getting current plan state: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("ApplyPlanHandler: Got current plan state:", currentPlan != nil)

	res := initClients(
		initClientsParams{
			w:           w,
			auth:        auth,
			apiKeys:     requestBody.ApiKeys,
			openAIOrgId: requestBody.OpenAIOrgId,
			authVars:    requestBody.AuthVars,
			plan:        plan,
			settings:    settings,
		},
	)

	clients := res.clients
	authVars := res.authVars

	commitMsg, err := modelPlan.GenCommitMsgForPendingResults(modelPlan.GenCommitMsgForPendingResultsParams{
		Auth:      auth,
		Plan:      plan,
		Clients:   clients,
		Settings:  settings,
		Current:   currentPlan,
		AuthVars:  authVars,
		SessionId: requestBody.SessionId,
		Ctx:       r.Context(),
	})

	if err != nil {
		log.Printf("Error generating commit message: %v\n", err)
		http.Error(w, "Error generating commit message: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branch,
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		return db.ApplyPlan(repo, ctx, db.ApplyPlanParams{
			OrgId:                  auth.OrgId,
			UserId:                 auth.User.Id,
			BranchName:             branch,
			Plan:                   plan,
			CurrentPlanState:       currentPlan,
			CurrentPlanStateParams: &currentPlanParams,
			CommitMsg:              commitMsg,
		})
	})

	if err != nil {
		log.Printf("Error applying plan: %v\n", err)
		http.Error(w, "Error applying plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write([]byte(commitMsg))

	log.Println("Successfully applied plan", planId)
}

func RejectAllChangesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RejectAllChangesHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branch,
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		err := db.RejectAllResults(auth.OrgId, planId)
		if err != nil {
			return err
		}

		err = repo.GitAddAndCommit(branch, "🚫 Rejected all pending changes")
		if err != nil {
			return fmt.Errorf("error committing rejected changes: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error rejecting all changes: %v\n", err)
		http.Error(w, "Error rejecting all changes: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully rejected all changes for plan", planId)
}

func RejectFileHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RejectFileHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	var req shared.RejectFileRequest
	err := json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		log.Printf("Error decoding request: %v\n", err)
		http.Error(w, "Error decoding request: "+err.Error(), http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branch,
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		err = db.RejectPlanFile(auth.OrgId, planId, req.FilePath, time.Now())
		if err != nil {
			return err
		}

		err = repo.GitAddAndCommit(branch, fmt.Sprintf("🚫 Rejected pending changes to file: %s", req.FilePath))
		if err != nil {
			return fmt.Errorf("error committing rejected changes: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error rejecting result: %v\n", err)
		http.Error(w, "Error rejecting result: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully rejected plan file", req.FilePath)
}

func RejectFilesHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RejectFilesHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	var req shared.RejectFilesRequest
	err := json.NewDecoder(r.Body).Decode(&req)
	if err != nil {
		log.Printf("Error decoding request: %v\n", err)
		http.Error(w, "Error decoding request: "+err.Error(), http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branch,
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		err = db.RejectPlanFiles(auth.OrgId, planId, req.Paths, time.Now())
		if err != nil {
			return err
		}

		msg := "🚫 Rejected pending changes to file"
		if len(req.Paths) > 1 {
			msg += "s"
		}
		msg += ":"

		for _, path := range req.Paths {
			msg += fmt.Sprintf("\n • %s", path)
		}

		err = repo.GitAddAndCommit(branch, msg)
		if err != nil {
			return fmt.Errorf("error committing rejected changes: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error rejecting result: %v\n", err)
		http.Error(w, "Error rejecting result: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully rejected plan files", req.Paths)
}

func ArchivePlanHandler(w http.ResponseWriter, r *http.Request) {
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	log.Println("Received request for ArchivePlanHandler")

	vars := mux.Vars(r)
	planId := vars["planId"]
	log.Println("planId: ", planId)

	plan := authorizePlanArchive(w, planId, auth)

	if plan == nil {
		return
	}

	if plan.ArchivedAt != nil {
		log.Println("Plan already archived")
		http.Error(w, "Plan already archived", http.StatusBadRequest)
		return
	}

	res, err := db.Conn.Exec("UPDATE plans SET archived_at = NOW() WHERE id = $1", planId)

	if err != nil {
		log.Printf("Error archiving plan: %v\n", err)
		http.Error(w, "Error archiving plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		log.Printf("Error getting rows affected: %v\n", err)
		http.Error(w, "Error getting rows affected: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if rowsAffected == 0 {
		log.Println("Plan not found")
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	log.Println("Successfully archived plan", planId)
}

func UnarchivePlanHandler(w http.ResponseWriter, r *http.Request) {
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	log.Println("Received request for UnarchivePlanHandler")

	vars := mux.Vars(r)
	planId := vars["planId"]
	log.Println("planId: ", planId)

	plan := authorizePlanArchive(w, planId, auth)

	if plan == nil {
		return
	}

	if plan.ArchivedAt == nil {
		log.Println("Plan isn't archived")
		http.Error(w, "Plan isn't archived", http.StatusBadRequest)
		return
	}

	res, err := db.Conn.Exec("UPDATE plans SET archived_at = NULL WHERE id = $1", planId)

	if err != nil {
		log.Printf("Error archiving plan: %v\n", err)
		http.Error(w, "Error archiving plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		log.Printf("Error getting rows affected: %v\n", err)
		http.Error(w, "Error getting rows affected: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if rowsAffected == 0 {
		log.Println("Plan not found")
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	log.Println("Successfully unarchived plan", planId)
}

func GetPlanDiffsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetPlanDiffs")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	plain := r.URL.Query().Get("plain") == "true"

	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())
	var diffs string

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		var err error
		diffs, err = db.GetPlanDiffs(auth.OrgId, planId, plain)
		if err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		log.Printf("Error getting plan diffs: %v\n", err)
		http.Error(w, "Error getting plan diffs: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Printf("diffs: %s", diffs)

	w.Write([]byte(diffs))

	log.Println("Successfully retrieved plan diffs")
}


================================================
FILE: app/server/handlers/plans_context.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func ListContextHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListContextHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())
	var dbContexts []*db.Context

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "list contexts",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.GetPlanContexts(auth.OrgId, planId, false, false)
		if err != nil {
			return err
		}

		dbContexts = res

		return nil
	})

	if err != nil {
		log.Printf("Error getting contexts: %v\n", err)
		http.Error(w, "Error getting contexts: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var apiContexts []*shared.Context

	for _, dbContext := range dbContexts {
		apiContexts = append(apiContexts, dbContext.ToApi())
	}

	bytes, err := json.Marshal(apiContexts)

	if err != nil {
		log.Printf("Error marshalling contexts: %v\n", err)
		http.Error(w, "Error marshalling contexts: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}

func GetContextBodyHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetContextBodyHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	contextId := vars["contextId"]
	log.Println("planId:", planId, "branch:", branch, "contextId:", contextId)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	var dbContexts []*db.Context
	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "get context body",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.GetPlanContexts(auth.OrgId, planId, true, false)
		if err != nil {
			return err
		}

		dbContexts = res

		return nil
	})

	if err != nil {
		log.Printf("Error getting contexts: %v\n", err)
		http.Error(w, "Error getting contexts: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var targetContext *db.Context
	for _, dbContext := range dbContexts {
		if dbContext.Id == contextId {
			targetContext = dbContext
			break
		}
	}

	if targetContext == nil {
		http.Error(w, "Context not found", http.StatusNotFound)
		return
	}

	response := shared.GetContextBodyResponse{
		Body: targetContext.Body,
	}

	bytes, err := json.Marshal(response)
	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}

func LoadContextHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for LoadContextHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branchName := vars["branch"]
	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.LoadContextRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	res, _ := loadContexts(loadContextsParams{
		w:          w,
		r:          r,
		auth:       auth,
		loadReq:    &requestBody,
		plan:       plan,
		branchName: branchName,
	})

	if res == nil {
		return
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed LoadContextHandler request")

	w.Write(bytes)
}

func UpdateContextHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateContextHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branchName := vars["branch"]
	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.UpdateContextRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	var updateRes *shared.UpdateContextResponse
	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branchName,
		Reason:         "update contexts",
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		var err error
		updateRes, err = db.UpdateContexts(db.UpdateContextsParams{
			Req:        &requestBody,
			OrgId:      auth.OrgId,
			Plan:       plan,
			BranchName: branchName,
		})

		if err != nil {
			return err
		}

		if updateRes.MaxTokensExceeded {
			return nil
		}

		err = repo.GitAddAndCommit(branchName, updateRes.Msg)

		if err != nil {
			return fmt.Errorf("error committing changes: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error error updating contexts: %v\n", err)
		http.Error(w, "Error error updating contexts: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if updateRes.MaxTokensExceeded {
		log.Printf("The total number of tokens (%d) exceeds the maximum allowed (%d)", updateRes.TotalTokens, updateRes.MaxTokens)
		bytes, err := json.Marshal(updateRes)

		if err != nil {
			log.Printf("Error marshalling response: %v\n", err)
			http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
			return
		}

		w.Write(bytes)
		return
	}

	bytes, err := json.Marshal(updateRes)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed UpdateContextHandler request")

	w.Write(bytes)
}

func DeleteContextHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for DeleteContextHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branchName := vars["branch"]
	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return
	}

	branch, err := db.GetDbBranch(planId, branchName)

	if err != nil {
		log.Printf("Error getting branch: %v\n", err)
		http.Error(w, "Error getting branch: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.DeleteContextRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	var dbContexts []*db.Context
	var toRemove []*db.Context
	var commitMsg string
	removeTokens := 0
	var toRemoveApiContexts []*shared.Context

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:          auth.OrgId,
		UserId:         auth.User.Id,
		PlanId:         planId,
		Branch:         branchName,
		Reason:         "delete contexts",
		Scope:          db.LockScopeWrite,
		Ctx:            ctx,
		CancelFn:       cancel,
		ClearRepoOnErr: true,
	}, func(repo *db.GitRepo) error {
		var err error
		dbContexts, err = db.GetPlanContexts(auth.OrgId, planId, false, false)

		if err != nil {
			return fmt.Errorf("error getting contexts: %v", err)
		}

		for _, dbContext := range dbContexts {
			if _, ok := requestBody.Ids[dbContext.Id]; ok {
				toRemove = append(toRemove, dbContext)
			}
		}

		err = db.ContextRemove(auth.OrgId, planId, toRemove)

		if err != nil {
			return fmt.Errorf("error removing contexts: %v", err)
		}

		for _, dbContext := range toRemove {
			toRemoveApiContexts = append(toRemoveApiContexts, dbContext.ToApi())
			removeTokens += dbContext.NumTokens
		}

		commitMsg = shared.SummaryForRemoveContext(toRemoveApiContexts, branch.ContextTokens) + "\n\n" + shared.TableForRemoveContext(toRemoveApiContexts)

		err = repo.GitAddAndCommit(branchName, commitMsg)

		if err != nil {
			return fmt.Errorf("error committing changes: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error deleting contexts: %v\n", err)
		http.Error(w, "Error deleting contexts: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = db.AddPlanContextTokens(planId, branchName, -removeTokens)
	if err != nil {
		log.Printf("Error updating plan tokens: %v\n", err)
		http.Error(w, "Error updating plan tokens: "+err.Error(), http.StatusInternalServerError)
		return
	}

	res := shared.DeleteContextResponse{
		TokensRemoved: removeTokens,
		TotalTokens:   branch.ContextTokens - removeTokens,
		Msg:           commitMsg,
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully deleted contexts")

	w.Write(bytes)
}


================================================
FILE: app/server/handlers/plans_convo.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func ListConvoHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for ListConvoHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	var err error
	var convoMessages []*db.ConvoMessage

	ctx, cancel := context.WithCancel(r.Context())

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "list convo",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.GetPlanConvo(auth.OrgId, planId)

		if err != nil {
			return err
		}

		convoMessages = res

		return nil
	})

	if err != nil {
		log.Println("Error getting plan convo: ", err)
		http.Error(w, "Error getting plan convo: "+err.Error(), http.StatusInternalServerError)
		return
	}

	apiConvoMessages := make([]*shared.ConvoMessage, len(convoMessages))
	for i, convoMessage := range convoMessages {
		apiConvoMessages[i] = convoMessage.ToApi()
	}

	bytes, err := json.Marshal(apiConvoMessages)

	if err != nil {
		log.Println("Error marshalling plan convo: ", err)
		http.Error(w, "Error marshalling plan convo: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed request for ListConvoHandler")
	w.Write(bytes)

}

func GetPlanStatusHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for GetPlanStatusHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	var convoMessages []*db.ConvoMessage
	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "get plan status",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.GetPlanConvo(auth.OrgId, planId)

		if err != nil {
			return err
		}

		convoMessages = res

		return nil
	})

	if err != nil {
		log.Println("Error getting plan convo: ", err)
		http.Error(w, "Error getting plan convo: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if len(convoMessages) == 0 {
		log.Println("No messages found for plan")
		return
	}

	convoMessageIds := make([]string, len(convoMessages))
	for i, convoMessage := range convoMessages {
		convoMessageIds[i] = convoMessage.Id
	}

	summmaries, err := db.GetPlanSummaries(planId, convoMessageIds)

	if err != nil {
		log.Println("Error getting plan summaries: ", err)
		http.Error(w, "Error getting plan summaries: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if len(summmaries) == 0 {
		log.Println("No summaries found for plan")
		return
	}

	latestSummary := summmaries[len(summmaries)-1]

	bytes := []byte(latestSummary.Summary)

	w.Write(bytes)

	log.Println("Successfully processed request for GetPlanStatusHandler")
}


================================================
FILE: app/server/handlers/plans_crud.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/hooks"
	"runtime"
	"runtime/debug"
	"sort"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func CreatePlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreatePlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if !auth.HasPermission(shared.PermissionCreatePlan) {
		log.Println("User does not have permission to create a plan")
		http.Error(w, "User does not have permission to create a plan", http.StatusForbidden)
		return
	}

	vars := mux.Vars(r)
	projectId := vars["projectId"]

	log.Println("projectId: ", projectId)

	if !authorizeProject(w, projectId, auth) {
		return
	}

	_, apiErr := hooks.ExecHook(hooks.WillCreatePlan, hooks.HookParams{Auth: auth})
	if apiErr != nil {
		writeApiError(w, *apiErr)
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.CreatePlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	name := requestBody.Name
	if name == "" {
		name = "draft"
	}

	if name == "draft" {
		// delete any existing draft plans
		err = db.DeleteDraftPlans(auth.OrgId, projectId, auth.User.Id)

		if err != nil {
			log.Printf("Error deleting draft plans: %v\n", err)
			http.Error(w, "Error deleting draft plans: "+err.Error(), http.StatusInternalServerError)
			return
		}
	} else {
		i := 2
		originalName := name
		for {
			var count int
			err := db.Conn.Get(&count, "SELECT COUNT(*) FROM plans WHERE project_id = $1 AND owner_id = $2 AND name = $3", projectId, auth.User.Id, name)

			if err != nil {
				log.Printf("Error checking if plan exists: %v\n", err)
				http.Error(w, "Error checking if plan exists: "+err.Error(), http.StatusInternalServerError)
				return
			}

			if count == 0 {
				break
			}

			name = originalName + "." + fmt.Sprint(i)
			i++
		}
	}

	plan, err := db.CreatePlan(r.Context(), auth.OrgId, projectId, auth.User.Id, name)

	if err != nil {
		log.Printf("Error creating plan: %v\n", err)
		http.Error(w, "Error creating plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	resp := shared.CreatePlanResponse{
		Id:   plan.Id,
		Name: plan.Name,
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Printf("Successfully created plan: %v\n", plan)
}

func GetPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetPlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return
	}

	bytes, err := json.Marshal(plan)

	if err != nil {
		log.Printf("Error marshalling plan: %v\n", err)
		http.Error(w, "Error marshalling plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}

func RenamePlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RenamePlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return
	}

	var requestBody shared.RenamePlanRequest
	if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	if plan.OwnerId != auth.User.Id {
		log.Println("Only the plan owner can rename a plan")
		http.Error(w, "Only the plan owner can rename a plan", http.StatusForbidden)
		return
	}

	if requestBody.Name == "" {
		log.Println("Name cannot be empty")
		http.Error(w, "Name cannot be empty", http.StatusBadRequest)
		return
	}

	err := db.RenamePlan(planId, requestBody.Name, nil)

	if err != nil {
		log.Printf("Error renaming plan: %v\n", err)
		http.Error(w, "Error renaming plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully renamed plan")
}

func DeletePlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for DeletePlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]

	log.Println("planId: ", planId)

	plan := authorizePlanDelete(w, planId, auth)

	if plan == nil {
		return
	}

	if plan.OwnerId != auth.User.Id {
		log.Println("Only the plan owner can delete a plan")
		http.Error(w, "Only the plan owner can delete a plan", http.StatusForbidden)
		return
	}

	res, err := db.Conn.Exec("DELETE FROM plans WHERE id = $1", planId)

	if err != nil {
		log.Printf("Error deleting plan: %v\n", err)
		http.Error(w, "Error deleting plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	rowsAffected, err := res.RowsAffected()
	if err != nil {
		log.Printf("Error getting rows affected: %v\n", err)
		http.Error(w, "Error getting rows affected: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if rowsAffected == 0 {
		log.Println("Plan not found")
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	err = db.DeletePlanDir(auth.OrgId, planId)

	if err != nil {
		log.Printf("Error deleting plan dir: %v\n", err)
		http.Error(w, "Error deleting plan dir: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully deleted plan", planId)
}

func DeleteAllPlansHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for DeleteAllPlansHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	projectId := vars["projectId"]

	log.Println("projectId: ", projectId)

	if !authorizeProject(w, projectId, auth) {
		return
	}

	err := db.DeleteOwnerPlans(auth.OrgId, projectId, auth.User.Id)

	if err != nil {
		log.Printf("Error deleting plans: %v\n", err)
		http.Error(w, "Error deleting plans: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully deleted all plans")
}

func ListPlansHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListPlans")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	projectIds := r.URL.Query()["projectId"]

	log.Println("projectIds: ", projectIds)

	var apiPlans []*shared.Plan

	writePlans := func() {
		jsonBytes, err := json.Marshal(apiPlans)
		if err != nil {
			log.Printf("Error marshalling plans: %v\n", err)
			http.Error(w, "Error marshalling plans: "+err.Error(), http.StatusInternalServerError)
			return
		}

		w.Write(jsonBytes)
	}

	if len(projectIds) == 0 {
		writePlans()
		return
	}

	authorizedProjectIds := []string{}
	for _, projectId := range projectIds {
		if authorizeProjectOptional(w, projectId, auth, false) {
			authorizedProjectIds = append(authorizedProjectIds, projectId)
		}
	}

	if len(authorizedProjectIds) == 0 {
		writePlans()
		return
	}

	plans, err := db.ListOwnedPlans(authorizedProjectIds, auth.User.Id, false)

	if err != nil {
		log.Printf("Error listing plans: %v\n", err)
		http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
		return
	}

	for _, plan := range plans {
		apiPlans = append(apiPlans, plan.ToApi())
	}

	writePlans()
}

func ListArchivedPlansHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListArchivedPlansHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	projectIds := r.URL.Query()["projectId"]

	log.Println("projectIds: ", projectIds)

	var apiPlans []*shared.Plan

	writePlans := func() {
		jsonBytes, err := json.Marshal(apiPlans)
		if err != nil {
			log.Printf("Error marshalling plans: %v\n", err)
			http.Error(w, "Error marshalling plans: "+err.Error(), http.StatusInternalServerError)
			return
		}

		log.Println("Successfully processed ListArchivedPlansHandler request")

		w.Write(jsonBytes)
	}

	if len(projectIds) == 0 {
		writePlans()
		return
	}

	authorizedProjectIds := []string{}
	for _, projectId := range projectIds {
		if authorizeProjectOptional(w, projectId, auth, false) {
			authorizedProjectIds = append(authorizedProjectIds, projectId)
		}
	}

	plans, err := db.ListOwnedPlans(authorizedProjectIds, auth.User.Id, true)

	if err != nil {
		log.Printf("Error listing plans: %v\n", err)
		http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
		return
	}

	for _, plan := range plans {
		apiPlans = append(apiPlans, plan.ToApi())
	}

	writePlans()
}

func ListPlansRunningHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListPlansRunningHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	projectIds := r.URL.Query()["projectId"]
	includeRecent := r.URL.Query().Get("recent") == "true"

	log.Println("projectIds: ", projectIds)

	if len(projectIds) == 0 {
		log.Println("No project ids provided")
		http.Error(w, "No project ids provided", http.StatusBadRequest)
		return
	}

	for _, projectId := range projectIds {
		if !authorizeProject(w, projectId, auth) {
			return
		}
	}

	plans, err := db.ListOwnedPlans(projectIds, auth.User.Id, false)

	if err != nil {
		log.Printf("Error listing plans: %v\n", err)
		http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var planIds []string
	for _, plan := range plans {
		planIds = append(planIds, plan.Id)
	}

	errCh := make(chan error, 2)
	var streams []*db.ModelStream
	var branches []*db.Branch

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in ListPlansRunningHandler: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in ListPlansRunningHandler: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()

		var err error
		if includeRecent {
			streams, err = db.GetActiveOrRecentModelStreams(planIds)
		} else {
			streams, err = db.GetActiveModelStreams(planIds)
		}
		if err != nil {
			errCh <- fmt.Errorf("error getting recent model streams: %v", err)
			return
		}
		errCh <- nil
	}()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in ListPlansRunningHandler: %v\n%s", r, debug.Stack())
				errCh <- fmt.Errorf("panic in ListPlansRunningHandler: %v\n%s", r, debug.Stack())
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()
		var err error
		branches, err = db.ListBranchesForPlans(auth.OrgId, planIds)
		if err != nil {
			errCh <- fmt.Errorf("error getting branches: %v", err)
			return
		}
		errCh <- nil
	}()

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			log.Println(err)
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}

	res := shared.ListPlansRunningResponse{
		Branches:                   []*shared.Branch{},
		StreamStartedAtByBranchId:  map[string]time.Time{},
		StreamFinishedAtByBranchId: map[string]time.Time{},
		PlansById:                  map[string]*shared.Plan{},
		StreamIdByBranchId:         map[string]string{},
	}

	var apiPlansById = make(map[string]*shared.Plan)
	for _, plan := range plans {
		apiPlan := plan.ToApi()
		apiPlansById[plan.Id] = apiPlan
	}

	var apiBranchesByComposite = make(map[string]*shared.Branch)
	for _, branch := range branches {
		apiBranch := branch.ToApi()
		apiBranchesByComposite[branch.PlanId+"|"+branch.Name] = apiBranch
	}

	addedBranches := make(map[string]bool)
	for _, stream := range streams {
		branchComposite := stream.PlanId + "|" + stream.Branch
		apiBranch, ok := apiBranchesByComposite[branchComposite]
		if !ok {
			log.Printf("Stream %s has no branch\n", stream.Id)
			http.Error(w, "Stream has no branch", http.StatusInternalServerError)
			return
		}

		apiPlan, ok := apiPlansById[stream.PlanId]
		if !ok {
			log.Printf("Stream %s has no plan\n", stream.Id)
			http.Error(w, "Stream has no plan", http.StatusInternalServerError)
			return
		}

		if !addedBranches[branchComposite] {
			res.Branches = append(res.Branches, apiBranch)
			addedBranches[branchComposite] = true
		}

		res.StreamStartedAtByBranchId[apiBranch.Id] = stream.CreatedAt
		if stream.FinishedAt != nil {
			res.StreamFinishedAtByBranchId[apiBranch.Id] = *stream.FinishedAt
		}
		res.StreamIdByBranchId[apiBranch.Id] = stream.Id

		res.PlansById[stream.PlanId] = apiPlan
	}

	sort.Slice(res.Branches, func(i, j int) bool {
		iComposite := res.Branches[i].PlanId + "|" + res.Branches[i].Name
		jComposite := res.Branches[j].PlanId + "|" + res.Branches[j].Name
		iFinishedAt, iOk := res.StreamFinishedAtByBranchId[iComposite]
		jFinishedAt, jOk := res.StreamFinishedAtByBranchId[jComposite]
		iCreatedAt := res.StreamStartedAtByBranchId[iComposite]
		jCreatedAt := res.StreamStartedAtByBranchId[jComposite]

		if iOk && jOk {
			return iFinishedAt.Before(jFinishedAt) // Sort finished streams by finishedAt in ascending order.
		}
		if iOk {
			return false // Place i after j if i is finished and j is not.
		}
		if jOk {
			return true // Place i before j if i is not finished and j is.
		}
		return iCreatedAt.Before(jCreatedAt) // Sort by createdAt in ascending order if both are unfinished.
	})

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed ListPlansRunningHandler request")

	w.Write(bytes)
}

func GetCurrentBranchByPlanIdHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CurrentBranchByPlanIdHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	projectId := vars["projectId"]

	log.Println("projectId: ", projectId)

	if !authorizeProject(w, projectId, auth) {
		return
	}

	var req shared.GetCurrentBranchByPlanIdRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	plans, err := db.ListOwnedPlans([]string{projectId}, auth.User.Id, false)

	if err != nil {
		log.Printf("Error listing plans: %v\n", err)
		http.Error(w, "Error listing plans: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if len(plans) == 0 {
		log.Println("No plans found")
		http.Error(w, "No plans found", http.StatusNotFound)
		return
	}

	query := "SELECT * FROM branches WHERE "

	var orConditions []string
	var queryArgs []interface{}
	currentArg := 1
	for _, plan := range plans {
		branchName, ok := req.CurrentBranchByPlanId[plan.Id]

		if !ok {
			continue
		}

		orConditions = append(orConditions, fmt.Sprintf("(plan_id = $%d AND name = $%d)", currentArg, currentArg+1))
		queryArgs = append(queryArgs, plan.Id, branchName)

		currentArg += 2
	}

	query += "(" + strings.Join(orConditions, " OR ") + ") AND archived_at IS NULL AND deleted_at IS NULL"

	var branches []db.Branch
	err = db.Conn.Select(&branches, query, queryArgs...)

	if err != nil {
		log.Printf("Error getting branches: %v\n", err)
		http.Error(w, "Error getting branches: "+err.Error(), http.StatusInternalServerError)
		return
	}

	res := map[string]*shared.Branch{}
	for _, branch := range branches {
		res[branch.PlanId] = branch.ToApi()
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Printf("Error marshalling branches: %v\n", err)
		http.Error(w, "Error marshalling branches: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed GetCurrentBranchByPlanIdHandler request")

	w.Write(bytes)
}


================================================
FILE: app/server/handlers/plans_exec.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/host"
	modelPlan "plandex-server/model/plan"
	"plandex-server/notify"
	"plandex-server/types"
	"time"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func TellPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for TellPlanHandler", "ip:", host.Ip)

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId)

	plan := authorizePlanExecUpdate(w, planId, auth)
	if plan == nil {
		return
	}

	settings, err := db.GetPlanSettings(plan)
	if err != nil {
		log.Printf("Error getting plan settings: %v\n", err)
		http.Error(w, "Error getting plan settings", http.StatusInternalServerError)
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error reading request body: %v", err))
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer func() {
		log.Println("Closing request body")
		r.Body.Close()
	}()

	var requestBody shared.TellPlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error parsing request body: %v", err))
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	_, apiErr := hooks.ExecHook(hooks.WillTellPlan, hooks.HookParams{
		Auth: auth,
		Plan: plan,
	})
	if apiErr != nil {
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error executing will tell plan hook: %v", apiErr))
		writeApiError(w, *apiErr)
		return
	}

	orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
	if err != nil {
		log.Printf("Error getting org user config: %v\n", err)
		http.Error(w, "Error getting org user config", http.StatusInternalServerError)
		return
	}

	res := initClients(
		initClientsParams{
			w:             w,
			auth:          auth,
			apiKeys:       requestBody.ApiKeys,
			openAIOrgId:   requestBody.OpenAIOrgId,
			authVars:      requestBody.AuthVars,
			plan:          plan,
			settings:      settings,
			orgUserConfig: orgUserConfig,
		},
	)
	err = modelPlan.Tell(modelPlan.TellParams{
		Clients:  res.clients,
		Plan:     plan,
		Branch:   branch,
		Auth:     auth,
		Req:      &requestBody,
		AuthVars: res.authVars,
	})

	if err != nil {
		log.Printf("Error telling plan: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error telling plan: %v", err))
		http.Error(w, "Error telling plan: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if requestBody.ConnectStream {
		startResponseStream(r.Context(), w, auth, planId, branch, false)
	}

	log.Println("Successfully processed request for TellPlanHandler")
}

func BuildPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for BuildPlanHandler", "ip:", host.Ip)
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId)
	plan := authorizePlanExecUpdate(w, planId, auth)
	if plan == nil {
		return
	}

	settings, err := db.GetPlanSettings(plan)
	if err != nil {
		log.Printf("Error getting plan settings: %v\n", err)
		http.Error(w, "Error getting plan settings", http.StatusInternalServerError)
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error reading request body: %v", err))
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer func() {
		log.Println("Closing request body")
		r.Body.Close()
	}()

	var requestBody shared.BuildPlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error parsing request body: %v", err))
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
	if err != nil {
		log.Printf("Error getting org user config: %v\n", err)
		http.Error(w, "Error getting org user config", http.StatusInternalServerError)
		return
	}

	res := initClients(
		initClientsParams{
			w:             w,
			auth:          auth,
			apiKeys:       requestBody.ApiKeys,
			openAIOrgId:   requestBody.OpenAIOrgId,
			authVars:      requestBody.AuthVars,
			plan:          plan,
			settings:      settings,
			orgUserConfig: orgUserConfig,
		},
	)
	numBuilds, err := modelPlan.Build(modelPlan.BuildParams{
		Clients:       res.clients,
		AuthVars:      res.authVars,
		Plan:          plan,
		Branch:        branch,
		Auth:          auth,
		SessionId:     requestBody.SessionId,
		OrgUserConfig: orgUserConfig,
		Settings:      settings,
	})

	if err != nil {
		log.Printf("Error building plan: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error building plan: %v", err))
		http.Error(w, "Error building plan", http.StatusInternalServerError)
		return
	}

	if numBuilds == 0 {
		log.Println("No builds were executed")
		go notify.NotifyErr(notify.SeverityInfo, fmt.Errorf("no builds were executed"))
		http.Error(w, shared.NoBuildsErr, http.StatusNotFound)
		return
	}

	if requestBody.ConnectStream {
		startResponseStream(r.Context(), w, auth, planId, branch, false)
	}

	log.Println("Successfully processed request for BuildPlanHandler")
}

func ConnectPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ConnectPlanHandler", "ip:", host.Ip)

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId)
	log.Println("branch: ", branch)
	active := modelPlan.GetActivePlan(planId, branch)
	isProxy := r.URL.Query().Get("proxy") == "true"

	if active == nil {
		if isProxy {
			log.Println("No active plan on proxied request")
			go notify.NotifyErr(notify.SeverityInfo, fmt.Errorf("no active plan on proxied request"))
			http.Error(w, "No active plan", http.StatusNotFound)
			return
		}

		log.Println("No active plan -- proxying request")

		proxyActivePlanMethod(w, r, planId, branch, "connect")
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		log.Println("No auth")
		return
	}

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		log.Println("No plan")
		return
	}

	startResponseStream(r.Context(), w, auth, planId, branch, true)

	log.Println("Successfully processed request for ConnectPlanHandler")
}

func StopPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for StopPlanHandler", "ip:", host.Ip)

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId)
	log.Println("branch: ", branch)
	active := modelPlan.GetActivePlan(planId, branch)
	isProxy := r.URL.Query().Get("proxy") == "true"

	if active == nil {
		if isProxy {
			log.Println("No active plan on proxied request")
			http.Error(w, "No active plan", http.StatusNotFound)
			return
		}
		proxyActivePlanMethod(w, r, planId, branch, "stop")
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	log.Println("Sending stream aborted message to client")

	active.Stream(shared.StreamMessage{
		Type: shared.StreamMessageAborted,
	})

	// give some time for stream message to be processed before canceling
	log.Println("Sleeping for 100ms before canceling")
	time.Sleep(100 * time.Millisecond)

	var err error
	ctx, cancel := context.WithCancel(r.Context())

	// this is here to ensure that the plan is stopped even if the db operation fails
	defer func() {
		err = modelPlan.Stop(planId, branch, auth.User.Id, auth.OrgId)

		if err != nil {
			log.Printf("Error stopping plan: %v\n", err)
		}

		log.Println("Successfully processed request for StopPlanHandler")
	}()

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "stop plan",
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		log.Println("Stopping plan - storing partial reply")
		err = modelPlan.StorePartialReply(repo, planId, branch, auth.User.Id, auth.OrgId)
		return err
	})

	if err != nil {
		log.Printf("Error storing partial reply: %v\n", err)
		http.Error(w, "Error storing partial reply", http.StatusInternalServerError)
		return
	}
}

func RespondMissingFileHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RespondMissingFileHandler", "ip:", host.Ip)

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId)
	log.Println("branch: ", branch)
	isProxy := r.URL.Query().Get("proxy") == "true"

	active := modelPlan.GetActivePlan(planId, branch)
	if active == nil {
		if isProxy {
			log.Println("No active plan on proxied request")
			http.Error(w, "No active plan", http.StatusNotFound)
			return
		}

		proxyActivePlanMethod(w, r, planId, branch, "respond_missing_file")
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.RespondMissingFileRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	log.Println("missing file choice:", requestBody.Choice)

	if requestBody.Choice == shared.RespondMissingFileChoiceLoad {
		log.Println("loading missing file")
		res, dbContexts := loadContexts(loadContextsParams{
			w:    w,
			r:    r,
			auth: auth,
			loadReq: &shared.LoadContextRequest{
				&shared.LoadContextParams{
					ContextType: shared.ContextFileType,
					Name:        requestBody.FilePath,
					FilePath:    requestBody.FilePath,
					Body:        requestBody.Body,
				},
			},
			plan:       plan,
			branchName: branch,
			autoLoaded: true,
		})
		if res == nil {
			return
		}

		dbContext := dbContexts[0]

		log.Println("loaded missing file:", dbContext.FilePath)

		modelPlan.UpdateActivePlan(planId, branch, func(activePlan *types.ActivePlan) {
			if activePlan == nil {
				log.Println("Active plan is nil")
				http.Error(w, "Active plan is nil", http.StatusInternalServerError)
				return
			}
			activePlan.Contexts = append(activePlan.Contexts, dbContext)
			activePlan.ContextsByPath[dbContext.FilePath] = dbContext
		})
	}

	// This will resume model stream
	log.Println("Resuming model stream")
	active.MissingFileResponseCh <- requestBody.Choice

	log.Println("Successfully processed request for RespondMissingFileHandler")
}

func AutoLoadContextHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for AutoLoadContextHandler", "ip:", host.Ip)

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]
	log.Println("planId: ", planId)
	log.Println("branch: ", branch)

	isProxy := r.URL.Query().Get("proxy") == "true"

	active := modelPlan.GetActivePlan(planId, branch)
	if active == nil {
		if isProxy {
			log.Println("No active plan on proxied request")
			http.Error(w, "No active plan", http.StatusNotFound)
			return
		}

		proxyActivePlanMethod(w, r, planId, branch, "auto_load_context")
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	var err error
	defer func() {
		if err == nil {
			active.AutoLoadContextCh <- struct{}{}
		} else {
			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Error in AutoLoadContextHandler: " + err.Error(),
			}
		}
	}()

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.LoadContextRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	log.Println("AutoLoadContextHandler - loading contexts")

	var res *shared.LoadContextResponse
	var dbContexts []*db.Context
	if len(requestBody) > 0 {
		res, dbContexts = loadContexts(loadContextsParams{
			w:          w,
			r:          r,
			auth:       auth,
			loadReq:    &requestBody,
			plan:       plan,
			branchName: branch,
			autoLoaded: true,
		})
	}

	if res == nil {
		// the client will treat this as a no-op
		markdownRes := shared.LoadContextResponse{
			TokensAdded:       0,
			TotalTokens:       0,
			MaxTokensExceeded: false,
			MaxTokens:         0,
			Msg:               "",
		}

		bytes, err := json.Marshal(markdownRes)
		if err != nil {
			log.Printf("Error marshalling response: %v\n", err)
			http.Error(w, "Error marshalling response", http.StatusInternalServerError)
			return
		}

		w.Write(bytes)
		return
	}

	log.Println("AutoLoadContextHandler - updating active plan")

	modelPlan.UpdateActivePlan(planId, branch, func(activePlan *types.ActivePlan) {
		if activePlan == nil {
			log.Println("Active plan is nil")
			http.Error(w, "Active plan is nil", http.StatusInternalServerError)
			return
		}
		activePlan.Contexts = append(activePlan.Contexts, dbContexts...)
		for _, dbContext := range dbContexts {
			activePlan.ContextsByPath[dbContext.FilePath] = dbContext
		}
	})

	log.Println("AutoLoadContextHandler - updated active plan")

	var apiContexts []*shared.Context
	for _, dbContext := range dbContexts {
		apiContexts = append(apiContexts, dbContext.ToApi())
	}

	msg := shared.SummaryForLoadContext(apiContexts, res.TokensAdded, res.TotalTokens)
	msg += "\n\n" + shared.TableForLoadContext(apiContexts, true)

	markdownRes := shared.LoadContextResponse{
		TokensAdded:       res.TokensAdded,
		TotalTokens:       res.TotalTokens,
		MaxTokensExceeded: res.MaxTokensExceeded,
		MaxTokens:         res.MaxTokens,
		Msg:               msg,
	}

	bytes, err := json.Marshal(markdownRes)
	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("Successfully processed request for AutoLoadContextHandler")
}

func GetBuildStatusHandler(w http.ResponseWriter, r *http.Request) {
	// logs are too chatty on this function, uncomment if you need to debug
	// log.Println("Received request for GetBuildStatusHandler", "ip:", host.Ip)

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	isProxy := r.URL.Query().Get("proxy") == "true"

	active := modelPlan.GetActivePlan(planId, branch)
	if active == nil {
		if isProxy {
			log.Println("No active plan on proxied request")
			http.Error(w, "No active plan", http.StatusNotFound)
			return
		}

		proxyActivePlanMethod(w, r, planId, branch, "auto_load_context")
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	response := shared.GetBuildStatusResponse{
		BuiltFiles:       active.BuiltFiles,
		IsBuildingByPath: active.IsBuildingByPath,
	}

	bytes, err := json.Marshal(response)
	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	// log.Println("Successfully processed request for GetBuildStatusHandler")
}

func authorizePlanExecUpdate(w http.ResponseWriter, planId string, auth *types.ServerAuth) *db.Plan {
	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return nil
	}

	if plan.OwnerId != auth.User.Id && !auth.HasPermission(shared.PermissionUpdateAnyPlan) {
		log.Println("User does not have permission to update plan")
		http.Error(w, "User does not have permission to update plan", http.StatusForbidden)
		return nil
	}

	return plan
}


================================================
FILE: app/server/handlers/plans_versions.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"io"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
)

func ListLogsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListLogsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	var body string
	var shas []string

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "list logs",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		var err error
		body, shas, err = repo.GetGitCommitHistory(branch)
		if err != nil {
			return err
		}

		return nil
	})

	if err != nil {
		log.Println("Error getting logs: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	res := shared.LogResponse{
		Body: body,
		Shas: shas,
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Println("Error marshalling logs: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("Successfully processed request for ListLogsHandler")
}

func RewindPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RewindPlanHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId)

	if authorizePlan(w, planId, auth) == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.RewindPlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	ctx, cancel := context.WithCancel(r.Context())

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "rewind plan",
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		return repo.GitRewindToSha(branch, requestBody.Sha)
	})

	if err != nil {
		log.Println("Error rewinding plan: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	err = db.SyncPlanTokens(auth.OrgId, planId, branch)

	if err != nil {
		log.Println("Error syncing plan tokens: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	var sha string
	var latest string

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "get latest commit",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		sha, latest, err = repo.GetLatestCommit(branch)
		return err
	})

	if err != nil {
		log.Println("Error getting latest commit: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	res := shared.RewindPlanResponse{
		LatestSha:    sha,
		LatestCommit: latest,
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Println("Error marshalling response: ", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("Successfully processed request for RewindPlanHandler")
}


================================================
FILE: app/server/handlers/projects.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"plandex-server/db"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func CreateProjectHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateProjectHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.CreateProjectRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	if requestBody.Name == "" {
		log.Println("Received empty name field")
		http.Error(w, "name field is required", http.StatusBadRequest)
		return
	}

	var projectId string
	err = db.WithTx(r.Context(), "create project", func(tx *sqlx.Tx) error {
		var err error

		projectId, err = db.CreateProject(auth.OrgId, requestBody.Name, tx)

		if err != nil {
			log.Printf("Error creating project: %v\n", err)
			return fmt.Errorf("error creating project: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Printf("Error creating project: %v\n", err)
		http.Error(w, "Error creating project: "+err.Error(), http.StatusInternalServerError)
		return
	}

	resp := shared.CreateProjectResponse{
		Id: projectId,
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("Successfully created project", projectId)
}

func ListProjectsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for ListProjectsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	rows, err := db.Conn.Query("SELECT id, name FROM projects WHERE org_id = $1", auth.OrgId)

	if err != nil {
		log.Printf("Error listing projects: %v\n", err)
		http.Error(w, "Error listing projects: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var projects []shared.Project

	for rows.Next() {
		var project shared.Project
		err := rows.Scan(&project.Id, &project.Name)
		if err != nil {
			log.Printf("Error scanning project: %v\n", err)
			http.Error(w, "Error scanning project: "+err.Error(), http.StatusInternalServerError)
			return
		}
		projects = append(projects, project)
	}

	bytes, err := json.Marshal(projects)
	if err != nil {
		log.Printf("Error marshalling projects: %v\n", err)
		http.Error(w, "Error marshalling projects: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}

func ProjectSetPlanHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateProjectSetPlanHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	projectId := vars["projectId"]

	log.Println("projectId: ", projectId)

	if !authorizeProject(w, projectId, auth) {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.SetProjectPlanRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	if requestBody.PlanId == "" {
		log.Println("Received empty planId field")
		http.Error(w, "planId field is required", http.StatusBadRequest)
		return
	}

	// update statement here -- need auth / current user id

	log.Println("Successfully set project plan", projectId)
}

func RenameProjectHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for RenameProjectHandler")
	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	projectId := vars["projectId"]

	log.Println("projectId: ", projectId)

	if !authorizeProjectRename(w, projectId, auth) {
		return
	}

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var requestBody shared.RenameProjectRequest
	if err := json.Unmarshal(body, &requestBody); err != nil {
		log.Printf("Error parsing request body: %v\n", err)
		http.Error(w, "Error parsing request body", http.StatusBadRequest)
		return
	}

	if requestBody.Name == "" {
		log.Println("Received empty name field")
		http.Error(w, "name field is required", http.StatusBadRequest)
		return
	}

	res, err := db.Conn.Exec("UPDATE projects SET name = $1 WHERE id = $2", requestBody.Name, projectId)

	if err != nil {
		log.Printf("Error updating project: %v\n", err)
		http.Error(w, "Error updating project: "+err.Error(), http.StatusInternalServerError)
		return
	}

	rowsAffected, err := res.RowsAffected()

	if err != nil {
		log.Printf("Error getting rows affected: %v\n", err)
		http.Error(w, "Error getting rows affected: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if rowsAffected == 0 {
		log.Printf("Project not found: %v\n", projectId)
		http.Error(w, "Project not found: "+projectId, http.StatusNotFound)
		return
	}

	log.Println("Successfully renamed project", projectId)

}


================================================
FILE: app/server/handlers/proxy_helper.go
================================================
package handlers

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/host"
	"time"

	shared "plandex-shared"
)

func proxyActivePlanMethod(w http.ResponseWriter, r *http.Request, planId, branch, method string) {
	modelStream, err := db.GetActiveModelStream(planId, branch)

	if err != nil {
		log.Printf("Error getting active model stream: %v\n", err)
		http.Error(w, "Error getting active model stream", http.StatusInternalServerError)
		return
	}

	if modelStream == nil {
		log.Printf("No active model stream for plan %s\n", planId)
		http.Error(w, "No active model stream for plan", http.StatusNotFound)
		return
	}

	if modelStream.InternalIp == host.Ip {
		// No active plan for this plan or else we wouldn't be calling proxyActivePlanMethod -- set the model stream to finished because something went wrong
		err := db.SetModelStreamFinished(modelStream.Id)
		if err != nil {
			log.Printf("Error setting model stream %s to finished: %v\n", modelStream.Id, err)
		}

		err = db.SetPlanStatus(planId, branch, shared.PlanStatusError, "No active stream for plan")
		if err != nil {
			log.Printf("Error setting plan %s status to error: %v\n", planId, err)
		}

		log.Printf("No active plan for plan %s\n", planId)
		http.Error(w, "No active plan for plan", http.StatusNotFound)
		return
	} else {
		log.Printf("Forwarding request to %s\n", modelStream.InternalIp)
		proxyUrl := fmt.Sprintf("http://%s:%s/plans/%s/%s/%s", modelStream.InternalIp, os.Getenv("PORT"), planId, branch, method)
		proxyUrl += "?proxy=true"

		log.Printf("Proxy url: %s\n", proxyUrl)
		proxyRequest(w, r, proxyUrl)
		return
	}
}

func proxyRequest(w http.ResponseWriter, originalRequest *http.Request, url string) {
	client := &http.Client{
		Timeout: time.Second * 10,
	}

	// Create a new request based on the original request
	req, err := http.NewRequestWithContext(originalRequest.Context(), originalRequest.Method, url, originalRequest.Body)
	if err != nil {
		log.Printf("Error creating request for proxy: %v\n", err)
		http.Error(w, "Error creating request for proxy", http.StatusInternalServerError)
		return
	}

	// Copy the headers from the original request to the new request
	for name, headers := range originalRequest.Header {
		for _, h := range headers {
			req.Header.Add(name, h)
		}
	}

	// Copy the body from the original request to the new request if it's a POST or PUT
	if originalRequest.Method == http.MethodPost || originalRequest.Method == http.MethodPut {
		req.Body = originalRequest.Body
	}

	// Make the request
	resp, err := client.Do(req)
	if err != nil {
		log.Printf("Error forwarding request: %v\n", err)
		http.Error(w, "Error forwarding request", http.StatusInternalServerError)
		return
	}
	defer resp.Body.Close()

	// Copy the response headers and status code
	for name, headers := range resp.Header {
		for _, h := range headers {
			w.Header().Add(name, h)
		}
	}
	w.WriteHeader(resp.StatusCode)

	log.Printf("Proxy forwarded successfully with status code: %d\n", resp.StatusCode)

	// Copy the response body
	if _, err := io.Copy(w, resp.Body); err != nil {
		log.Printf("Error copying response body: %v\n", err)
		http.Error(w, "Error copying response body", http.StatusInternalServerError)
	}
}


================================================
FILE: app/server/handlers/sessions.go
================================================
package handlers

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/email"
	"strings"

	shared "plandex-shared"
)

func CreateEmailVerificationHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateEmailVerificationHandler")

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.CreateEmailVerificationRequest
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}
	req.Email = strings.ToLower(req.Email)

	var hasAccount bool
	if req.UserId == "" {
		user, err := db.GetUserByEmail(req.Email)

		if err != nil {
			log.Printf("Error getting user: %v\n", err)
			http.Error(w, "Error getting user: "+err.Error(), http.StatusInternalServerError)
			return
		}

		hasAccount = user != nil
	} else {
		hasAccount = true

		user, err := db.GetUser(req.UserId)

		if err != nil {
			log.Printf("Error getting user: %v\n", err)
			http.Error(w, "Error getting user: "+err.Error(), http.StatusInternalServerError)
			return
		}

		if user == nil {
			log.Printf("User not found for id: %v\n", req.UserId)
			http.Error(w, "User not found", http.StatusNotFound)
			return
		}

		if user.Email != req.Email {
			log.Printf("User email does not match for id: %v\n", req.UserId)
			http.Error(w, "User email does not match", http.StatusBadRequest)
			return
		}
	}

	if req.RequireUser && !hasAccount {
		log.Printf("User not found for email: %v\n", req.Email)
		http.Error(w, "User not found", http.StatusNotFound)
		return
	} else if req.RequireNoUser && hasAccount {
		log.Printf("User already exists for email: %v\n", req.Email)
		http.Error(w, "User already exists", http.StatusConflict)
		return
	}

	var res shared.CreateEmailVerificationResponse

	if !(os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1") {
		// create pin - 6 alphanumeric characters
		pinBytes, err := shared.GetRandomAlphanumeric(6)
		if err != nil {
			log.Printf("Error generating random pin: %v\n", err)
			http.Error(w, "Error generating random pin: "+err.Error(), http.StatusInternalServerError)
			return
		}

		// get sha256 hash of pin
		hashBytes := sha256.Sum256(pinBytes)
		pinHash := hex.EncodeToString(hashBytes[:])

		// create verification
		err = db.CreateEmailVerification(req.Email, req.UserId, pinHash)

		if err != nil {
			log.Printf("Error creating email verification: %v\n", err)
			http.Error(w, "Error creating email verification: "+err.Error(), http.StatusInternalServerError)
			return
		}

		err = email.SendVerificationEmail(req.Email, string(pinBytes))

		if err != nil {
			log.Printf("Error sending verification email: %v\n", err)
			http.Error(w, "Error sending verification email: "+err.Error(), http.StatusInternalServerError)
			return
		}

		res = shared.CreateEmailVerificationResponse{
			HasAccount: hasAccount,
		}
	} else {
		res = shared.CreateEmailVerificationResponse{
			HasAccount:  hasAccount,
			IsLocalMode: true,
		}
	}

	bytes, err := json.Marshal(res)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created email verification")

	w.Write(bytes)
}

func CheckEmailPinHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for VerifyEmailPinHandler")

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.VerifyEmailPinRequest
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}
	req.Email = strings.ToLower(req.Email)

	_, err = db.ValidateEmailVerification(req.Email, req.Pin)

	if err != nil {
		if err.Error() == db.InvalidOrExpiredPinError {
			http.Error(w, "Invalid or expired pin", http.StatusNotFound)
			return
		}

		log.Printf("Error validating email verification: %v\n", err)
		http.Error(w, "Error validating email verification: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully verified email pin")
}

// sign in codes allow users to authenticate between different clients
// like UI to CLI or vice versa
func CreateSignInCodeHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for CreateSignInCodeHandler")

	auth := Authenticate(w, r, true)

	if auth == nil {
		return
	}

	// create pin - 6 alphanumeric characters
	pinBytes, err := shared.GetRandomAlphanumeric(6)
	if err != nil {
		log.Printf("Error generating random pin: %v\n", err)
		http.Error(w, "Error generating random pin: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// get sha256 hash of pin
	hashBytes := sha256.Sum256(pinBytes)
	pinHash := hex.EncodeToString(hashBytes[:])

	err = db.CreateSignInCode(auth.User.Id, auth.OrgId, pinHash)

	if err != nil {
		log.Printf("Error creating sign in code: %v\n", err)
		http.Error(w, "Error creating sign in code: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully created sign in code")

	// return the pin as a response
	w.Write(pinBytes)
}

func SignInHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for SignInHandler")

	// read the request body
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.SignInRequest
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Validating and signing in")
	resp, err := ValidateAndSignIn(w, r, req)

	if err != nil {
		log.Printf("Error signing in: %v\n", err)
		http.Error(w, "Error signing in: "+err.Error(), http.StatusInternalServerError)
		return
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully signed in")

	w.Write(bytes)
}

func SignOutHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for SignOutHandler")

	auth := Authenticate(w, r, false)
	if auth == nil {
		return
	}

	_, err := db.Conn.Exec("UPDATE auth_tokens SET deleted_at = NOW() WHERE token_hash = $1", auth.AuthToken.TokenHash)

	if err != nil {
		log.Printf("Error deleting auth token: %v\n", err)
		http.Error(w, "Error deleting auth token: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = ClearAuthCookieIfBrowser(w, r)

	if err != nil {
		log.Printf("Error clearing auth cookie: %v\n", err)
		http.Error(w, "Error clearing auth cookie: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = ClearAccountFromCookies(w, r, auth.User.Id)

	if err != nil {
		log.Printf("Error clearing account from cookies: %v\n", err)
		http.Error(w, "Error clearing account from cookies: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully signed out")
}

func GetOrgUserConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetOrgUserConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	orgUserConfig, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)

	if err != nil {
		log.Printf("Error getting org user config: %v\n", err)
		http.Error(w, "Error getting org user config: "+err.Error(), http.StatusInternalServerError)
		return
	}

	bytes, err := json.Marshal(orgUserConfig)

	if err != nil {
		log.Printf("Error marshalling response: %v\n", err)
		http.Error(w, "Error marshalling response: "+err.Error(), http.StatusInternalServerError)
		return
	}

	w.Write(bytes)
}

func UpdateOrgUserConfigHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateOrgUserConfigHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("Error reading request body: %v\n", err)
		http.Error(w, "Error reading request body: "+err.Error(), http.StatusInternalServerError)
		return
	}

	var req shared.OrgUserConfig
	err = json.Unmarshal(body, &req)
	if err != nil {
		log.Printf("Error unmarshalling request: %v\n", err)
		http.Error(w, "Error unmarshalling request: "+err.Error(), http.StatusInternalServerError)
		return
	}

	err = db.UpdateOrgUserConfig(auth.User.Id, auth.OrgId, &req)

	if err != nil {
		log.Printf("Error updating org user config: %v\n", err)
		http.Error(w, "Error updating org user config: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully updated org user config")
}


================================================
FILE: app/server/handlers/settings.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"reflect"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func GetSettingsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetSettingsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	plan := authorizePlan(w, planId, auth)
	if plan == nil {
		return
	}

	var settings *shared.PlanSettings
	ctx, cancel := context.WithCancel(r.Context())

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "get settings",
		Scope:    db.LockScopeRead,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		res, err := db.GetPlanSettings(plan)
		if err != nil {
			return err
		}

		settings = res

		return nil
	})

	if err != nil {
		log.Println("Error getting settings: ", err)
		http.Error(w, "Error getting settings", http.StatusInternalServerError)
		return
	}

	bytes, err := json.Marshal(settings)

	if err != nil {
		log.Println("Error marshalling settings: ", err)
		http.Error(w, "Error marshalling settings", http.StatusInternalServerError)
		return
	}

	log.Println("GetSettingsHandler processed successfully")

	w.Write(bytes)
}

func UpdateSettingsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateSettingsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	vars := mux.Vars(r)
	planId := vars["planId"]
	branch := vars["branch"]

	log.Println("planId: ", planId, "branch: ", branch)

	plan := authorizePlan(w, planId, auth)

	if plan == nil {
		return
	}

	var req shared.UpdateSettingsRequest
	err := json.NewDecoder(r.Body).Decode(&req)

	if err != nil {
		log.Println("Error decoding request body: ", err)
		http.Error(w, "Error decoding request body", http.StatusInternalServerError)
		return
	}

	if req.ModelPackName == "" && req.ModelPack == nil {
		log.Println("No model pack name or model pack provided")
		http.Error(w, "No model pack name or model pack provided", http.StatusBadRequest)
		return
	}

	if req.ModelPackName != "" {
		if mp, builtIn := shared.BuiltInModelPacksByName[req.ModelPackName]; builtIn {
			if os.Getenv("IS_CLOUD") != "" && mp.LocalProvider != "" {
				msg := fmt.Sprintf("Built-in local model pack %s can't be used on Plandex Cloud", req.ModelPackName)
				log.Println(msg)
				http.Error(w, msg, http.StatusUnprocessableEntity)
				return
			}
		}
	}

	if req.ModelPack != nil {
		if req.ModelPack.LocalProvider != "" {
			msg := fmt.Sprintf("Local model pack %s can't be used on Plandex Cloud", req.ModelPack.Name)
			log.Println(msg)
			http.Error(w, msg, http.StatusUnprocessableEntity)
			return
		}

		ids := req.ModelPack.ToModelPackSchema().AllModelIds()
		for _, id := range ids {
			bm, builtIn := shared.BuiltInBaseModelsById[id]
			if builtIn && os.Getenv("IS_CLOUD") != "" && bm.IsLocalOnly() {
				msg := fmt.Sprintf("Built-in local model %s can't be used on Plandex Cloud", id)
				log.Println(msg)
				http.Error(w, msg, http.StatusUnprocessableEntity)
				return
			}
		}
	}

	ctx, cancel := context.WithCancel(r.Context())

	var commitMsg string

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Reason:   "update settings",
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancel,
	}, func(repo *db.GitRepo) error {
		originalSettings, err := db.GetPlanSettings(plan)

		if err != nil {
			return fmt.Errorf("error getting settings: %v", err)
		}

		settings, err := originalSettings.DeepCopy()
		if err != nil {
			return fmt.Errorf("error copying settings: %v", err)
		}

		if req.ModelPackName != "" {
			settings.SetModelPackByName(req.ModelPackName)
		} else if req.ModelPack != nil {
			settings.SetCustomModelPack(req.ModelPack)
		} else {
			return fmt.Errorf("no model pack name or model pack provided")
		}

		// log.Println("Original settings:")
		// spew.Dump(originalSettings)

		// log.Println("req.Settings:")
		// spew.Dump(req.Settings)

		err = db.StorePlanSettings(plan, *settings)

		if err != nil {
			return fmt.Errorf("error storing settings: %v", err)
		}

		commitMsg = getUpdateCommitMsg(settings, originalSettings, false)

		err = repo.GitAddAndCommit(branch, commitMsg)

		if err != nil {
			return fmt.Errorf("error committing settings: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Println("Error updating settings: ", err)
		http.Error(w, "Error updating settings", http.StatusInternalServerError)
		return
	}

	res := shared.UpdateSettingsResponse{
		Msg: commitMsg,
	}
	bytes, err := json.Marshal(res)

	if err != nil {
		log.Println("Error marshalling response: ", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("UpdateSettingsHandler processed successfully")

}

func GetDefaultSettingsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for GetDefaultSettingsHandler")

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	settings, err := db.GetOrgDefaultSettings(auth.OrgId)

	if err != nil {
		log.Println("Error getting default settings: ", err)
		http.Error(w, "Error getting default settings", http.StatusInternalServerError)
		return
	}

	bytes, err := json.Marshal(settings)

	if err != nil {
		log.Println("Error marshalling default settings: ", err)
		http.Error(w, "Error marshalling default settings", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("GetDefaultSettingsHandler processed successfully")
}

func UpdateDefaultSettingsHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received request for UpdateDefaultSettingsHandler")

	auth := Authenticate(w, r, true)

	if auth == nil {
		return
	}

	var req shared.UpdateSettingsRequest
	err := json.NewDecoder(r.Body).Decode(&req)

	if err != nil {
		log.Println("Error decoding request body: ", err)
		http.Error(w, "Error decoding request body", http.StatusInternalServerError)
		return
	}

	if req.ModelPackName == "" && req.ModelPack == nil {
		log.Println("No model pack name or model pack provided")
		http.Error(w, "No model pack name or model pack provided", http.StatusBadRequest)
		return
	}

	var originalSettings *shared.PlanSettings
	var settings *shared.PlanSettings

	err = db.WithTx(r.Context(), "update default settings", func(tx *sqlx.Tx) error {
		var err error

		originalSettings, err = db.GetOrgDefaultSettingsForUpdate(auth.OrgId, tx)

		if err != nil {
			log.Println("Error getting default settings: ", err)
			return fmt.Errorf("error getting default settings: %v", err)
		}

		settings, err = originalSettings.DeepCopy()
		if err != nil {
			return fmt.Errorf("error copying settings: %v", err)
		}

		if req.ModelPackName != "" {
			settings.SetModelPackByName(req.ModelPackName)
		} else if req.ModelPack != nil {
			settings.SetCustomModelPack(req.ModelPack)
		} else {
			return fmt.Errorf("no model pack name or model pack provided")
		}

		// log.Println("Original settings:")
		// spew.Dump(originalSettings)

		// log.Println("req.Settings:")
		// spew.Dump(req.Settings)

		err = db.StoreOrgDefaultSettings(auth.OrgId, settings, tx)

		if err != nil {
			log.Println("Error storing default settings: ", err)
			return fmt.Errorf("error storing default settings: %v", err)
		}

		return nil
	})

	if err != nil {
		log.Println("Error updating default settings: ", err)
		http.Error(w, "Error updating default settings", http.StatusInternalServerError)
		return
	}

	commitMsg := getUpdateCommitMsg(settings, originalSettings, true)

	res := shared.UpdateSettingsResponse{
		Msg: commitMsg,
	}
	bytes, err := json.Marshal(res)

	if err != nil {
		log.Println("Error marshalling response: ", err)
		http.Error(w, "Error marshalling response", http.StatusInternalServerError)
		return
	}

	w.Write(bytes)

	log.Println("UpdateDefaultSettingsHandler processed successfully")
}

func getUpdateCommitMsg(settings *shared.PlanSettings, originalSettings *shared.PlanSettings, isOrgDefault bool) string {
	// log.Println("Comparing settings")
	// log.Println("Original:")
	// spew.Dump(originalSettings)
	// log.Println("New:")
	// spew.Dump(settings)

	// log.Println("Changes to settings:", strings.Join(changes, "\n"))
	var s string
	if isOrgDefault {
		s = "⚙️  Updated org-wide default settings:"
	} else {
		s = "⚙️  Updated model settings:"
	}

	var changes []string
	changes = compareSettings(originalSettings, settings, changes)

	if len(changes) == 0 {
		return "No changes to settings"
	}

	for _, change := range changes {
		s += "\n" + "  • " + change
	}

	return s
}

func compareSettings(original, updated *shared.PlanSettings, changes []string) []string {
	if updated.ModelPackName != "" {
		originalName := "custom"
		if original.ModelPackName != "" {
			originalName = original.ModelPackName
		}
		changes = append(changes, fmt.Sprintf("model-pack | %v → %v", originalName, updated.ModelPackName))
	} else if updated.ModelPack != nil {
		if original.ModelPack == nil {
			changes = append(changes, fmt.Sprintf("model-pack | %v → %v", original.ModelPackName, "custom"))
		}

		changes = compareAny(original.GetModelPack().ToModelPackSchema().ModelPackSchemaRoles, updated.GetModelPack().ToModelPackSchema().ModelPackSchemaRoles, "", changes)
	}

	return changes
}

func compareAny(a, b interface{}, path string, changes []string) []string {
	aVal, bVal := reflect.ValueOf(a), reflect.ValueOf(b)

	if !aVal.IsValid() && !bVal.IsValid() {
		return changes
	}

	// Pointer / nil handling – BEFORE dereferencing
	if aVal.Kind() == reflect.Ptr || bVal.Kind() == reflect.Ptr {
		// both nil → nothing
		if (aVal.Kind() == reflect.Ptr && aVal.IsNil()) &&
			(bVal.Kind() == reflect.Ptr && bVal.IsNil()) {
			return changes
		}

		// one nil, one non-nil → record diff
		if (aVal.Kind() == reflect.Ptr && aVal.IsNil()) ||
			(bVal.Kind() == reflect.Ptr && bVal.IsNil()) {
			aStr := "none"
			bStr := "none"
			if aVal.Kind() != reflect.Ptr || !aVal.IsNil() {
				aStr = short(aVal)
			}
			if bVal.Kind() != reflect.Ptr || !bVal.IsNil() {
				bStr = short(bVal)
			}
			changes = append(changes, fmt.Sprintf("%s | %s → %s", path, aStr, bStr))
			return changes
		}

		// both non-nil pointers → safe to dereference
		if aVal.Kind() == reflect.Ptr {
			aVal = aVal.Elem()
		}
		if bVal.Kind() == reflect.Ptr {
			bVal = bVal.Elem()
		}
	}

	// Check again after dereferencing
	if !aVal.IsValid() && !bVal.IsValid() {
		return changes
	}

	// One side nil → record diff and stop
	if !aVal.IsValid() || !bVal.IsValid() {
		var aStr, bStr string
		if aVal.IsValid() {
			aStr = short(aVal)
		} else {
			aStr = "none"
		}
		if bVal.IsValid() {
			bStr = short(bVal)
		} else {
			bStr = "none"
		}
		changes = append(changes, fmt.Sprintf("%s | %s → %s", path, aStr, bStr))
		return changes
	}

	// Ensure we can safely call Interface()
	if !aVal.CanInterface() || !bVal.CanInterface() {
		return changes
	}

	if reflect.DeepEqual(aVal.Interface(), bVal.Interface()) {
		return changes // No difference found
	}

	switch aVal.Kind() {
	case reflect.Struct:
		for i := 0; i < aVal.NumField(); i++ {
			field := aVal.Type().Field(i)
			if !field.IsExported() {
				continue // Skip unexported fields
			}
			fieldName := field.Name
			dasherizedName := shared.Dasherize(fieldName)

			updatedPath := path
			if !(dasherizedName == "model-set" ||
				dasherizedName == "model-role-config" ||
				dasherizedName == "base-model-config" ||
				dasherizedName == "planner-model-config" ||
				dasherizedName == "task-model-config") {
				if updatedPath != "" {
					updatedPath = updatedPath + "." + dasherizedName
				} else {
					if dasherizedName == "model-overrides" {
						dasherizedName = "overrides"
					}
					updatedPath = dasherizedName
				}
			}

			changes = compareAny(aVal.Field(i).Interface(), bVal.Field(i).Interface(), updatedPath, changes)
		}
	default:
		var aStr, bStr string
		if aVal.IsValid() {
			aStr = short(aVal)
		} else {
			aStr = "no override"
		}

		if bVal.IsValid() {
			bStr = short(bVal)
		} else {
			bStr = "no override"
		}

		change := fmt.Sprintf("%s | %v → %v", path, aStr, bStr)
		changes = append(changes, change)
	}

	return changes
}

func short(v reflect.Value) string {
	if !v.IsValid() {
		return "none"
	}

	// If it’s a pointer, follow it once
	if v.Kind() == reflect.Ptr {
		if v.IsNil() {
			return "none"
		}
		v = v.Elem()
	}

	switch v.Kind() {
	case reflect.String:
		return v.String()
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return fmt.Sprintf("%d", v.Int())
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return fmt.Sprintf("%d", v.Uint())
	case reflect.Float32, reflect.Float64:
		return fmt.Sprintf("%g", v.Float())
	case reflect.Struct:
		// Special-case ModelRoleConfigSchema: show the ModelId only
		if f := v.FieldByName("ModelId"); f.IsValid() && f.Kind() == reflect.String {
			return f.String()
		}
		return fmt.Sprintf("%T", v.Interface()) // fall-back: just the type name
	default:
		return fmt.Sprintf("%v", v.Interface())
	}
}


================================================
FILE: app/server/handlers/stream_helper.go
================================================
package handlers

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	modelPlan "plandex-server/model/plan"
	"plandex-server/types"
	"time"

	shared "plandex-shared"
)

const HeartbeatInterval = 5 * time.Second

func startResponseStream(reqCtx context.Context, w http.ResponseWriter, auth *types.ServerAuth, planId, branch string, isConnect bool) {
	log.Println("Response stream manager: starting plan stream")

	active := modelPlan.GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("Response stream manager: active plan not found for plan ID %s on branch %s\n", planId, branch)
		http.Error(w, "Active plan not found", http.StatusNotFound)
		return
	}

	w.Header().Set("Transfer-Encoding", "chunked")
	w.Header().Set("Content-Type", "text/plain; charset=utf-8")

	// send initial message to client
	msg := shared.StreamMessage{
		Type: shared.StreamMessageStart,
	}

	bytes, err := json.Marshal(msg)

	if err != nil {
		log.Printf("Response stream manager: error marshalling message: %v\n", err)
		return
	}

	log.Println("Response stream manager: sending initial message")
	err = sendStreamMessage(w, string(bytes))
	if err != nil {
		log.Println("Response stream manager: error sending initial message:", err)
		return
	}

	if isConnect {
		time.Sleep(100 * time.Millisecond)
		err = initConnectActive(auth, planId, branch, w)

		if err != nil {
			log.Println("Response stream manager: error initializing connection to active plan:", err)
			return
		}
	}

	subscriptionId, ch := modelPlan.SubscribePlan(reqCtx, planId, branch)
	defer func() {
		log.Println("Response stream manager: client stream closed")
		modelPlan.UnsubscribePlan(planId, branch, subscriptionId)
	}()

	if isConnect {
		time.Sleep(50 * time.Millisecond)
	} else {
		time.Sleep(100 * time.Millisecond)
	}

	chHeartbeat := make(chan string)

	// send heartbeats while the stream is active
	go func() {
		ticker := time.NewTicker(HeartbeatInterval)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				chHeartbeat <- string(shared.StreamMessageHeartbeat)
			case <-reqCtx.Done():
				return
			}
		}
	}()

	for {
		select {
		case <-reqCtx.Done():
			log.Println("Response stream manager: request context done")
			return
		case msg := <-chHeartbeat:
			err = sendStreamMessage(w, msg)
			if err != nil {
				return
			}
		case msg := <-ch:
			// log.Println("Response stream manager: sending message:", msg)
			err = sendStreamMessage(w, msg)
			if err != nil {
				return
			}
		}
	}

}

func sendStreamMessage(w http.ResponseWriter, msg string) error {
	bytes := []byte(msg + shared.STREAM_MESSAGE_SEPARATOR)

	// log.Printf("Response stream manager: writing message to client: %s\n", msg)

	_, err := w.Write(bytes)
	if err != nil {
		log.Printf("Response stream manager: error writing to client: %v\n", err)
		return err
	} else if flusher, ok := w.(http.Flusher); ok {
		flusher.Flush()
	}
	return nil
}

func initConnectActive(auth *types.ServerAuth, planId, branch string, w http.ResponseWriter) error {
	log.Println("Response stream manager: initializing connection to active plan")

	active := modelPlan.GetActivePlan(planId, branch)

	if active == nil {
		return fmt.Errorf("active plan not found for plan ID %s on branch %s", planId, branch)
	}

	msg := shared.StreamMessage{
		Type: shared.StreamMessageConnectActive,
	}

	if active.Prompt != "" && !active.BuildOnly {
		msg.InitPrompt = active.Prompt
	}

	if active.BuildOnly {
		msg.InitBuildOnly = true
	}

	if len(active.StoredReplyIds) > 0 {
		convo, err := db.GetPlanConvo(auth.OrgId, active.Id)
		if err != nil {
			return fmt.Errorf("error getting plan convo: %v", err)
		}

		convoMsgById := map[string]*db.ConvoMessage{}
		for _, convoMsg := range convo {
			convoMsgById[convoMsg.Id] = convoMsg
		}

		for _, replyId := range active.StoredReplyIds {
			if convoMsg, ok := convoMsgById[replyId]; ok {
				msg.InitReplies = append(msg.InitReplies, convoMsg.Message)
			}
		}
	}

	if active.CurrentReplyContent != "" {
		msg.InitReplies = append(msg.InitReplies, active.CurrentReplyContent)
	}

	if active.MissingFilePath != "" {
		msg.MissingFilePath = active.MissingFilePath
	}

	bytes, err := json.Marshal(msg)

	if err != nil {
		return fmt.Errorf("error marshalling message: %v", err)
	}

	log.Println("Response stream manager: sending connect message")
	err = sendStreamMessage(w, string(bytes))

	if err != nil {
		return fmt.Errorf("error sending connect message: %v", err)
	}

	buildQueuesByPath := modelPlan.GetActivePlan(planId, branch).BuildQueuesByPath

	// if we're connecting to an active stream and there are active builds, send initial build info
	if len(buildQueuesByPath) > 0 {

		for path, queue := range buildQueuesByPath {
			buildInfo := shared.BuildInfo{Path: path}

			for _, build := range queue {
				if build.BuildFinished() {
					buildInfo.NumTokens = 0
					buildInfo.Finished = true
				} else {
					// no longer showing token counts in build info - leaving commented out for now for reference
					// tokens := build.WithLineNumsBufferTokens
					buildInfo.Finished = false
					// buildInfo.NumTokens += tokens
				}
			}

			msg := shared.StreamMessage{
				Type:      shared.StreamMessageBuildInfo,
				BuildInfo: &buildInfo,
			}
			bytes, err := json.Marshal(msg)

			if err != nil {
				return fmt.Errorf("error marshalling message: %v", err)
			}

			err = sendStreamMessage(w, string(bytes))

			if err != nil {
				return fmt.Errorf("error sending message: %v", err)
			}

		}

	}

	return nil
}


================================================
FILE: app/server/handlers/users.go
================================================
package handlers

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"strings"

	shared "plandex-shared"

	"github.com/gorilla/mux"
	"github.com/jmoiron/sqlx"
)

func ListUsersHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for ListUsersHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for user management",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't list users",
		})
		return
	}

	users, err := db.ListUsers(auth.OrgId)
	if err != nil {
		log.Println("Error listing users: ", err)
		http.Error(w, "Error listing users: "+err.Error(), http.StatusInternalServerError)
		return
	}

	apiUsers := make([]*shared.User, 0, len(users))
	for _, user := range users {
		apiUsers = append(apiUsers, user.ToApi())
	}

	orgUsers, err := db.ListOrgUsers(auth.OrgId)
	if err != nil {
		log.Println("Error listing org users: ", err)
		http.Error(w, "Error listing org users: "+err.Error(), http.StatusInternalServerError)
		return
	}

	orgUsersByUserId := make(map[string]*shared.OrgUser)
	for _, orgUser := range orgUsers {
		orgUsersByUserId[orgUser.UserId] = orgUser.ToApi()
	}

	resp := shared.ListUsersResponse{
		Users:            apiUsers,
		OrgUsersByUserId: orgUsersByUserId,
	}

	bytes, err := json.Marshal(resp)

	if err != nil {
		log.Println("Error marshalling users: ", err)
		http.Error(w, "Error marshalling users: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed request for ListUsersHandler")

	w.Write(bytes)
}

func DeleteOrgUserHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Received a request for DeleteOrgUserHandler")

	if os.Getenv("GOENV") == "development" && os.Getenv("LOCAL_MODE") == "1" {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusForbidden,
			Msg:    "Local mode is not supported for user management",
		})
		return
	}

	auth := Authenticate(w, r, true)
	if auth == nil {
		return
	}

	org, err := db.GetOrg(auth.OrgId)
	if err != nil {
		log.Printf("Error getting org: %v\n", err)
		http.Error(w, "Error getting org: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if org.IsTrial {
		writeApiError(w, shared.ApiError{
			Type:   shared.ApiErrorTypeTrialActionNotAllowed,
			Status: http.StatusForbidden,
			Msg:    "Trial user can't delete users",
		})
		return
	}

	vars := mux.Vars(r)
	userId := vars["userId"]

	log.Println("userId: ", userId)

	orgUser, err := db.GetOrgUser(userId, auth.OrgId)

	if err != nil {
		log.Printf("Error getting org user: %v\n", err)
		http.Error(w, "Error getting org user: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// ensure current user can remove target user
	removePermission := shared.Permission(strings.Join([]string{string(shared.PermissionRemoveUser), orgUser.OrgRoleId}, "|"))

	if !auth.HasPermission(removePermission) {
		log.Printf("User does not have permission to remove user with role: %v\n", orgUser.OrgRoleId)
		http.Error(w, "User does not have permission to remove user with role: "+orgUser.OrgRoleId, http.StatusForbidden)
		return
	}

	// verify user is org member
	isMember, err := db.ValidateOrgMembership(userId, auth.OrgId)

	if err != nil {
		log.Printf("Error validating org membership: %v\n", err)
		http.Error(w, "Error validating org membership: "+err.Error(), http.StatusInternalServerError)
		return
	}

	if !isMember {
		log.Printf("User %s is not a member of org %s\n", userId, auth.OrgId)
		http.Error(w, "User "+userId+" is not a member of org "+auth.OrgId, http.StatusForbidden)
		return
	}

	orgOwnerRoleId, err := db.GetOrgOwnerRoleId()

	if err != nil {
		log.Printf("Error getting org owner role id: %v\n", err)
		http.Error(w, "Error getting org owner role id: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// verify user isn't the only org owner
	if orgUser.OrgRoleId == orgOwnerRoleId {
		numOwners, err := db.NumUsersWithRole(auth.OrgId, orgOwnerRoleId)

		if err != nil {
			log.Printf("Error getting number of org owners: %v\n", err)
			http.Error(w, "Error getting number of org owners: "+err.Error(), http.StatusInternalServerError)
			return
		}

		if numOwners == 1 {
			log.Println("Cannot delete the only org owner")
			http.Error(w, "Cannot delete the only org owner", http.StatusForbidden)
			return
		}
	}

	err = db.WithTx(r.Context(), "delete org user", func(tx *sqlx.Tx) error {

		err = db.DeleteOrgUser(auth.OrgId, userId, tx)

		if err != nil {
			log.Println("Error deleting org user: ", err)
			return fmt.Errorf("error deleting org user: %v", err)
		}

		invite, err := db.GetActiveInviteByEmail(auth.OrgId, auth.User.Email)

		if err != nil {
			log.Println("Error getting invite for org user: ", err)
			return fmt.Errorf("error getting invite for org user: %v", err)
		}

		if invite != nil {
			err = db.DeleteInvite(invite.Id, tx)

			if err != nil {
				log.Println("Error deleting invite: ", err)
				return fmt.Errorf("error deleting invite: %v", err)
			}
		}

		return nil
	})

	if err != nil {
		log.Println("Error deleting org user: ", err)
		http.Error(w, "Error deleting org user: "+err.Error(), http.StatusInternalServerError)
		return
	}

	log.Println("Successfully processed request for DeleteOrgUserHandler")
}


================================================
FILE: app/server/hooks/hooks.go
================================================
package hooks

import (
	"context"
	"plandex-server/db"
	"plandex-server/types"
	"time"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
	"github.com/sashabaranov/go-openai"
)

const (
	HealthCheck = "health_check"

	CreateAccount        = "create_account"
	WillCreatePlan       = "will_create_plan"
	WillTellPlan         = "will_tell_plan"
	WillExecPlan         = "will_exec_plan"
	WillSendModelRequest = "will_send_model_request"
	DidSendModelRequest  = "did_send_model_request"
	DidFinishBuilderRun  = "did_finish_builder_run"
	CreateOrg            = "create_org"
	Authenticate         = "authenticate"
	GetIntegratedModels  = "get_integrated_models"
	GetApiOrgs           = "get_api_orgs"
	CallFastApply        = "call_fast_apply"
)

type WillSendModelRequestParams struct {
	InputTokens  int
	OutputTokens int
	ModelName    shared.ModelName
	IsUserPrompt bool
	ModelTag     shared.ModelTag
	ModelId      shared.ModelId
}

type DidSendModelRequestParams struct {
	InputTokens     int
	OutputTokens    int
	CachedTokens    int
	ModelId         shared.ModelId
	ModelTag        shared.ModelTag
	ModelName       shared.ModelName
	ModelProvider   shared.ModelProvider
	ModelRole       shared.ModelRole
	ModelPackName   string
	Purpose         string
	GenerationId    string
	PlanId          string
	ModelStreamId   string
	ConvoMessageId  string
	BuildId         string
	StoppedEarly    bool
	UserCancelled   bool
	HadError        bool
	NoReportedUsage bool
	SessionId       string

	RequestStartedAt time.Time
	Streaming        bool
	StreamResult     string
	FirstTokenAt     time.Time
	Req              *types.ExtendedChatCompletionRequest
	Res              *openai.ChatCompletionResponse
	ModelConfig      *shared.ModelRoleConfig
}

type DidFinishBuilderRunParams struct {
	PlanId        string
	FilePath      string
	FileExt       string
	Lang          string
	GenerationIds []string

	ValidateModelConfig  *shared.ModelRoleConfig
	FastApplyModelConfig *shared.ModelRoleConfig
	WholeFileModelConfig *shared.ModelRoleConfig

	AutoApplySuccess                   bool
	AutoApplyValidationReasons         []string
	AutoApplyValidationSyntaxErrors    []string
	AutoApplyValidationPassed          bool
	AutoApplyValidationFailureResponse string
	AutoApplyValidationStartedAt       time.Time
	AutoApplyValidationFinishedAt      time.Time

	DidReplacement             bool
	ReplacementSuccess         bool
	ReplacementSyntaxErrors    []string
	ReplacementFailureResponse string
	ReplacementStartedAt       time.Time
	ReplacementFinishedAt      time.Time

	DidRewriteProposed             bool
	RewriteProposedSuccess         bool
	RewriteProposedSyntaxErrors    []string
	RewriteProposedFailureResponse string
	RewriteProposedStartedAt       time.Time
	RewriteProposedFinishedAt      time.Time

	DidFastApply             bool
	FastApplySuccess         bool
	FastApplySyntaxErrors    []string
	FastApplyFailureResponse string
	FastApplyStartedAt       time.Time
	FastApplyFinishedAt      time.Time

	BuiltWholeFile           bool
	BuildWholeFileStartedAt  time.Time
	BuildWholeFileFinishedAt time.Time

	StartedAt  time.Time
	FinishedAt time.Time
}

type CreateOrgHookRequestParams struct {
	Org *db.Org
}

type AuthenticateHookRequestParams struct {
	Path string
	Hash string
}

type FastApplyParams struct {
	InitialCode string `json:"initialCode"`
	EditSnippet string `json:"editSnippet"`

	InitialCodeTokens int
	EditSnippetTokens int

	Language shared.Language

	Ctx context.Context
}

type HookParams struct {
	Auth *types.ServerAuth
	Plan *db.Plan
	Tx   *sqlx.Tx

	WillSendModelRequestParams    *WillSendModelRequestParams
	DidSendModelRequestParams     *DidSendModelRequestParams
	CreateOrgHookRequestParams    *CreateOrgHookRequestParams
	GetApiOrgIds                  []string
	AuthenticateHookRequestParams *AuthenticateHookRequestParams
	DidFinishBuilderRunParams     *DidFinishBuilderRunParams
	FastApplyParams               *FastApplyParams
}

type GetIntegratedModelsResult struct {
	IntegratedModelsMode bool
	AuthVars             map[string]string
}

type FastApplyResult struct {
	MergedCode string
}

type HookResult struct {
	GetIntegratedModelsResult *GetIntegratedModelsResult
	ApiOrgsById               map[string]*shared.Org
	FastApplyResult           *FastApplyResult
}

type Hook func(params HookParams) (HookResult, *shared.ApiError)

var hooks = make(map[string]Hook)

func RegisterHook(name string, hook Hook) {
	hooks[name] = hook
}

func ExecHook(name string, params HookParams) (HookResult, *shared.ApiError) {
	hook, ok := hooks[name]
	if !ok {
		return HookResult{}, nil
	}
	return hook(params)
}

func TestUpdate() {

}


================================================
FILE: app/server/host/ip.go
================================================
package host

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

var Ip string

func LoadIp() error {
	if os.Getenv("GOENV") == "development" {
		Ip = "localhost"
		return nil
	}

	if os.Getenv("IS_CLOUD") != "" {
		var err error
		Ip, err = getAwsIp()

		if err != nil {
			return fmt.Errorf("error getting AWS ECS IP: %v", err)
		}

		log.Println("Got AWS ECS IP: ", Ip)

	} else if os.Getenv("IP") != "" {
		Ip = os.Getenv("IP")
		return nil
	}

	return nil
}

type ecsMetadata struct {
	Networks []struct {
		IPv4Addresses []string `json:"IPv4Addresses"`
	} `json:"Networks"`
}

var awsIp string

func getAwsIp() (string, error) {
	ecsMetadataURL := os.Getenv("ECS_CONTAINER_METADATA_URI")

	log.Printf("Getting ECS metadata from %s\n", ecsMetadataURL)

	resp, err := http.Get(ecsMetadataURL)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	var metadata ecsMetadata
	err = json.Unmarshal(body, &metadata)
	if err != nil {
		return "", err
	}

	if len(metadata.Networks) == 0 || len(metadata.Networks[0].IPv4Addresses) == 0 {
		return "", errors.New("no IP address found in ECS metadata")
	}

	awsIp = metadata.Networks[0].IPv4Addresses[0]

	return awsIp, nil
}


================================================
FILE: app/server/litellm_proxy.py
================================================
from litellm.llms.anthropic.common_utils import AnthropicModelInfo
from typing import List, Optional

_orig_get_hdrs = AnthropicModelInfo.get_anthropic_headers

def _oauth_get_hdrs(
  self,
  api_key: str,
  anthropic_version: Optional[str] = None,
  computer_tool_used: bool = False,
  prompt_caching_set: bool = False,
  pdf_used: bool = False,
  file_id_used: bool = False,
  mcp_server_used: bool = False,
  is_vertex_request: bool = False,
  user_anthropic_beta_headers: Optional[List[str]] = None,
):
  # call the original builder first
  hdrs = _orig_get_hdrs(
    self,
    api_key=api_key,
    anthropic_version=anthropic_version,
    computer_tool_used=computer_tool_used,
    prompt_caching_set=prompt_caching_set,
    pdf_used=pdf_used,
    file_id_used=file_id_used,
    mcp_server_used=mcp_server_used,
    is_vertex_request=is_vertex_request,
    user_anthropic_beta_headers=user_anthropic_beta_headers,
  )

  # remove x-api-key when we detect an OAuth access-token
  print(f"api_key: {api_key}")
  if api_key and api_key.startswith(("sk-ant-oat", "sk-ant-oau")):
    hdrs["anthropic-beta"] = "oauth-2025-04-20"
    hdrs["anthropic-product"] = "claude-code"
    hdrs.pop("x-api-key", None)

  print(f"Anthropic headers: {hdrs}")

  return hdrs

# monkey-patch AnthropicModelInfo.get_anthropic_headers to handle OAuth headers
AnthropicModelInfo.get_anthropic_headers = _oauth_get_hdrs

from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse, JSONResponse
from litellm import completion, _turn_on_debug
import json
import re

# _turn_on_debug()

LOGGING_ENABLED = False

print("Litellm proxy: starting proxy server on port 4000...")

app = FastAPI()

@app.get("/health")
async def health():
  return {"status": "ok"}

@app.post("/v1/chat/completions")
async def passthrough(request: Request):
  payload = await request.json()

  if LOGGING_ENABLED:
    # Log the request data for debugging
    try:
      # Get headers (excluding authorization to avoid logging credentials)
      headers = dict(request.headers)
      if "Authorization" in headers:
        headers["Authorization"] = "Bearer [REDACTED]"
      if "api-key" in headers:
        headers["api-key"] = "[REDACTED]"
      
      # Create a log-friendly representation
      request_data = {
        "method": request.method,
        "url": str(request.url),
        "headers": headers,
        "body": payload
      }
    
      # Log the request data
      print("Incoming request to /v1/chat/completions:")
      print(json.dumps(request_data, indent=2))
    except Exception as e:
      print(f"Error logging request: {str(e)}")

  model = payload.get("model", None)
  print(f"Litellm proxy: calling model: {model}")

  api_key = payload.pop("api_key", None)

  if not api_key:
    api_key = request.headers.get("Authorization")

  if not api_key:
    api_key = request.headers.get("api-key")

  if api_key and api_key.startswith("Bearer "):
    api_key = api_key.replace("Bearer ", "")

  # api key optional for local/ollama models, so no need to error if not provided

  # clean up for ollama if needed
  payload = normalise_for_ollama(payload)

  try:
    if payload.get("stream"):
      
      try:
        response_stream = completion(api_key=api_key, **payload)
      except Exception as e:
        return error_response(e)
      def stream_generator():
        try:  
          for chunk in response_stream:
            yield f"data: {json.dumps(chunk.to_dict())}\n\n"
          yield "data: [DONE]\n\n"
        except Exception as e:
          # surface the problem to the client _inside_ the SSE stream
          yield f"data: {json.dumps({'error': str(e)})}\n\n"
          return

        finally:
          try:
            response_stream.close()
          except AttributeError:
            pass

      print(f"Litellm proxy: Initiating streaming response for model: {payload.get('model', 'unknown')}")
      return StreamingResponse(stream_generator(), media_type="text/event-stream")

    else:
      print(f"Litellm proxy: Non-streaming response requested for model: {payload.get('model', 'unknown')}")
      try:
        result = completion(api_key=api_key, **payload)
      except Exception as e:
        return error_response(e)
      return JSONResponse(content=result)

  except Exception as e:
    err_msg = str(e)
    print(f"Litellm proxy: Error: {err_msg}")
    status_match = re.search(r"status code: (\d+)", err_msg)
    if status_match:
      status_code = int(status_match.group(1))
    else:
      status_code = 500
    return JSONResponse(
      status_code=status_code,
      content={"error": err_msg}
    )

def error_response(exc: Exception) -> JSONResponse:
  status = getattr(exc, "status_code", 500)
  retry_after = (
    getattr(getattr(exc, "response", None), "headers", {})
    .get("Retry-After")
  )
  hdrs = {"Retry-After": retry_after} if retry_after else {}
  return JSONResponse(status_code=status, content={"error": str(exc)}, headers=hdrs)

def normalise_for_ollama(p):
  if not p.get("model", "").startswith("ollama"):
    return p

  # flatten content parts
  for m in p.get("messages", []):
    if isinstance(m["content"], list):  # [{type:"text", text:"…"}]
        m["content"] = "".join(part.get("text", "")
                                for part in m["content"]
                                if part.get("type") == "text")

  # drop params Ollama ignores
  for k in ("top_p", "temperature", "presence_penalty",
            "tool_choice", "tools", "seed"):
      p.pop(k, None)

  return p

================================================
FILE: app/server/main.go
================================================
package main

import (
	"fmt"
	"log"
	"os"
	"plandex-server/model"
	"plandex-server/routes"
	"plandex-server/setup"

	"github.com/gorilla/mux"
)

func main() {
	// Configure the default logger to include milliseconds in timestamps
	log.SetFlags(log.LstdFlags | log.Lmicroseconds | log.Lshortfile)

	routes.RegisterHandlePlandex(func(router *mux.Router, path string, isStreaming bool, handler routes.PlandexHandler) *mux.Route {
		return router.HandleFunc(path, handler)
	})

	err := model.EnsureLiteLLM(2)
	if err != nil {
		panic(fmt.Sprintf("Failed to start LiteLLM proxy: %v", err))
	}
	setup.RegisterShutdownHook(func() {
		model.ShutdownLiteLLMServer()
	})

	r := mux.NewRouter()
	routes.AddHealthRoutes(r)
	routes.AddApiRoutes(r)
	routes.AddProxyableApiRoutes(r)
	setup.MustLoadIp()
	setup.MustInitDb()
	setup.StartServer(r, nil, nil)
	os.Exit(0)
}


================================================
FILE: app/server/migrations/2023120500_init.down.sql
================================================
DROP TABLE IF EXISTS branches;

DROP TABLE IF EXISTS convo_summaries;
DROP TABLE IF EXISTS plan_builds;

DROP TABLE IF EXISTS users_projects;
DROP TABLE IF EXISTS plans;
DROP TABLE IF EXISTS projects;
DROP TABLE IF EXISTS orgs_users;

DROP TABLE IF EXISTS email_verifications;
DROP TABLE IF EXISTS auth_tokens;
DROP TABLE IF EXISTS invites;

DROP TABLE IF EXISTS orgs;
DROP TABLE IF EXISTS users;


================================================
FILE: app/server/migrations/2023120500_init.up.sql
================================================
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

CREATE OR REPLACE FUNCTION update_updated_at_column()
RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = NOW();
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TABLE IF NOT EXISTS users (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) NOT NULL,
  domain VARCHAR(255) NOT NULL,
  is_trial BOOLEAN NOT NULL,
  num_non_draft_plans INTEGER NOT NULL DEFAULT 0,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_users_modtime BEFORE UPDATE ON users FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

ALTER TABLE users ADD UNIQUE (email);
CREATE INDEX users_domain_idx ON users(domain);

CREATE TABLE IF NOT EXISTS orgs (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  name VARCHAR(255) NOT NULL,
  domain VARCHAR(255),
  auto_add_domain_users BOOLEAN NOT NULL DEFAULT FALSE,
  owner_id UUID NOT NULL REFERENCES users(id),
  is_trial BOOLEAN NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_orgs_modtime BEFORE UPDATE ON orgs FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

ALTER TABLE orgs ADD UNIQUE (domain);

CREATE TABLE IF NOT EXISTS orgs_users (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_orgs_users_modtime BEFORE UPDATE ON orgs_users FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX orgs_users_user_idx ON orgs_users(user_id);
CREATE INDEX orgs_users_org_idx ON orgs_users(org_id);

CREATE TABLE IF NOT EXISTS invites (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  name VARCHAR(255) NOT NULL,
  email VARCHAR(255) NOT NULL,
  inviter_id UUID NOT NULL REFERENCES users(id),
  invitee_id UUID REFERENCES users(id),
  accepted_at TIMESTAMP,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_invites_modtime BEFORE UPDATE ON invites FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX invites_pending_idx ON invites(org_id, (accepted_at IS NULL));
CREATE INDEX invites_email_idx ON invites(email, (accepted_at IS NULL));
CREATE INDEX invites_org_user_idx ON invites(org_id, invitee_id);

CREATE TABLE IF NOT EXISTS auth_tokens (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  token_hash VARCHAR(64) NOT NULL,
  is_trial BOOLEAN NOT NULL DEFAULT FALSE,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  deleted_at TIMESTAMP
);
CREATE UNIQUE INDEX auth_tokens_idx ON auth_tokens(token_hash);

CREATE TABLE IF NOT EXISTS email_verifications (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  email VARCHAR(255) NOT NULL,
  pin_hash VARCHAR(64) NOT NULL,
  user_id UUID REFERENCES users(id),  
  auth_token_id UUID REFERENCES auth_tokens(id),
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_email_verifications_modtime BEFORE UPDATE ON email_verifications FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX email_verifications_idx ON email_verifications(pin_hash, email, created_at DESC);

CREATE TABLE IF NOT EXISTS projects (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  name VARCHAR(255) NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_projects_modtime BEFORE UPDATE ON projects FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE TABLE IF NOT EXISTS plans (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
  name VARCHAR(255) NOT NULL,  
  shared_with_org_at TIMESTAMP,
  total_replies INTEGER NOT NULL DEFAULT 0,
  active_branches INTEGER NOT NULL DEFAULT 0,
  archived_at TIMESTAMP,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_plans_modtime BEFORE UPDATE ON plans FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX plans_name_idx ON plans(project_id, owner_id, name);
CREATE INDEX plans_archived_idx ON plans(project_id, owner_id, archived_at);

CREATE TABLE IF NOT EXISTS branches (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
  parent_branch_id UUID REFERENCES branches(id) ON DELETE CASCADE,
  name VARCHAR(255) NOT NULL,
  status VARCHAR(32) NOT NULL,
  error TEXT,
  context_tokens INTEGER NOT NULL DEFAULT 0,
  convo_tokens INTEGER NOT NULL DEFAULT 0,
  shared_with_org_at TIMESTAMP,
  archived_at TIMESTAMP,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW(),
  deleted_at TIMESTAMP
);
CREATE TRIGGER update_branches_modtime BEFORE UPDATE ON branches FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX branches_name_idx ON branches(plan_id, name, archived_at, deleted_at);


CREATE TABLE IF NOT EXISTS users_projects (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
  last_active_plan_id UUID REFERENCES plans(id),
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_users_projects_modtime BEFORE UPDATE ON users_projects FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX users_projects_idx ON users_projects(user_id, org_id, project_id);

CREATE TABLE IF NOT EXISTS convo_summaries (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
  latest_convo_message_id UUID NOT NULL,
  latest_convo_message_created_at TIMESTAMP NOT NULL,
  summary TEXT NOT NULL,
  tokens INTEGER NOT NULL,
  num_messages INTEGER NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS plan_builds (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
  convo_message_id UUID NOT NULL,
  file_path VARCHAR(255) NOT NULL,
  error TEXT,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_plan_builds_modtime BEFORE UPDATE ON plan_builds FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

================================================
FILE: app/server/migrations/2024011700_rbac.down.sql
================================================
ALTER TABLE orgs_users DROP COLUMN org_role_id;
ALTER TABLE invites DROP COLUMN org_role_id;

DROP TABLE IF EXISTS org_roles_permissions;
DROP TABLE IF EXISTS permissions;
DROP TABLE IF EXISTS org_roles;




================================================
FILE: app/server/migrations/2024011700_rbac.up.sql
================================================

CREATE TABLE IF NOT EXISTS org_roles (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID REFERENCES orgs(id) ON DELETE CASCADE,
  name VARCHAR(255) NOT NULL,
  label VARCHAR(255) NOT NULL,
  description TEXT NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_org_roles_modtime BEFORE UPDATE ON org_roles FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX org_roles_org_idx ON org_roles(org_id, name);

ALTER TABLE orgs_users ADD COLUMN org_role_id UUID NOT NULL REFERENCES org_roles(id) ON DELETE RESTRICT;
CREATE INDEX orgs_users_org_role_idx ON orgs_users(org_id, org_role_id);

ALTER TABLE invites ADD COLUMN org_role_id UUID NOT NULL REFERENCES org_roles(id) ON DELETE RESTRICT;
CREATE INDEX invites_org_role_idx ON invites(org_id, org_role_id);

CREATE TABLE IF NOT EXISTS permissions (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  name VARCHAR(255) NOT NULL,
  description TEXT NOT NULL,
  resource_id UUID,
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS org_roles_permissions (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_role_id UUID NOT NULL REFERENCES org_roles(id) ON DELETE CASCADE,
  permission_id UUID NOT NULL REFERENCES permissions(id) ON DELETE CASCADE,
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

INSERT INTO org_roles (name, label, description) VALUES
  ('owner', 'Owner', 'Can read and update any plan, invite other owners/admins/members, manage email domain auth, manage billing, read audit logs, delete the org'),
  ('billing_admin', 'Billing Admin', 'Can manage billing'),
  ('admin', 'Admin', 'Can read and update any plan, invite other admins/members'),
  ('member', 'Member', 'Can read and update their own plans or plans shared with them');

DO $$
DECLARE
  owner_org_role_id UUID;
  billing_admin_org_role_id UUID;
  admin_org_role_id UUID;
  member_org_role_id UUID;
BEGIN
  SELECT id INTO owner_org_role_id FROM org_roles WHERE org_id IS NULL AND name = 'owner';
  SELECT id INTO billing_admin_org_role_id FROM org_roles WHERE org_id IS NULL AND name = 'billing_admin';
  SELECT id INTO admin_org_role_id FROM org_roles WHERE org_id IS NULL AND name = 'admin';
  SELECT id INTO member_org_role_id FROM org_roles WHERE org_id IS NULL AND name = 'member';

  INSERT INTO permissions (name, description, resource_id) VALUES
    ('delete_org', 'Delete an org', NULL),
    ('manage_email_domain_auth', 'Configure whether orgs_users from the org''s email domain are auto-admitted to org', NULL),
    ('manage_billing', 'Manage an org''s billing', NULL),
    
    ('invite_user', 'Invite owners to an org', owner_org_role_id),
    ('invite_user', 'Invite admins to an org', admin_org_role_id),
    ('invite_user', 'Invite billing admins to an org', billing_admin_org_role_id),
    ('invite_user', 'Invite members to an org', member_org_role_id),
    
    ('remove_user', 'Remove owners from an org', owner_org_role_id),
    ('remove_user', 'Remove admins from an org', admin_org_role_id),
    ('remove_user', 'Remove billing admins from an org', billing_admin_org_role_id),
    ('remove_user', 'Remove members from an org', member_org_role_id),
    
    ('set_user_role', 'Update an owner''s role in an org', owner_org_role_id),
    ('set_user_role', 'Update an admin''s role in an org', admin_org_role_id),
    ('set_user_role', 'Update a billing admin''s role in an org', billing_admin_org_role_id),
    ('set_user_role', 'Update a member''s role in an org', member_org_role_id),

    ('list_org_roles', 'List org roles', NULL),
    
    ('create_project', 'Create a project', NULL),
    ('rename_any_project', 'Rename a project', NULL),
    ('delete_any_project', 'Delete a project', NULL),

    ('create_plan', 'Create a plan', NULL),

    ('manage_any_plan_shares', 'Unshare a plan any user shared', NULL),
    ('rename_any_plan', 'Rename a plan', NULL),
    ('delete_any_plan', 'Delete a plan', NULL),
    ('update_any_plan', 'Update a plan', NULL),
    ('archive_any_plan', 'Archive a plan', NULL);
END $$;

-- Insert all permissions for the 'org owner' role
INSERT INTO org_roles_permissions (org_role_id, permission_id)
SELECT 
    (SELECT id FROM org_roles WHERE name = 'owner') AS org_role_id, 
    p.id AS permission_id
FROM 
    permissions p;

-- Insert all permissions except specific ones and those exclusive to 'owner' or 'billing admin' for the 'org admin' role
INSERT INTO org_roles_permissions (org_role_id, permission_id)
SELECT 
    (SELECT id FROM org_roles WHERE name = 'admin') AS org_role_id, 
    p.id AS permission_id
FROM 
    permissions p
WHERE 
    p.name NOT IN ('delete_org', 'manage_email_domain_auth', 'manage_billing')
    AND NOT EXISTS (
        SELECT 1 FROM permissions p2
        WHERE p2.resource_id IN (SELECT id FROM org_roles WHERE name IN ('owner', 'billing_admin'))
        AND p2.id = p.id
    );

INSERT INTO org_roles_permissions (org_role_id, permission_id)
SELECT 
    (SELECT id FROM org_roles WHERE name = 'billing_admin') AS org_role_id, 
    p.id AS permission_id
FROM
    permissions p
WHERE 
    p.name IN (
      'manage_billing'
    );

INSERT INTO org_roles_permissions (org_role_id, permission_id)
SELECT 
    (SELECT id FROM org_roles WHERE name = 'member') AS org_role_id, 
    p.id AS permission_id
FROM
    permissions p
WHERE 
    p.name IN (
      'create_project',
      'create_plan'
    );


================================================
FILE: app/server/migrations/2024012400_streams.down.sql
================================================
DROP TABLE IF EXISTS model_streams;
-- DROP TABLE IF EXISTS model_stream_subscriptions;

================================================
FILE: app/server/migrations/2024012400_streams.up.sql
================================================
CREATE TABLE IF NOT EXISTS model_streams (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
  branch VARCHAR(255) NOT NULL,
  internal_ip VARCHAR(45) NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  finished_at TIMESTAMP
);

CREATE UNIQUE INDEX model_streams_plan_idx ON model_streams(plan_id, branch, finished_at);

-- CREATE TABLE IF NOT EXISTS model_stream_subscriptions (
--   id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
--   org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
--   plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
--   model_stream_id UUID NOT NULL REFERENCES model_streams(id) ON DELETE CASCADE,
--   user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
--   user_ip VARCHAR(45) NOT NULL,
--   created_at TIMESTAMP NOT NULL DEFAULT NOW()
--   finished_at TIMESTAMP
-- );



================================================
FILE: app/server/migrations/2024012500_locks.down.sql
================================================
DROP TABLE IF EXISTS repo_locks;

================================================
FILE: app/server/migrations/2024012500_locks.up.sql
================================================
CREATE UNLOGGED TABLE IF NOT EXISTS repo_locks (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  plan_id UUID NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
  plan_build_id UUID REFERENCES plan_builds(id) ON DELETE CASCADE,
  scope VARCHAR(1) NOT NULL,
  branch VARCHAR(255),
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE INDEX repo_locks_plan_idx ON repo_locks(plan_id);


================================================
FILE: app/server/migrations/2024013000_plan_build_convo_ids.down.sql
================================================
ALTER TABLE plan_builds
  RENAME COLUMN convo_message_ids TO convo_message_id;

ALTER TABLE plan_builds
  ALTER COLUMN convo_message_id TYPE UUID USING (convo_message_id[1]);

================================================
FILE: app/server/migrations/2024013000_plan_build_convo_ids.up.sql
================================================
ALTER TABLE plan_builds
  RENAME COLUMN convo_message_id TO convo_message_ids;

ALTER TABLE plan_builds
  ALTER COLUMN convo_message_ids TYPE UUID[] USING ARRAY[convo_message_ids];


================================================
FILE: app/server/migrations/2024020800_heartbeats.down.sql
================================================
ALTER TABLE repo_locks DROP COLUMN last_heartbeat_at;
ALTER TABLE model_streams DROP COLUMN last_heartbeat_at;

================================================
FILE: app/server/migrations/2024020800_heartbeats.up.sql
================================================
ALTER TABLE repo_locks ADD COLUMN last_heartbeat_at TIMESTAMP NOT NULL DEFAULT NOW();
ALTER TABLE model_streams ADD COLUMN last_heartbeat_at TIMESTAMP NOT NULL DEFAULT NOW();

================================================
FILE: app/server/migrations/2024022000_revert_plan_build_convo_ids.down.sql
================================================
ALTER TABLE plan_builds
  RENAME COLUMN convo_message_id TO convo_message_ids;

ALTER TABLE plan_builds
  ALTER COLUMN convo_message_ids TYPE UUID[] USING ARRAY[convo_message_ids];


================================================
FILE: app/server/migrations/2024022000_revert_plan_build_convo_ids.up.sql
================================================
ALTER TABLE plan_builds
  RENAME COLUMN convo_message_ids TO convo_message_id;

ALTER TABLE plan_builds
  ALTER COLUMN convo_message_id TYPE UUID USING (convo_message_id[1]);

================================================
FILE: app/server/migrations/2024032700_remove_billing_admin.down.sql
================================================


================================================
FILE: app/server/migrations/2024032700_remove_billing_admin.up.sql
================================================
DELETE FROM org_roles WHERE name = 'billing_admin';

================================================
FILE: app/server/migrations/2024032701_drop_users_projects.down.sql
================================================
CREATE TABLE IF NOT EXISTS users_projects (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
  last_active_plan_id UUID REFERENCES plans(id),
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_users_projects_modtime BEFORE UPDATE ON users_projects FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX users_projects_idx ON users_projects(user_id, org_id, project_id);

================================================
FILE: app/server/migrations/2024032701_drop_users_projects.up.sql
================================================
DROP TABLE IF EXISTS users_projects;

================================================
FILE: app/server/migrations/2024040400_add_orgs_users_unique.down.sql
================================================
ALTER TABLE orgs_users DROP CONSTRAINT org_user_unique;

================================================
FILE: app/server/migrations/2024040400_add_orgs_users_unique.up.sql
================================================
-- clean up any duplicates added mistakenly earlier
WITH ranked_duplicates AS (
  SELECT id,
         ROW_NUMBER() OVER (PARTITION BY org_id, user_id ORDER BY created_at) AS rn
  FROM orgs_users
)
DELETE FROM orgs_users
WHERE id IN (
  SELECT id FROM ranked_duplicates WHERE rn > 1
);
 
ALTER TABLE orgs_users ADD CONSTRAINT org_user_unique UNIQUE (org_id, user_id);


================================================
FILE: app/server/migrations/2024041500_model_sets_models.down.sql
================================================
DROP TABLE IF EXISTS model_sets;
DROP TABLE IF EXISTS custom_models;

================================================
FILE: app/server/migrations/2024041500_model_sets_models.up.sql
================================================
CREATE TABLE IF NOT EXISTS model_sets (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,

  name VARCHAR(255) NOT NULL,
  description TEXT,

  planner JSON,
  plan_summary JSON,
  builder JSON,
  namer JSON,
  commit_msg JSON,
  exec_status JSON,

  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE INDEX model_sets_org_idx ON model_sets(org_id);

CREATE TABLE IF NOT EXISTS custom_models (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
  
  provider VARCHAR(255) NOT NULL,
  custom_provider VARCHAR(255),
  base_url VARCHAR(255) NOT NULL,
  model_name VARCHAR(255) NOT NULL,
  description TEXT,
  max_tokens INTEGER NOT NULL,
  api_key_env_var VARCHAR(255),

  is_openai_compatible BOOLEAN NOT NULL,
  has_json_mode BOOLEAN NOT NULL,
  has_streaming BOOLEAN NOT NULL,
  has_function_calling BOOLEAN NOT NULL,
  has_streaming_function_calls BOOLEAN NOT NULL,

  default_max_convo_tokens INTEGER NOT NULL,
  default_reserved_output_tokens INTEGER NOT NULL,

  updated_at TIMESTAMP NOT NULL DEFAULT NOW(),
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

CREATE TRIGGER update_custom_models_modtime BEFORE UPDATE ON custom_models FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE INDEX custom_models_org_idx ON custom_models(org_id);


================================================
FILE: app/server/migrations/2024042600_default_plan_settings.down.sql
================================================
DROP TABLE IF EXISTS default_plan_settings;

================================================
FILE: app/server/migrations/2024042600_default_plan_settings.up.sql
================================================
CREATE TABLE IF NOT EXISTS default_plan_settings (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,

  plan_settings JSON,

  updated_at TIMESTAMP NOT NULL DEFAULT NOW(),
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_default_plan_settings_modtime BEFORE UPDATE ON default_plan_settings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX default_plan_settings_org_idx ON default_plan_settings(org_id);


================================================
FILE: app/server/migrations/2024091800_sign_in_codes.down.sql
================================================
DROP TABLE IF EXISTS sign_in_codes;

================================================
FILE: app/server/migrations/2024091800_sign_in_codes.up.sql
================================================
CREATE TABLE IF NOT EXISTS sign_in_codes (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  pin_hash VARCHAR(64) NOT NULL,
  user_id UUID REFERENCES users(id),  
  org_id UUID REFERENCES orgs(id),
  auth_token_id UUID REFERENCES auth_tokens(id),
  created_at TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE TRIGGER update_sign_in_codes_modtime BEFORE UPDATE ON sign_in_codes FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX sign_in_codes_idx ON sign_in_codes(pin_hash, created_at DESC);

================================================
FILE: app/server/migrations/2024092100_remove_trial_fields.down.sql
================================================
ALTER TABLE auth_tokens ADD COLUMN is_trial BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE users ADD COLUMN is_trial BOOLEAN NOT NULL DEFAULT FALSE;

================================================
FILE: app/server/migrations/2024092100_remove_trial_fields.up.sql
================================================
ALTER TABLE auth_tokens DROP COLUMN is_trial;
ALTER TABLE users DROP COLUMN is_trial;

================================================
FILE: app/server/migrations/2024100900_update_locks.down.sql
================================================
-- Revert user_id to NOT NULL if no NULL values exist
DO $$ 
BEGIN
    -- Check for NULL values in user_id
    IF EXISTS (SELECT 1 FROM repo_locks WHERE user_id IS NULL) THEN
        RAISE EXCEPTION 'Cannot revert to NOT NULL, as there are rows with NULL values in user_id.';
    ELSE
        -- Proceed with setting the columns to NOT NULL
        ALTER TABLE repo_locks
          ALTER COLUMN user_id SET NOT NULL;
    END IF;
END $$;


================================================
FILE: app/server/migrations/2024100900_update_locks.up.sql
================================================
ALTER TABLE repo_locks
  ALTER COLUMN user_id DROP NOT NULL;


================================================
FILE: app/server/migrations/2024121400_plan_config.down.sql
================================================
ALTER TABLE plans DROP COLUMN IF EXISTS plan_config;

ALTER TABLE users DROP COLUMN IF EXISTS default_plan_config;

================================================
FILE: app/server/migrations/2024121400_plan_config.up.sql
================================================
ALTER TABLE plans ADD COLUMN IF NOT EXISTS plan_config JSON;

ALTER TABLE users ADD COLUMN IF NOT EXISTS default_plan_config JSON;


================================================
FILE: app/server/migrations/2025012600_update_custom_models.down.sql
================================================
ALTER TABLE custom_models DROP COLUMN preferred_output_format;

ALTER TABLE custom_models ADD COLUMN has_streaming BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE custom_models ADD COLUMN has_function_calling BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE custom_models ADD COLUMN has_streaming_function_calls BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE custom_models ADD COLUMN has_json_mode BOOLEAN NOT NULL DEFAULT FALSE;
ALTER TABLE custom_models ADD COLUMN is_openai_compatible BOOLEAN NOT NULL DEFAULT FALSE;

ALTER TABLE custom_models DROP COLUMN has_image_support;


================================================
FILE: app/server/migrations/2025012600_update_custom_models.up.sql
================================================
ALTER TABLE custom_models ADD COLUMN preferred_output_format VARCHAR(32) NOT NULL DEFAULT 'xml';

ALTER TABLE custom_models DROP COLUMN has_streaming_function_calls;
ALTER TABLE custom_models DROP COLUMN has_json_mode;
ALTER TABLE custom_models DROP COLUMN has_streaming;
ALTER TABLE custom_models DROP COLUMN has_function_calling;
ALTER TABLE custom_models DROP COLUMN is_openai_compatible;

ALTER TABLE custom_models ADD COLUMN has_image_support BOOLEAN NOT NULL DEFAULT FALSE;

================================================
FILE: app/server/migrations/2025021101_locks_unique.down.sql
================================================
DROP TABLE IF EXISTS lockable_plan_ids;
DROP INDEX IF EXISTS repo_locks_single_write_lock;

================================================
FILE: app/server/migrations/2025021101_locks_unique.up.sql
================================================

CREATE UNIQUE INDEX repo_locks_single_write_lock
  ON repo_locks(plan_id)
  WHERE (scope = 'w');

CREATE TABLE IF NOT EXISTS lockable_plan_ids (
  plan_id UUID NOT NULL PRIMARY KEY REFERENCES plans(id) ON DELETE CASCADE
);

================================================
FILE: app/server/migrations/2025022700_remove_models_col.down.sql
================================================
ALTER TABLE custom_models ADD COLUMN default_reserved_output_tokens INTEGER NOT NULL;

================================================
FILE: app/server/migrations/2025022700_remove_models_col.up.sql
================================================
ALTER TABLE custom_models DROP COLUMN default_reserved_output_tokens;

================================================
FILE: app/server/migrations/2025031300_add_model_roles.down.sql
================================================
ALTER TABLE model_sets DROP COLUMN context_loader;
ALTER TABLE model_sets DROP COLUMN whole_file_builder;
ALTER TABLE model_sets DROP COLUMN coder;

================================================
FILE: app/server/migrations/2025031300_add_model_roles.up.sql
================================================
ALTER TABLE model_sets ADD COLUMN context_loader JSON;
ALTER TABLE model_sets ADD COLUMN whole_file_builder JSON;
ALTER TABLE model_sets ADD COLUMN coder JSON;

================================================
FILE: app/server/migrations/2025031900_add_custom_model_cols.down.sql
================================================
ALTER TABLE custom_models DROP COLUMN max_output_tokens;
ALTER TABLE custom_models DROP COLUMN reserved_output_tokens;
ALTER TABLE custom_models DROP COLUMN model_id;


================================================
FILE: app/server/migrations/2025031900_add_custom_model_cols.up.sql
================================================
ALTER TABLE custom_models 
  ADD COLUMN max_output_tokens INTEGER NOT NULL,
  ADD COLUMN reserved_output_tokens INTEGER NOT NULL,
  ADD COLUMN model_id VARCHAR(255) NOT NULL;

================================================
FILE: app/server/migrations/2025032400_sign_in_codes_on_delete.down.sql
================================================
ALTER TABLE sign_in_codes
DROP CONSTRAINT sign_in_codes_org_id_fkey,
ADD CONSTRAINT sign_in_codes_org_id_fkey
FOREIGN KEY (org_id)
REFERENCES orgs(id);



================================================
FILE: app/server/migrations/2025032400_sign_in_codes_on_delete.up.sql
================================================
ALTER TABLE sign_in_codes
DROP CONSTRAINT sign_in_codes_org_id_fkey,
ADD CONSTRAINT sign_in_codes_org_id_fkey
FOREIGN KEY (org_id)
REFERENCES orgs(id)
ON DELETE SET NULL;



================================================
FILE: app/server/migrations/2025051600_custom_models_refactor.down.sql
================================================
DROP TABLE IF EXISTS custom_models;
DROP TABLE IF EXISTS custom_providers;

ALTER TABLE custom_models_legacy RENAME TO custom_models;


================================================
FILE: app/server/migrations/2025051600_custom_models_refactor.up.sql
================================================

BEGIN;
ALTER TABLE custom_models RENAME TO custom_models_legacy;

CREATE TABLE IF NOT EXISTS custom_models (
  id                       UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id                   UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,

  model_id                 VARCHAR(255) NOT NULL,
  description              TEXT,
  publisher                VARCHAR(64) NOT NULL DEFAULT '',

  max_tokens               INTEGER NOT NULL,
  default_max_convo_tokens INTEGER NOT NULL,
  max_output_tokens        INTEGER NOT NULL,
  reserved_output_tokens   INTEGER NOT NULL,

  has_image_support        BOOLEAN NOT NULL DEFAULT FALSE,
  preferred_output_format  VARCHAR(32) NOT NULL DEFAULT 'xml',

  system_prompt_disabled       BOOLEAN NOT NULL DEFAULT FALSE,
  role_params_disabled         BOOLEAN NOT NULL DEFAULT FALSE,
  stop_disabled                BOOLEAN NOT NULL DEFAULT FALSE,
  predicted_output_enabled     BOOLEAN NOT NULL DEFAULT FALSE,
  reasoning_effort_enabled     BOOLEAN NOT NULL DEFAULT FALSE,
  reasoning_effort             VARCHAR(32) NOT NULL DEFAULT '',
  include_reasoning            BOOLEAN NOT NULL DEFAULT FALSE,
  reasoning_budget             INTEGER NOT NULL DEFAULT 0,
  supports_cache_control       BOOLEAN NOT NULL DEFAULT FALSE,
  single_message_no_system_prompt BOOLEAN NOT NULL DEFAULT FALSE,
  token_estimate_padding_pct   FLOAT NOT NULL DEFAULT 0.0,

  providers JSON NOT NULL DEFAULT '[]',

  created_at               TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at               TIMESTAMP NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS cmv_org_idx ON custom_models(org_id);
CREATE UNIQUE INDEX IF NOT EXISTS cmv_unique_idx ON custom_models(org_id, model_id);

CREATE TRIGGER cmv_modtime BEFORE UPDATE ON custom_models
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE TABLE IF NOT EXISTS custom_providers (
  id              UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  org_id          UUID NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,

  name            VARCHAR(255) NOT NULL,          
  base_url        VARCHAR(255) NOT NULL,
  skip_auth       BOOLEAN NOT NULL DEFAULT FALSE,
  api_key_env_var VARCHAR(255),

  extra_auth_vars JSON NOT NULL DEFAULT '[]',

  created_at      TIMESTAMP NOT NULL DEFAULT NOW(),
  updated_at      TIMESTAMP NOT NULL DEFAULT NOW()                          
);
CREATE INDEX IF NOT EXISTS cp_org_idx ON custom_providers(org_id);
CREATE UNIQUE INDEX IF NOT EXISTS cp_unique_idx ON custom_providers(org_id, name);
CREATE TRIGGER cp_modtime BEFORE UPDATE ON custom_providers
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

/* ---- migrate base rows into the new custom_models ------------------ */
INSERT INTO custom_models (
    id, org_id, model_id, description,
    max_tokens, default_max_convo_tokens,
    max_output_tokens, reserved_output_tokens,
    has_image_support, preferred_output_format,

    providers,                 -- <-- aggregated JSON array
    created_at, updated_at
)
SELECT
    id, org_id, model_id, description,
    max_tokens, default_max_convo_tokens,
    max_output_tokens, reserved_output_tokens,
    has_image_support, preferred_output_format,

    /* -------- build a one-element providers array -------- */
    json_build_array(
        json_build_object(
            'provider',        provider,
            'custom_provider', custom_provider,
            'model_name',      model_name
        )
    )::json,

    created_at, updated_at
FROM custom_models_legacy
ON CONFLICT (org_id, model_id) DO NOTHING;

/* ---- migrate unique custom providers ------------------------------- */
WITH src AS (
  SELECT DISTINCT
         org_id,
         custom_provider AS name,
         base_url,
         api_key_env_var
  FROM   custom_models_legacy
  WHERE  custom_provider IS NOT NULL
)
INSERT INTO custom_providers (org_id, name, base_url, api_key_env_var)
SELECT org_id, name, base_url, api_key_env_var
FROM   src
ON CONFLICT (org_id, name) DO NOTHING;

COMMIT;

================================================
FILE: app/server/migrations/2025052200_model_pack_cols.down.sql
================================================
ALTER TABLE model_sets
  DROP COLUMN IF EXISTS updated_at;

DROP TRIGGER IF EXISTS model_set_modtime ON model_sets;

DROP INDEX IF EXISTS model_set_unique_idx;


================================================
FILE: app/server/migrations/2025052200_model_pack_cols.up.sql
================================================
ALTER TABLE model_sets
  ADD COLUMN updated_at TIMESTAMP NOT NULL DEFAULT NOW();

CREATE TRIGGER model_set_modtime BEFORE UPDATE ON model_sets
  FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();

CREATE UNIQUE INDEX IF NOT EXISTS model_set_unique_idx ON model_sets(org_id, name);

================================================
FILE: app/server/migrations/2025070200_add_org_user_config.down.sql
================================================
ALTER TABLE orgs_users DROP COLUMN config;

================================================
FILE: app/server/migrations/2025070200_add_org_user_config.up.sql
================================================
ALTER TABLE orgs_users ADD COLUMN config JSON;

================================================
FILE: app/server/model/client.go
================================================
package model

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"plandex-server/db"
	"plandex-server/types"
	"strings"
	"sync"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
	"github.com/sashabaranov/go-openai"
)

// note that we are *only* using streaming requests now
// non-streaming request handling has been removed completely
// streams offer more predictable cancellation partial results

const (
	ACTIVE_STREAM_CHUNK_TIMEOUT          = time.Duration(60) * time.Second
	USAGE_CHUNK_TIMEOUT                  = time.Duration(10) * time.Second
	MAX_ADDITIONAL_RETRIES_WITH_FALLBACK = 1
	MAX_RETRIES_WITHOUT_FALLBACK         = 3
	MAX_RETRY_DELAY_SECONDS              = 10
)

var httpClient = &http.Client{}

type ClientInfo struct {
	Client         *openai.Client
	ProviderConfig shared.ModelProviderConfigSchema
	ApiKey         string
	OpenAIOrgId    string
}

func InitClients(authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig) map[string]ClientInfo {
	clients := make(map[string]ClientInfo)
	providers := shared.GetProvidersForAuthVars(authVars, settings, orgUserConfig)

	for _, provider := range providers {
		clients[provider.ToComposite()] = newClient(provider, authVars)
	}

	return clients
}

func newClient(providerConfig shared.ModelProviderConfigSchema, authVars map[string]string) ClientInfo {
	var apiKey string
	if providerConfig.ApiKeyEnvVar != "" {
		apiKey = authVars[providerConfig.ApiKeyEnvVar]
	} else if providerConfig.HasClaudeMaxAuth {
		apiKey = authVars[shared.AnthropicClaudeMaxTokenEnvVar]
	}

	config := openai.DefaultConfig(apiKey)
	config.BaseURL = providerConfig.BaseUrl

	var openAIOrgId string
	if providerConfig.Provider == shared.ModelProviderOpenAI && authVars["OPENAI_ORG_ID"] != "" {
		openAIOrgId = authVars["OPENAI_ORG_ID"]
		config.OrgID = openAIOrgId
	}

	return ClientInfo{
		Client:         openai.NewClientWithConfig(config),
		ApiKey:         apiKey,
		ProviderConfig: providerConfig,
		OpenAIOrgId:    openAIOrgId,
	}
}

// ExtendedChatCompletionStream can wrap either a native OpenAI stream or our custom implementation
type ExtendedChatCompletionStream struct {
	openaiStream *openai.ChatCompletionStream
	customReader *StreamReader[types.ExtendedChatCompletionStreamResponse]
	ctx          context.Context
}

// StreamReader handles the SSE stream reading
type StreamReader[T any] struct {
	reader             *bufio.Reader
	response           *http.Response
	emptyMessagesLimit int
	errAccumulator     *ErrorAccumulator
	unmarshaler        *JSONUnmarshaler
}

// ErrorAccumulator keeps track of errors during streaming
type ErrorAccumulator struct {
	errors []error
	mu     sync.Mutex
}

// JSONUnmarshaler handles JSON unmarshaling for stream responses
type JSONUnmarshaler struct{}

func CreateChatCompletionStream(
	clients map[string]ClientInfo,
	authVars map[string]string,
	modelConfig *shared.ModelRoleConfig,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	currentOrgId string,
	currentUserId string,
	ctx context.Context,
	req types.ExtendedChatCompletionRequest,
) (*ExtendedChatCompletionStream, error) {
	providerComposite := modelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
	_, ok := clients[providerComposite]
	if !ok {
		return nil, fmt.Errorf("client not found for provider composite: %s", providerComposite)
	}

	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)

	// ensure the model name is set correctly on fallbacks
	req.Model = baseModelConfig.ModelName

	resolveReq(&req, modelConfig, baseModelConfig, settings)

	// choose the fastest provider by latency/throughput on openrouter
	if baseModelConfig.Provider == shared.ModelProviderOpenRouter {
		if !strings.HasSuffix(string(req.Model), ":nitro") && !strings.HasSuffix(string(req.Model), ":free") && !strings.HasSuffix(string(req.Model), ":floor") {
			req.Model += ":nitro"
		}
	}

	if baseModelConfig.ReasoningBudget > 0 {
		req.ReasoningConfig = &types.ReasoningConfig{
			MaxTokens: baseModelConfig.ReasoningBudget,
			Exclude:   !baseModelConfig.IncludeReasoning || baseModelConfig.HideReasoning,
		}
	} else if baseModelConfig.ReasoningEffortEnabled {
		req.ReasoningConfig = &types.ReasoningConfig{
			Effort:  shared.ReasoningEffort(baseModelConfig.ReasoningEffort),
			Exclude: !baseModelConfig.IncludeReasoning || baseModelConfig.HideReasoning,
		}
	} else if baseModelConfig.IncludeReasoning {
		req.ReasoningConfig = &types.ReasoningConfig{
			Exclude: baseModelConfig.HideReasoning,
		}
	}

	return withStreamingRetries(ctx, func(numTotalRetry int, didProviderFallback bool, modelErr *shared.ModelError) (*ExtendedChatCompletionStream, shared.FallbackResult, error) {
		handleClaudeMaxRateLimitedIfNeeded(
			modelErr,
			modelConfig,
			authVars,
			settings,
			orgUserConfig,
			currentOrgId,
			currentUserId,
		)

		fallbackRes := modelConfig.GetFallbackForModelError(
			numTotalRetry,
			didProviderFallback,
			modelErr,
			authVars,
			settings,
			orgUserConfig,
		)
		resolvedModelConfig := fallbackRes.ModelRoleConfig

		if resolvedModelConfig == nil {
			return nil, fallbackRes, fmt.Errorf("model config is nil")
		}

		providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings, orgUserConfig)

		baseModelConfig := resolvedModelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)

		opClient, ok := clients[providerComposite]

		if !ok {
			return nil, fallbackRes, fmt.Errorf("client not found for provider composite: %s", providerComposite)
		}

		if modelErr != nil && modelErr.Kind == shared.ErrCacheSupport {
			for i := range req.Messages {
				for j := range req.Messages[i].Content {
					if req.Messages[i].Content[j].CacheControl != nil {
						req.Messages[i].Content[j].CacheControl = nil
					}
				}
			}
		}

		modelConfig = resolvedModelConfig

		log.Println("createChatCompletionStreamExtended - modelConfig")
		spew.Dump(map[string]interface{}{
			"modelConfig.ModelId":      baseModelConfig.ModelId,
			"modelConfig.ModelTag":     baseModelConfig.ModelTag,
			"modelConfig.ModelName":    baseModelConfig.ModelName,
			"modelConfig.Provider":     baseModelConfig.Provider,
			"modelConfig.BaseUrl":      baseModelConfig.BaseUrl,
			"modelConfig.ApiKeyEnvVar": baseModelConfig.ApiKeyEnvVar,
		})

		resp, err := createChatCompletionStreamExtended(resolvedModelConfig, opClient, authVars, settings, orgUserConfig, ctx, req)
		return resp, fallbackRes, err
	}, func(resp *ExtendedChatCompletionStream, err error) {})
}

func createChatCompletionStreamExtended(
	modelConfig *shared.ModelRoleConfig,
	client ClientInfo,
	authVars map[string]string,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	ctx context.Context,
	extendedReq types.ExtendedChatCompletionRequest,
) (*ExtendedChatCompletionStream, error) {
	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)

	// ensure the model name is set correctly on fallbacks
	extendedReq.Model = baseModelConfig.ModelName

	var openaiReq *types.ExtendedOpenAIChatCompletionRequest
	if baseModelConfig.Provider == shared.ModelProviderOpenAI {
		openaiReq = extendedReq.ToOpenAI()
		log.Println("Creating chat completion stream with direct OpenAI provider request")
	}

	switch baseModelConfig.Provider {
	case shared.ModelProviderGoogleVertex:
		if authVars["VERTEXAI_PROJECT"] != "" {
			extendedReq.VertexProject = authVars["VERTEXAI_PROJECT"]
		}
		if authVars["VERTEXAI_LOCATION"] != "" {
			extendedReq.VertexLocation = authVars["VERTEXAI_LOCATION"]
		}
		if authVars["GOOGLE_APPLICATION_CREDENTIALS"] != "" {
			extendedReq.VertexCredentials = authVars["GOOGLE_APPLICATION_CREDENTIALS"]
		}
	case shared.ModelProviderAzureOpenAI:
		if authVars["AZURE_API_BASE"] != "" {
			extendedReq.LiteLLMApiBase = authVars["AZURE_API_BASE"]
		}
		if authVars["AZURE_API_VERSION"] != "" {
			extendedReq.AzureApiVersion = authVars["AZURE_API_VERSION"]
		}

		if authVars["AZURE_DEPLOYMENTS_MAP"] != "" {
			var azureDeploymentsMap map[string]string
			err := json.Unmarshal([]byte(authVars["AZURE_DEPLOYMENTS_MAP"]), &azureDeploymentsMap)
			if err != nil {
				return nil, fmt.Errorf("error unmarshalling AZURE_DEPLOYMENTS_MAP: %w", err)
			}
			modelName := string(extendedReq.Model)
			modelName = strings.ReplaceAll(modelName, "azure/", "")

			deploymentName, ok := azureDeploymentsMap[modelName]
			if ok {
				log.Println("azure - deploymentName", deploymentName)
				modelName = "azure/" + deploymentName
				extendedReq.Model = shared.ModelName(modelName)
			}
		}

		// azure uses 'reasoning_config' instead of 'reasoning' like direct openai api
		if extendedReq.ReasoningConfig != nil {
			extendedReq.AzureReasoningEffort = extendedReq.ReasoningConfig.Effort
			extendedReq.ReasoningConfig = nil
		}
	case shared.ModelProviderAmazonBedrock:
		if authVars["AWS_ACCESS_KEY_ID"] != "" {
			extendedReq.BedrockAccessKeyId = authVars["AWS_ACCESS_KEY_ID"]
		}
		if authVars["AWS_SECRET_ACCESS_KEY"] != "" {
			extendedReq.BedrockSecretAccessKey = authVars["AWS_SECRET_ACCESS_KEY"]
		}
		if authVars["AWS_SESSION_TOKEN"] != "" {
			extendedReq.BedrockSessionToken = authVars["AWS_SESSION_TOKEN"]
		}
		if authVars["AWS_REGION"] != "" {
			extendedReq.BedrockRegion = authVars["AWS_REGION"]
		}
		if authVars["AWS_INFERENCE_PROFILE_ARN"] != "" {
			extendedReq.BedrockInferenceProfileArn = authVars["AWS_INFERENCE_PROFILE_ARN"]
		}

	case shared.ModelProviderOllama:
		if os.Getenv("OLLAMA_BASE_URL") != "" {
			extendedReq.LiteLLMApiBase = os.Getenv("OLLAMA_BASE_URL")
		}
	}

	if client.ProviderConfig.HasClaudeMaxAuth {
		extendedReq.Messages = append([]types.ExtendedChatMessage{
			{
				Role: openai.ChatMessageRoleSystem,
				Content: []types.ExtendedChatMessagePart{
					{Type: openai.ChatMessagePartTypeText,
						Text: "You are Claude Code, Anthropic's official CLI for Claude."},
				},
			},
		}, extendedReq.Messages...)

		if extendedReq.ExtraHeaders == nil {
			extendedReq.ExtraHeaders = make(map[string]string)
		}
		extendedReq.ExtraHeaders["anthropic-beta"] = shared.AnthropicClaudeMaxBetaHeader
		extendedReq.ExtraHeaders["Authorization"] = "Bearer " + authVars[shared.AnthropicClaudeMaxTokenEnvVar]
		extendedReq.ExtraHeaders["anthropic-product"] = "claude-code"

	}

	// Marshal the request body to JSON
	var jsonBody []byte
	var err error
	if openaiReq != nil {
		jsonBody, err = json.Marshal(openaiReq)
	} else {
		jsonBody, err = json.Marshal(extendedReq)
	}
	if err != nil {
		return nil, fmt.Errorf("error marshaling request: %w", err)
	}

	// log.Println("request jsonBody", string(jsonBody))

	// Create new request
	baseUrl := baseModelConfig.BaseUrl
	url := baseUrl + "/chat/completions"

	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBody))
	if err != nil {
		return nil, fmt.Errorf("error creating request: %w", err)
	}

	// Set required headers for streaming
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "text/event-stream")
	req.Header.Set("Cache-Control", "no-cache")
	req.Header.Set("Connection", "keep-alive")

	// some providers send api key in the body, some in the header
	// some use other auth methods and so don't have a simple api key
	if client.ApiKey != "" {
		req.Header.Set("Authorization", "Bearer "+client.ApiKey)
	}
	if client.OpenAIOrgId != "" {
		req.Header.Set("OpenAI-Organization", client.OpenAIOrgId)
	}

	addOpenRouterHeaders(req)

	// Send the request
	resp, err := httpClient.Do(req) //nolint:bodyclose // body is closed in stream.Close()
	if err != nil {
		return nil, fmt.Errorf("error making request: %w", err)
	}

	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusBadRequest {
		defer resp.Body.Close()
		body, err := io.ReadAll(resp.Body)
		if err != nil {
			return nil, fmt.Errorf("error reading error response: %w", err)
		}
		return nil, &HTTPError{
			StatusCode: resp.StatusCode,
			Body:       string(body),
			Header:     resp.Header.Clone(), // retain Retry-After etc.
		}
	}

	// Log response headers
	// log.Println("Response headers:")
	// for key, values := range resp.Header {
	// 	log.Printf("%s: %v\n", key, values)
	// }

	reader := &StreamReader[types.ExtendedChatCompletionStreamResponse]{
		reader:             bufio.NewReader(resp.Body),
		response:           resp,
		emptyMessagesLimit: 30,
		errAccumulator:     NewErrorAccumulator(),
		unmarshaler:        &JSONUnmarshaler{},
	}

	return &ExtendedChatCompletionStream{
		customReader: reader,
		ctx:          ctx,
	}, nil
}

func NewErrorAccumulator() *ErrorAccumulator {
	return &ErrorAccumulator{
		errors: make([]error, 0),
	}
}

func (ea *ErrorAccumulator) Add(err error) {
	ea.mu.Lock()
	defer ea.mu.Unlock()
	ea.errors = append(ea.errors, err)
}

func (ea *ErrorAccumulator) GetErrors() []error {
	ea.mu.Lock()
	defer ea.mu.Unlock()
	return ea.errors
}

func (ju *JSONUnmarshaler) Unmarshal(data []byte, v interface{}) error {
	return json.Unmarshal(data, v)
}

// Recv reads from the stream
func (stream *StreamReader[T]) Recv() (*T, error) {
	for {
		line, err := stream.reader.ReadString('\n')
		if err != nil {
			return nil, err
		}

		// Trim any whitespace
		line = strings.TrimSpace(line)

		// Skip empty lines
		if line == "" {
			continue
		}

		// Check for data prefix
		if !strings.HasPrefix(line, "data: ") {
			continue
		}

		// Extract the data
		data := strings.TrimPrefix(line, "data: ")

		// log.Println("\n\n--- stream data:\n", data, "\n\n")

		// Check for stream completion
		if data == "[DONE]" {
			return nil, io.EOF
		}

		// Parse the response
		var response T
		err = stream.unmarshaler.Unmarshal([]byte(data), &response)
		if err != nil {
			stream.errAccumulator.Add(err)
			continue
		}

		return &response, nil
	}
}

func (stream *StreamReader[T]) Close() error {
	if stream.response != nil {
		return stream.response.Body.Close()
	}
	return nil
}

// Recv returns the next message in the stream
func (stream *ExtendedChatCompletionStream) Recv() (*types.ExtendedChatCompletionStreamResponse, error) {
	select {
	case <-stream.ctx.Done():
		return nil, stream.ctx.Err()
	default:
		if stream.openaiStream != nil {
			bytes, err := stream.openaiStream.RecvRaw()
			if err != nil {
				return nil, err
			}

			var response types.ExtendedChatCompletionStreamResponse
			err = json.Unmarshal(bytes, &response)
			if err != nil {
				return nil, err
			}
			return &response, nil
		}
		return stream.customReader.Recv()
	}
}

// Close the response body
func (stream *ExtendedChatCompletionStream) Close() error {
	if stream.openaiStream != nil {
		return stream.openaiStream.Close()
	}
	return stream.customReader.Close()
}

func resolveReq(req *types.ExtendedChatCompletionRequest, modelConfig *shared.ModelRoleConfig, baseModelConfig *shared.BaseModelConfig, settings *shared.PlanSettings) {
	// if system prompt is disabled, change the role of the system message to user
	if modelConfig.GetSharedBaseConfig(settings).SystemPromptDisabled {
		log.Println("System prompt disabled - changing role of system message to user")
		for i, msg := range req.Messages {
			log.Println("Message role:", msg.Role)
			if msg.Role == openai.ChatMessageRoleSystem {
				log.Println("Changing role of system message to user")
				req.Messages[i].Role = openai.ChatMessageRoleUser
			}
		}

		for _, msg := range req.Messages {
			log.Println("Final message role:", msg.Role)
		}
	}

	if modelConfig.GetSharedBaseConfig(settings).RoleParamsDisabled {
		log.Println("Role params disabled - setting temperature and top p to 0")
		req.Temperature = 0
		req.TopP = 0
	}

	if baseModelConfig.Provider == shared.ModelProviderOllama {
		// ollama doesn't support temperature or top p params
		log.Println("Ollama - clearing temperature and top p")
		req.Temperature = 0
		req.TopP = 0

	}
}

func addOpenRouterHeaders(req *http.Request) {
	req.Header.Set("HTTP-Referer", "https://plandex.ai")
	req.Header.Set("X-Title", "Plandex")
	req.Header.Set("X-OR-Prefer", "ttft,throughput")
	if os.Getenv("GOENV") == "production" {
		req.Header.Set("X-OR-Region", "us-east-1")
	}
}

func handleClaudeMaxRateLimitedIfNeeded(modelErr *shared.ModelError, modelConfig *shared.ModelRoleConfig, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, currentOrgId string, currentUserId string) {

	// if we used a claude max provider and got rate limited, set the cooldown on org user config and update the db in the background
	if modelErr != nil && modelErr.Kind == shared.ErrRateLimited && modelErr.RetryAfterSeconds == 0 {
		baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)
		if baseModelConfig.BaseModelProviderConfig.HasClaudeMaxAuth {
			orgUserConfig.ClaudeSubscriptionCooldownStartedAt = time.Now()

			go func() {
				err := db.UpdateOrgUserConfig(currentUserId, currentOrgId, orgUserConfig)
				if err != nil {
					log.Printf("Error updating org user config: %v\n", err)
				}
			}()
		}
	}

}


================================================
FILE: app/server/model/client_stream.go
================================================
package model

import (
	"context"
	"fmt"
	"io"
	"log"
	"math/rand"
	"plandex-server/types"
	shared "plandex-shared"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/sashabaranov/go-openai"
)

type OnStreamFn func(chunk string, buffer string) (shouldStop bool)

func CreateChatCompletionWithInternalStream(
	clients map[string]ClientInfo,
	authVars map[string]string,
	modelConfig *shared.ModelRoleConfig,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	currentOrgId string,
	currentUserId string,
	ctx context.Context,
	req types.ExtendedChatCompletionRequest,
	onStream OnStreamFn,
	reqStarted time.Time,
) (*types.ModelResponse, error) {
	providerComposite := modelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
	_, ok := clients[providerComposite]
	if !ok {
		return nil, fmt.Errorf("client not found for provider composite: %s", providerComposite)
	}

	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)

	resolveReq(&req, modelConfig, baseModelConfig, settings)

	// choose the fastest provider by latency/throughput on openrouter
	if baseModelConfig.Provider == shared.ModelProviderOpenRouter {
		req.Model += ":nitro"
	}

	// Force streaming mode since we're using the streaming API
	req.Stream = true

	// Include usage in stream response
	req.StreamOptions = &openai.StreamOptions{
		IncludeUsage: true,
	}

	return withStreamingRetries(ctx, func(numTotalRetry int, didProviderFallback bool, modelErr *shared.ModelError) (resp *types.ModelResponse, fallbackRes shared.FallbackResult, err error) {
		handleClaudeMaxRateLimitedIfNeeded(modelErr, modelConfig, authVars, settings, orgUserConfig, currentOrgId, currentUserId)

		fallbackRes = modelConfig.GetFallbackForModelError(numTotalRetry, didProviderFallback, modelErr, authVars, settings, orgUserConfig)
		resolvedModelConfig := fallbackRes.ModelRoleConfig

		if resolvedModelConfig == nil {
			return nil, fallbackRes, fmt.Errorf("model config is nil")
		}

		providerComposite := resolvedModelConfig.GetProviderComposite(authVars, settings, orgUserConfig)
		opClient, ok := clients[providerComposite]

		if !ok {
			return nil, fallbackRes, fmt.Errorf("client not found for provider composite: %s", providerComposite)
		}

		modelConfig = resolvedModelConfig
		resp, err = processChatCompletionStream(resolvedModelConfig, opClient, authVars, settings, orgUserConfig, ctx, req, onStream, reqStarted)
		if err != nil {
			return nil, fallbackRes, err
		}
		return resp, fallbackRes, nil
	}, func(resp *types.ModelResponse, err error) {
		if resp != nil {
			resp.Stopped = true
			resp.Error = err.Error()
		}
	})
}

func processChatCompletionStream(
	modelConfig *shared.ModelRoleConfig,
	client ClientInfo,
	authVars map[string]string,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	ctx context.Context,
	req types.ExtendedChatCompletionRequest,
	onStream OnStreamFn,
	reqStarted time.Time,
) (*types.ModelResponse, error) {
	streamCtx, cancel := context.WithCancel(ctx)

	log.Println("processChatCompletionStream - modelConfig", spew.Sdump(map[string]interface{}{
		"model": modelConfig.ModelId,
	}))

	stream, err := createChatCompletionStreamExtended(modelConfig, client, authVars, settings, orgUserConfig, streamCtx, req)

	if err != nil {
		cancel()
		return nil, fmt.Errorf("error creating chat completion stream: %w", err)
	}

	defer stream.Close()
	defer cancel()

	accumulator := types.NewStreamCompletionAccumulator()
	// Create a timer that will trigger if no chunk is received within the specified duration
	timer := time.NewTimer(ACTIVE_STREAM_CHUNK_TIMEOUT)
	defer timer.Stop()
	streamFinished := false

	receivedFirstChunk := false

	// Process stream until EOF or error
	for {
		select {
		case <-streamCtx.Done():
			log.Println("Stream canceled")
			return accumulator.Result(true, streamCtx.Err()), streamCtx.Err()
		case <-timer.C:
			log.Println("Stream timed out due to inactivity")
			if streamFinished {
				log.Println("Stream finished—timed out waiting for usage chunk")
				return accumulator.Result(false, nil), nil
			} else {
				log.Println("Stream timed out due to inactivity")
				return accumulator.Result(true, fmt.Errorf("stream timed out due to inactivity. The model is not responding.")), nil
			}
		default:
			response, err := stream.Recv()
			if err == io.EOF {
				if streamFinished {
					return accumulator.Result(false, nil), nil
				}

				err = fmt.Errorf("model stream ended unexpectedly: %w", err)
				return accumulator.Result(true, err), err
			}
			if err != nil {
				err = fmt.Errorf("error receiving stream chunk: %w", err)
				return accumulator.Result(true, err), err
			}

			if response.ID != "" {
				accumulator.SetGenerationId(response.ID)
			}

			if !receivedFirstChunk {
				receivedFirstChunk = true
				accumulator.SetFirstTokenAt(time.Now())
			}

			if !timer.Stop() {
				<-timer.C
			}
			timer.Reset(ACTIVE_STREAM_CHUNK_TIMEOUT)

			// Process the response
			if response.Usage != nil {
				accumulator.SetUsage(response.Usage)
				return accumulator.Result(false, nil), nil
			}

			emptyChoices := false
			var content string

			if len(response.Choices) == 0 {
				// Previously we'd return an error if there were no choices, but some models do this and then keep streaming, so we'll just log it and continue
				log.Println("processChatCompletionStream - no choices in response")
				// err := fmt.Errorf("no choices in response")
				// return accumulator.Result(false, err), err
				emptyChoices = true
			}

			// We'll be more accepting of multiple choices and just take the first one
			// if len(response.Choices) > 1 {
			// 	err = fmt.Errorf("stream finished with more than one choice | The model failed to generate a valid response.")
			// 	return accumulator.Result(true, err), err
			// }

			if !emptyChoices {
				choice := response.Choices[0]

				if choice.FinishReason != "" {
					if choice.FinishReason == "error" {
						err = fmt.Errorf("model stopped with error status | The model is not responding.")
						return accumulator.Result(true, err), err
					} else {
						// Reset the timer for the usage chunk
						if !timer.Stop() {
							<-timer.C
						}
						timer.Reset(USAGE_CHUNK_TIMEOUT)
						streamFinished = true
						continue
					}
				}

				if req.Tools != nil {
					if choice.Delta.ToolCalls != nil {
						toolCall := choice.Delta.ToolCalls[0]
						content = toolCall.Function.Arguments
					}
				} else {
					if choice.Delta.Content != "" {
						content = choice.Delta.Content
					}
				}
			}

			accumulator.AddContent(content)
			// pass the chunk and the accumulated content to the callback
			if onStream != nil {
				shouldReturn := onStream(content, accumulator.Content())
				if shouldReturn {
					return accumulator.Result(false, nil), nil
				}
			}
		}
	}
}

func withStreamingRetries[T any](
	ctx context.Context,
	operation func(numRetry int, didProviderFallback bool, modelErr *shared.ModelError) (resp *T, fallbackRes shared.FallbackResult, err error),
	onContextDone func(resp *T, err error),
) (*T, error) {
	var resp *T
	var numTotalRetry int
	var numFallbackRetry int
	var fallbackRes shared.FallbackResult
	var modelErr *shared.ModelError
	var didProviderFallback bool

	for {
		if ctx.Err() != nil {
			if resp != nil {
				// Return partial result with context error
				onContextDone(resp, ctx.Err())
				return resp, ctx.Err()
			}
			return nil, ctx.Err()
		}

		var err error

		var numRetry int
		if numFallbackRetry > 0 {
			numRetry = numFallbackRetry
		} else {
			numRetry = numTotalRetry
		}

		log.Printf("withStreamingRetries - will run operation")

		log.Println(spew.Sdump(map[string]interface{}{
			"numTotalRetry":       numTotalRetry,
			"didProviderFallback": didProviderFallback,
			"modelErr":            modelErr,
		}))

		resp, fallbackRes, err = operation(numTotalRetry, didProviderFallback, modelErr)
		if err == nil {
			return resp, nil
		}

		log.Printf("withStreamingRetries - operation returned error: %v", err)

		isFallback := fallbackRes.IsFallback
		maxRetries := MAX_RETRIES_WITHOUT_FALLBACK
		if isFallback {
			maxRetries = MAX_ADDITIONAL_RETRIES_WITH_FALLBACK
		}

		if fallbackRes.FallbackType == shared.FallbackTypeProvider {
			didProviderFallback = true
		}

		compareRetries := numTotalRetry
		if isFallback {
			compareRetries = numFallbackRetry
		}

		log.Printf("Error in streaming operation: %v, isFallback: %t, numTotalRetry: %d, numFallbackRetry: %d, numRetry: %d, compareRetries: %d, maxRetries: %d\n", err, isFallback, numTotalRetry, numFallbackRetry, numRetry, compareRetries, maxRetries)

		classifyRes := classifyBasicError(err, fallbackRes.BaseModelConfig.HasClaudeMaxAuth)
		modelErr = &classifyRes

		newFallback := false
		if !modelErr.Retriable {
			log.Printf("withStreamingRetries - operation returned non-retriable error: %v", err)
			spew.Dump(modelErr)
			if modelErr.Kind == shared.ErrContextTooLong && fallbackRes.ModelRoleConfig.LargeContextFallback == nil {
				log.Printf("withStreamingRetries - non-retriable context too long error and no large context fallback is defined, returning error")
				// if it's a context too long error and no large context fallback is defined, return the error
				return resp, err
			} else if modelErr.Kind != shared.ErrContextTooLong && fallbackRes.ModelRoleConfig.ErrorFallback == nil {
				log.Printf("withStreamingRetries - non-retriable error and no error fallback is defined, returning error")
				// if it's any other error and no error fallback is defined, return the error
				return resp, err
			}
			log.Printf("withStreamingRetries - operation returned non-retriable error, but has fallback - resetting numFallbackRetry to 0 and continuing to retry")
			numFallbackRetry = 0
			newFallback = true
			compareRetries = 0
			// otherwise, continue to retry logic
		}

		if compareRetries >= maxRetries {
			log.Printf("withStreamingRetries - compareRetries >= maxRetries - returning error")
			return resp, err
		}

		var retryDelay time.Duration
		if modelErr != nil && modelErr.RetryAfterSeconds > 0 {
			// if the model err has a retry after, then use that with a bit of padding
			retryDelay = time.Duration(int(float64(modelErr.RetryAfterSeconds)*1.1)) * time.Second
		} else {
			// otherwise, use some jitter
			retryDelay = time.Duration(1000+rand.Intn(200)) * time.Millisecond
		}

		log.Printf("withStreamingRetries - retrying stream in %v seconds", retryDelay)
		time.Sleep(retryDelay)

		if modelErr != nil && modelErr.ShouldIncrementRetry() {
			numTotalRetry++
			if isFallback && !newFallback {
				numFallbackRetry++
			}
		}
	}
}


================================================
FILE: app/server/model/litellm.go
================================================
package model

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/exec"
	"strconv"
	"sync"
	"time"
)

var (
	liteLLMOnce sync.Once
	liteLLMCmd  *exec.Cmd
)

func EnsureLiteLLM(numWorkers int) error {
	var finalErr error
	liteLLMOnce.Do(func() {
		if isLiteLLMHealthy() {
			log.Println("LiteLLM proxy is already healthy")
			return
		}

		log.Println("LiteLLM proxy is not running. Starting...")

		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()

		err := startLiteLLMServer(numWorkers)
		if err != nil {
			log.Println("LiteLLM proxy launch failed:", err)
			finalErr = fmt.Errorf("LiteLLM proxy launch failed: %w", err)
			return
		}

		ticker := time.NewTicker(500 * time.Millisecond)
		defer ticker.Stop()

		for {
			select {
			case <-ctx.Done():
				log.Println("LiteLLM proxy launch timed out")
				finalErr = fmt.Errorf("LiteLLM proxy launch timed out")
				return
			case <-ticker.C:
				if isLiteLLMHealthy() {
					log.Println("LiteLLM proxy is healthy")
					return
				} else {
					log.Println("LiteLLM proxy is not healthy yet, retrying after 500ms...")
				}
			}
		}
	})

	return finalErr
}

func ShutdownLiteLLMServer() error {
	if liteLLMCmd != nil && liteLLMCmd.Process != nil {
		log.Println("Shutting down LiteLLM proxy gracefully...")
		if err := liteLLMCmd.Process.Signal(os.Interrupt); err != nil {
			return fmt.Errorf("failed to signal LiteLLM for shutdown: %w", err)
		}

		done := make(chan error, 1)
		go func() {
			done <- liteLLMCmd.Wait()
		}()

		select {
		case <-time.After(5 * time.Second):
			log.Println("LiteLLM proxy shutdown timed out, forcing kill")
			return liteLLMCmd.Process.Kill()
		case err := <-done:
			return err
		}
	}
	return nil
}

func isLiteLLMHealthy() bool {
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "GET", "http://localhost:4000/health", nil)
	if err != nil {
		log.Println("LiteLLM health check request failed:", err)
		return false
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Println("LiteLLM health check failed:", err)
		return false
	}
	defer resp.Body.Close()

	return resp.StatusCode == 200
}

func startLiteLLMServer(numWorkers int) error {
	liteLLMCmd = exec.Command("python3",
		"-m", "uvicorn",
		"litellm_proxy:app",
		"--host", "0.0.0.0",
		"--port", "4000",
		"--workers", strconv.Itoa(numWorkers),
	)

	if os.Getenv("LITELLM_PROXY_DIR") != "" {
		liteLLMCmd.Dir = os.Getenv("LITELLM_PROXY_DIR")
	}

	// clean env
	liteLLMCmd.Env = []string{
		"PATH=" + os.Getenv("PATH"),
		"HOME=" + os.Getenv("HOME"),
	}

	if os.Getenv("OLLAMA_BASE_URL") != "" {
		log.Println("OLLAMA_BASE_URL is set, so we can reach ollama from inside docker container in local mode")
		// so we can reach ollama from inside docker container in local mode
		liteLLMCmd.Env = append(liteLLMCmd.Env, "OLLAMA_BASE_URL="+os.Getenv("OLLAMA_BASE_URL"))
	}

	liteLLMCmd.Stdout = os.Stdout
	liteLLMCmd.Stderr = os.Stderr

	err := liteLLMCmd.Start()
	if err != nil {
		return err
	}

	log.Println("LiteLLM proxy launched")
	return nil
}


================================================
FILE: app/server/model/model_error.go
================================================
package model

import (
	"fmt"
	"log"
	"net/http"
	shared "plandex-shared"
	"regexp"
	"strconv"
	"strings"
	"time"
)

type HTTPError struct {
	StatusCode int
	Body       string
	Header     http.Header
}

func (e *HTTPError) Error() string {
	return fmt.Sprintf("status code: %d, body: %s", e.StatusCode, e.Body)
}

// JSON-style  `"retry_after_ms":1234`
var reJSON = regexp.MustCompile(`"retry_after_ms"\s*:\s*(\d+)`)

// Header- or text-style  "Retry-After: 12" / "retry_after: 12s"
var reRetryAfter = regexp.MustCompile(
	`retry[_\-\s]?after[_\-\s]?(?:[:\s]+)?(\d+)(ms|seconds?|secs?|s)?`,
)

// Free-form Azure style  "Try again in 59 seconds."
// Also matches "Retry in 10 seconds."
var reTryAgain = regexp.MustCompile(
	`(?:re)?try[_\-\s]+(?:again[_\-\s]+)?in[_\-\s]+(\d+)(ms|seconds?|secs?|s)?`,
)

func ClassifyErrMsg(msg string) *shared.ModelError {
	log.Printf("Classifying error message: %s", msg)

	msg = strings.ToLower(msg)

	if strings.Contains(msg, "maximum context length") ||
		strings.Contains(msg, "context length exceeded") ||
		strings.Contains(msg, "exceed context limit") ||
		strings.Contains(msg, "decrease input length") ||
		strings.Contains(msg, "too many tokens") ||
		strings.Contains(msg, "payload too large") ||
		strings.Contains(msg, "payload is too large") ||
		strings.Contains(msg, "input is too large") ||
		strings.Contains(msg, "input too large") ||
		strings.Contains(msg, "input is too long") ||
		strings.Contains(msg, "input too long") {
		log.Printf("Context too long error: %s", msg)
		return &shared.ModelError{
			Kind:              shared.ErrContextTooLong,
			Retriable:         false,
			RetryAfterSeconds: 0,
		}
	}

	if strings.Contains(msg, "model_overloaded") ||
		strings.Contains(msg, "model overloaded") ||
		strings.Contains(msg, "server is overloaded") ||
		strings.Contains(msg, "model is currently overloaded") ||
		strings.Contains(msg, "overloaded_error") ||
		strings.Contains(msg, "resource has been exhausted") {
		log.Printf("Overloaded error: %s", msg)
		return &shared.ModelError{
			Kind:              shared.ErrOverloaded,
			Retriable:         true,
			RetryAfterSeconds: 0,
		}
	}

	if strings.Contains(msg, "cache control") {
		log.Printf("Cache control error: %s", msg)
		return &shared.ModelError{
			Kind:              shared.ErrCacheSupport,
			Retriable:         true,
			RetryAfterSeconds: 0,
		}
	}

	log.Println("No error classification based on message")

	return nil
}

func ClassifyModelError(code int, message string, headers http.Header, isClaudeMax bool) shared.ModelError {
	msg := strings.ToLower(message)

	// first of all, if it's claude max and a 429, it means the subscription limit was reached, so handle it accordingly
	if isClaudeMax && code == 429 {
		retryAfter := extractRetryAfter(headers, msg)
		if retryAfter > 0 {
			return shared.ModelError{
				Kind:              shared.ErrSubscriptionQuotaExhausted,
				Retriable:         true,
				RetryAfterSeconds: retryAfter,
			}
		}
		return shared.ModelError{
			Kind:              shared.ErrSubscriptionQuotaExhausted,
			Retriable:         false,
			RetryAfterSeconds: 0,
		}
	}

	// next try to classify the error based on the message only
	msgRes := ClassifyErrMsg(msg)
	if msgRes != nil {
		log.Printf("Classified error message: %+v", msgRes)
		return *msgRes
	}

	var res shared.ModelError

	switch code {
	case 429, 529:
		res = shared.ModelError{
			Kind:              shared.ErrRateLimited,
			Retriable:         true,
			RetryAfterSeconds: 0,
		}
	case 413:
		res = shared.ModelError{
			Kind:              shared.ErrContextTooLong,
			Retriable:         false,
			RetryAfterSeconds: 0,
		}

	// rare codes but they never succeed on retry if they do show up
	case 501, 505:
		res = shared.ModelError{
			Kind:              shared.ErrOther,
			Retriable:         false,
			RetryAfterSeconds: 0,
		}
	default:
		res = shared.ModelError{
			Kind:              shared.ErrOther,
			Retriable:         code >= 500 || strings.Contains(msg, "provider returned error"), // 'provider returned error' is from OpenRouter, and unless it's a non-retriable status code, it should still be retried since OpenRouter may switch to a different provider
			RetryAfterSeconds: 0,
		}
	}

	log.Printf("Model error: %+v", res)

	// best‑effort parse of "Retry‑After" style hints in the message
	if res.Retriable {
		retryAfter := extractRetryAfter(headers, msg)

		// if the retry after is greater than the max delay, then the error is not retriable
		if retryAfter > MAX_RETRY_DELAY_SECONDS {
			log.Printf("Retry after %d seconds is greater than the max delay of %d seconds - not retriable", retryAfter, MAX_RETRY_DELAY_SECONDS)
			res.Retriable = false
		} else {
			res.RetryAfterSeconds = retryAfter
		}

	}

	return res
}

func extractRetryAfter(h http.Header, body string) (sec int) {
	now := time.Now()

	// Retry-After header: seconds or HTTP-date
	if v := h.Get("Retry-After"); v != "" {
		if n, err := strconv.Atoi(strings.TrimSpace(v)); err == nil {
			return n
		}
		if t, err := time.Parse(http.TimeFormat, v); err == nil {
			d := int(t.Sub(now).Seconds())
			if d > 0 {
				return d
			}
		}
	}

	// X-RateLimit-Reset epoch
	if v := h.Get("X-RateLimit-Reset"); v != "" {
		if reset, _ := strconv.ParseInt(v, 10, 64); reset > now.Unix() {
			return int(reset - now.Unix())
		}
	}

	lower := strings.ToLower(strings.TrimSpace(body))

	// "retry_after_ms": 1234
	if m := reJSON.FindStringSubmatch(lower); len(m) == 2 {
		n, _ := strconv.Atoi(m[1])
		return n / 1000
	}
	// "retry after 12"
	if m := reRetryAfter.FindStringSubmatch(lower); len(m) >= 2 {
		unit := ""
		if len(m) == 3 {
			unit = m[2]
		}
		return normalizeUnit(m[1], unit)
	}

	// "try again in 8"
	if m := reTryAgain.FindStringSubmatch(lower); len(m) >= 2 {
		unit := ""
		if len(m) == 3 {
			unit = m[2]
		}
		return normalizeUnit(m[1], unit)
	}
	return 0
}

func normalizeUnit(numStr, unit string) int {
	n, _ := strconv.Atoi(numStr) // safe because the regex matched \d+

	switch unit {
	case "ms": // milliseconds
		return n / 1000
	case "sec", "secs", "second", "seconds", "s":
		return n // already in seconds
	default: // unit omitted ⇒ assume seconds
		return n
	}
}

func classifyBasicError(err error, isClaudeMax bool) shared.ModelError {
	// if it's an http error, classify it based on the status code and body
	if httpErr, ok := err.(*HTTPError); ok {
		me := ClassifyModelError(
			httpErr.StatusCode,
			httpErr.Body,
			httpErr.Header,
			isClaudeMax,
		)
		return me
	}

	// try to classify the error based on the message only
	msgRes := ClassifyErrMsg(err.Error())
	if msgRes != nil {
		return *msgRes
	}

	// Fall back to old heuristic – still keeps the signature identical
	if isNonRetriableBasicErr(err) {
		return shared.ModelError{Kind: shared.ErrOther, Retriable: false}
	}
	return shared.ModelError{Kind: shared.ErrOther, Retriable: true}
}

func isNonRetriableBasicErr(err error) bool {
	errStr := err.Error()

	// we don't want to retry on the errors below
	if strings.Contains(errStr, "context deadline exceeded") || strings.Contains(errStr, "context canceled") {
		log.Println("Context deadline exceeded or canceled - no retry")
		return true
	}

	if strings.Contains(errStr, "status code: 400") &&
		strings.Contains(errStr, "reduce the length of the messages") {
		log.Println("Token limit exceeded - no retry")
		return true
	}

	if strings.Contains(errStr, "status code: 401") {
		log.Println("Invalid auth or api key - no retry")
		return true
	}

	if strings.Contains(errStr, "status code: 429") && strings.Contains(errStr, "exceeded your current quota") {
		log.Println("Current quota exceeded - no retry")
		return true
	}

	return false
}


================================================
FILE: app/server/model/model_request.go
================================================
package model

import (
	"context"
	"fmt"
	"log"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/notify"
	"plandex-server/types"
	shared "plandex-shared"
	"runtime/debug"
	"strings"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/sashabaranov/go-openai"
)

type ModelRequestParams struct {
	Clients       map[string]ClientInfo
	AuthVars      map[string]string
	Auth          *types.ServerAuth
	Plan          *db.Plan
	ModelConfig   *shared.ModelRoleConfig
	Settings      *shared.PlanSettings
	OrgUserConfig *shared.OrgUserConfig
	Purpose       string

	Messages   []types.ExtendedChatMessage
	Prediction string
	Stop       []string
	Tools      []openai.Tool
	ToolChoice *openai.ToolChoice

	EstimatedOutputTokens int // optional

	ModelStreamId  string
	ConvoMessageId string
	BuildId        string
	ModelPackName  string
	SessionId      string

	BeforeReq func()
	AfterReq  func()

	OnStream func(string, string) bool

	WillCacheNumTokens int
}

func ModelRequest(
	ctx context.Context,
	params ModelRequestParams,
) (*types.ModelResponse, error) {
	clients := params.Clients
	authVars := params.AuthVars
	auth := params.Auth
	plan := params.Plan
	messages := params.Messages
	prediction := params.Prediction
	stop := params.Stop
	tools := params.Tools
	toolChoice := params.ToolChoice
	modelConfig := params.ModelConfig
	modelStreamId := params.ModelStreamId
	convoMessageId := params.ConvoMessageId
	buildId := params.BuildId
	modelPackName := params.ModelPackName
	purpose := params.Purpose
	sessionId := params.SessionId
	settings := params.Settings
	orgUserConfig := params.OrgUserConfig
	currentOrgId := auth.OrgId
	currentUserId := auth.User.Id

	if purpose == "" {
		return nil, fmt.Errorf("purpose is required")
	}

	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, settings, orgUserConfig)

	messages = FilterEmptyMessages(messages)
	messages = CheckSingleSystemMessage(modelConfig, baseModelConfig, messages)
	inputTokensEstimate := GetMessagesTokenEstimate(messages...) + TokensPerRequest

	config := modelConfig.GetRoleForInputTokens(inputTokensEstimate, settings)
	modelConfig = &config

	if params.EstimatedOutputTokens != 0 {
		config = modelConfig.GetRoleForOutputTokens(params.EstimatedOutputTokens, settings)
		modelConfig = &config
	}

	log.Println("ModelRequest - modelConfig:")
	spew.Dump(modelConfig)
	log.Println("ModelRequest - baseModelConfig:")
	spew.Dump(baseModelConfig)

	log.Printf("Model config - role: %s, model: %s, max output tokens: %d\n", modelConfig.Role, baseModelConfig.ModelName, baseModelConfig.MaxOutputTokens)

	expectedOutputTokens := baseModelConfig.MaxOutputTokens - inputTokensEstimate
	if params.EstimatedOutputTokens != 0 {
		expectedOutputTokens = params.EstimatedOutputTokens
	}

	_, apiErr := hooks.ExecHook(hooks.WillSendModelRequest, hooks.HookParams{
		Auth: auth,
		Plan: plan,
		WillSendModelRequestParams: &hooks.WillSendModelRequestParams{
			InputTokens:  inputTokensEstimate,
			OutputTokens: expectedOutputTokens,
			ModelName:    baseModelConfig.ModelName,
			ModelId:      baseModelConfig.ModelId,
			ModelTag:     baseModelConfig.ModelTag,
		},
	})

	if apiErr != nil {
		return nil, apiErr
	}

	if params.BeforeReq != nil {
		params.BeforeReq()
	}

	reqStarted := time.Now()

	req := types.ExtendedChatCompletionRequest{
		Model:    baseModelConfig.ModelName,
		Messages: messages,
	}

	if !baseModelConfig.RoleParamsDisabled {
		req.Temperature = modelConfig.Temperature
		req.TopP = modelConfig.TopP
	}

	if len(tools) > 0 {
		req.Tools = tools
	}

	if toolChoice != nil {
		req.ToolChoice = toolChoice
	}

	onStream := params.OnStream
	if baseModelConfig.StopDisabled {
		if len(stop) > 0 {
			onStream = func(chunk string, buffer string) (shouldStop bool) {
				for _, stopSequence := range stop {
					if strings.Contains(buffer, stopSequence) {
						return true
					}
				}
				if params.OnStream != nil {
					return params.OnStream(chunk, buffer)
				}
				return false
			}
		}
	} else {
		req.Stop = stop
	}

	if prediction != "" {
		req.Prediction = &types.OpenAIPrediction{
			Type:    "content",
			Content: prediction,
		}
	}

	res, err := CreateChatCompletionWithInternalStream(clients, authVars, modelConfig, settings, orgUserConfig, currentOrgId, currentUserId, ctx, req, onStream, reqStarted)

	if err != nil {
		return nil, err
	}

	if baseModelConfig.StopDisabled && len(stop) > 0 {
		earliest := len(res.Content)
		found := false
		for _, s := range stop {
			if i := strings.Index(res.Content, s); i != -1 && i < earliest {
				earliest = i
				found = true
			}
		}
		if found {
			res.Content = res.Content[:earliest]
		}
	}

	if params.AfterReq != nil {
		params.AfterReq()
	}

	// log.Printf("\n\n**\n\nModel response: %s\n\n**\n\n", res.Content)

	var inputTokens int
	var outputTokens int
	var cachedTokens int

	if res.Usage != nil {
		if res.Usage.PromptTokensDetails != nil {
			cachedTokens = res.Usage.PromptTokensDetails.CachedTokens
		}
		inputTokens = res.Usage.PromptTokens
		outputTokens = res.Usage.CompletionTokens
	} else {
		inputTokens = inputTokensEstimate
		outputTokens = shared.GetNumTokensEstimate(res.Content)

		if params.WillCacheNumTokens > 0 {
			cachedTokens = params.WillCacheNumTokens
		}
	}

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in DidSendModelRequest hook: %v\n%s", r, debug.Stack())
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in DidSendModelRequest hook: %v\n%s", r, debug.Stack()))
			}
		}()

		_, apiErr := hooks.ExecHook(hooks.DidSendModelRequest, hooks.HookParams{
			Auth: auth,
			Plan: plan,
			DidSendModelRequestParams: &hooks.DidSendModelRequestParams{
				InputTokens:    inputTokens,
				OutputTokens:   outputTokens,
				CachedTokens:   cachedTokens,
				ModelId:        baseModelConfig.ModelId,
				ModelTag:       baseModelConfig.ModelTag,
				ModelName:      baseModelConfig.ModelName,
				ModelProvider:  baseModelConfig.Provider,
				ModelPackName:  modelPackName,
				ModelRole:      modelConfig.Role,
				Purpose:        purpose,
				GenerationId:   res.GenerationId,
				PlanId:         plan.Id,
				ModelStreamId:  modelStreamId,
				ConvoMessageId: convoMessageId,
				BuildId:        buildId,

				RequestStartedAt: reqStarted,
				Streaming:        true,
				Req:              &req,
				StreamResult:     res.Content,
				ModelConfig:      modelConfig,
				FirstTokenAt:     res.FirstTokenAt,
				SessionId:        sessionId,
			},
		})

		if apiErr != nil {
			log.Printf("buildWholeFile - error executing DidSendModelRequest hook: %v", apiErr)
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error executing DidSendModelRequest hook: %v", apiErr))
		}
	}()

	return res, nil
}

func FilterEmptyMessages(messages []types.ExtendedChatMessage) []types.ExtendedChatMessage {
	filteredMessages := []types.ExtendedChatMessage{}
	for _, message := range messages {
		var content []types.ExtendedChatMessagePart
		for _, part := range message.Content {
			if part.Type != openai.ChatMessagePartTypeText || part.Text != "" {
				content = append(content, part)
			}
		}
		if len(content) > 0 {
			filteredMessages = append(filteredMessages, types.ExtendedChatMessage{
				Role:    message.Role,
				Content: content,
			})
		}
	}
	return filteredMessages
}

func CheckSingleSystemMessage(modelConfig *shared.ModelRoleConfig, baseModelConfig *shared.BaseModelConfig, messages []types.ExtendedChatMessage) []types.ExtendedChatMessage {
	if len(messages) == 1 && baseModelConfig.SingleMessageNoSystemPrompt {
		if messages[0].Role == openai.ChatMessageRoleSystem {
			msg := messages[0]
			msg.Role = openai.ChatMessageRoleUser
			return []types.ExtendedChatMessage{msg}
		}
	}

	return messages
}


================================================
FILE: app/server/model/name.go
================================================
package model

import (
	"context"
	"encoding/json"
	"fmt"
	"plandex-server/db"
	"plandex-server/model/prompts"
	"plandex-server/types"
	"plandex-server/utils"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func GenPlanName(
	auth *types.ServerAuth,
	plan *db.Plan,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	clients map[string]ClientInfo,
	authVars map[string]string,
	planContent string,
	sessionId string,
	ctx context.Context,
) (string, error) {
	config := settings.GetModelPack().Namer

	var tools []openai.Tool
	var toolChoice *openai.ToolChoice

	baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)

	var sysPrompt string
	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		sysPrompt = prompts.SysPlanNameXml
	} else {
		sysPrompt = prompts.SysPlanName
		tools = []openai.Tool{
			{
				Type:     "function",
				Function: &prompts.PlanNameFn,
			},
		}
		choice := openai.ToolChoice{
			Type: "function",
			Function: openai.ToolFunction{
				Name: prompts.PlanNameFn.Name,
			},
		}
		toolChoice = &choice
	}

	prompt := prompts.GetPlanNamePrompt(sysPrompt, planContent)

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		},
	}

	modelRes, err := ModelRequest(ctx, ModelRequestParams{
		Clients:       clients,
		AuthVars:      authVars,
		Auth:          auth,
		Plan:          plan,
		ModelConfig:   &config,
		OrgUserConfig: orgUserConfig,
		Purpose:       "Plan name",
		Messages:      messages,
		Tools:         tools,
		ToolChoice:    toolChoice,
		SessionId:     sessionId,
		Settings:      settings,
	})

	if err != nil {
		fmt.Printf("Error during plan name model call: %v\n", err)
		return "", err
	}

	var planName string
	content := modelRes.Content

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		planName = utils.GetXMLContent(content, "planName")
		if planName == "" {
			return "", fmt.Errorf("No planName tag found in XML response")
		}
	} else {
		if content == "" {
			fmt.Println("no namePlan function call found in response")
			return "", fmt.Errorf("No namePlan function call found in response. The model failed to generate a valid response.")
		}

		var nameRes prompts.PlanNameRes
		err = json.Unmarshal([]byte(content), &nameRes)
		if err != nil {
			fmt.Printf("Error unmarshalling plan description response: %v\n", err)
			return "", err
		}
		planName = nameRes.PlanName
	}

	return planName, nil
}

type GenPipedDataNameParams struct {
	Ctx           context.Context
	Auth          *types.ServerAuth
	Plan          *db.Plan
	Settings      *shared.PlanSettings
	OrgUserConfig *shared.OrgUserConfig
	AuthVars      map[string]string
	SessionId     string
	Clients       map[string]ClientInfo
	PipedContent  string
}

func GenPipedDataName(
	params GenPipedDataNameParams,
) (string, error) {
	ctx := params.Ctx
	auth := params.Auth
	plan := params.Plan
	settings := params.Settings
	clients := params.Clients
	authVars := params.AuthVars
	pipedContent := params.PipedContent
	sessionId := params.SessionId
	orgUserConfig := params.OrgUserConfig

	config := settings.GetModelPack().Namer

	var sysPrompt string
	var tools []openai.Tool
	var toolChoice *openai.ToolChoice

	baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		sysPrompt = prompts.SysPipedDataNameXml
	} else {
		sysPrompt = prompts.SysPipedDataName
		tools = []openai.Tool{
			{
				Type:     "function",
				Function: &prompts.PipedDataNameFn,
			},
		}
		choice := openai.ToolChoice{
			Type: "function",
			Function: openai.ToolFunction{
				Name: prompts.PipedDataNameFn.Name,
			},
		}
		toolChoice = &choice
	}

	prompt := prompts.GetPipedDataNamePrompt(sysPrompt, pipedContent)

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		},
	}

	modelRes, err := ModelRequest(ctx, ModelRequestParams{
		Clients:       clients,
		Auth:          auth,
		AuthVars:      authVars,
		Plan:          plan,
		ModelConfig:   &config,
		Purpose:       "Piped data name",
		Messages:      messages,
		Tools:         tools,
		ToolChoice:    toolChoice,
		SessionId:     sessionId,
		Settings:      settings,
		OrgUserConfig: orgUserConfig,
	})

	if err != nil {
		fmt.Printf("Error during piped data name model call: %v\n", err)
		return "", err
	}

	var name string
	content := modelRes.Content

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		name = utils.GetXMLContent(content, "name")
		if name == "" {
			return "", fmt.Errorf("No name tag found in XML response")
		}
	} else {
		if content == "" {
			fmt.Println("no namePipedData function call found in response")
			return "", fmt.Errorf("No namePipedData function call found in response. The model failed to generate a valid response.")
		}

		var nameRes prompts.PipedDataNameRes
		err = json.Unmarshal([]byte(content), &nameRes)
		if err != nil {
			fmt.Printf("Error unmarshalling piped data name response: %v\n", err)
			return "", err
		}
		name = nameRes.Name
	}

	return name, nil
}

func GenNoteName(
	ctx context.Context,
	auth *types.ServerAuth,
	plan *db.Plan,
	settings *shared.PlanSettings,
	orgUserConfig *shared.OrgUserConfig,
	clients map[string]ClientInfo,
	authVars map[string]string,
	note string,
	sessionId string,
) (string, error) {
	config := settings.GetModelPack().Namer

	var sysPrompt string
	var tools []openai.Tool
	var toolChoice *openai.ToolChoice

	baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		sysPrompt = prompts.SysNoteNameXml
	} else {
		sysPrompt = prompts.SysNoteName
		tools = []openai.Tool{
			{
				Type:     "function",
				Function: &prompts.NoteNameFn,
			},
		}
		choice := openai.ToolChoice{
			Type: "function",
			Function: openai.ToolFunction{
				Name: prompts.NoteNameFn.Name,
			},
		}
		toolChoice = &choice
	}

	prompt := prompts.GetNoteNamePrompt(sysPrompt, note)

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		},
	}

	modelRes, err := ModelRequest(ctx, ModelRequestParams{
		Clients:       clients,
		Auth:          auth,
		AuthVars:      authVars,
		Plan:          plan,
		ModelConfig:   &config,
		Purpose:       "Note name",
		Messages:      messages,
		Tools:         tools,
		ToolChoice:    toolChoice,
		SessionId:     sessionId,
		Settings:      settings,
		OrgUserConfig: orgUserConfig,
	})

	if err != nil {
		fmt.Printf("Error during note name model call: %v\n", err)
		return "", err
	}

	var name string
	content := modelRes.Content

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		name = utils.GetXMLContent(content, "name")
		if name == "" {
			return "", fmt.Errorf("No name tag found in XML response")
		}
	} else {
		if content == "" {
			fmt.Println("no nameNote function call found in response")
			return "", fmt.Errorf("No nameNote function call found in response. The model failed to generate a valid response.")
		}

		var nameRes prompts.NoteNameRes
		err = json.Unmarshal([]byte(content), &nameRes)
		if err != nil {
			fmt.Printf("Error unmarshalling note name response: %v\n", err)
			return "", err
		}
		name = nameRes.Name
	}

	return name, nil
}


================================================
FILE: app/server/model/parse/subtasks.go
================================================
package parse

import (
	"log"
	"plandex-server/db"
	"regexp"
	"strings"
)

func ParseSubtasks(replyContent string) []*db.Subtask {
	split := strings.Split(replyContent, "### Tasks")
	if len(split) < 2 {
		split = strings.Split(replyContent, "### Task")
		if len(split) < 2 {
			log.Println("[Subtasks] No tasks section found in reply")
			return nil
		}
	}

	lines := strings.Split(split[1], "\n")

	var subtasks []*db.Subtask
	var currentTask *db.Subtask
	var descLines []string

	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}

		// Check for any number followed by a period and space
		if matched, _ := regexp.MatchString(`^\d+\.\s`, line); matched {
			// Save previous task if exists
			if currentTask != nil {
				currentTask.Description = strings.Join(descLines, "\n")
				log.Printf("[Subtasks] Adding subtask: %q with %d uses files", currentTask.Title, len(currentTask.UsesFiles))
				subtasks = append(subtasks, currentTask)
			}

			// Start new task
			parts := strings.SplitN(line, ". ", 2)
			if len(parts) == 2 {
				title := parts[1]
				currentTask = &db.Subtask{
					Title: title,
				}
				descLines = nil
			}
			continue
		}

		// Handle Uses: section
		if strings.HasPrefix(line, "Uses:") {
			if currentTask != nil {
				usesStr := strings.TrimPrefix(line, "Uses:")
				for _, use := range strings.Split(usesStr, ",") {
					use = strings.TrimSpace(use)
					use = strings.Trim(use, "`")
					if use != "" {
						currentTask.UsesFiles = append(currentTask.UsesFiles, use)
					}
				}
				log.Printf("[Subtasks] Added uses files for %q: %v", currentTask.Title, currentTask.UsesFiles)
			}
			continue
		}

		// Add to description if we have a current task
		if currentTask != nil {
			// Remove bullet point if present, but don't require it
			line = strings.TrimPrefix(line, "-")
			line = strings.TrimSpace(line)
			if line != "" {
				descLines = append(descLines, line)
			}
		}
	}

	// Save final task if exists
	if currentTask != nil {
		currentTask.Description = strings.Join(descLines, "\n")
		log.Printf("[Subtasks] Adding final subtask: %q with %d uses files", currentTask.Title, len(currentTask.UsesFiles))
		subtasks = append(subtasks, currentTask)
	}

	log.Printf("[Subtasks] Parsed %d total subtasks", len(subtasks))
	return subtasks
}

func ParseRemoveSubtasks(replyContent string) []string {
	split := strings.Split(replyContent, "### Remove Tasks")
	if len(split) < 2 {
		return nil
	}

	section := split[1]
	lines := strings.Split(section, "\n")
	var tasksToRemove []string

	sawEmptyLine := false
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if line == "" {
			sawEmptyLine = true
			continue
		}
		if sawEmptyLine && !strings.HasPrefix(line, "-") {
			break
		}
		if strings.HasPrefix(line, "- ") {
			title := strings.TrimPrefix(line, "- ")
			title = strings.TrimSpace(title)
			if title != "" {
				tasksToRemove = append(tasksToRemove, title)
			}
		}
	}

	return tasksToRemove
}


================================================
FILE: app/server/model/parse/subtasks_test.go
================================================
package parse

import (
	"plandex-server/db"
	"testing"
)

func TestParseSubtasks(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected []*db.Subtask
	}{
		{
			name:     "empty input",
			input:    "",
			expected: nil,
		},
		{
			name: "single task without description",
			input: `### Tasks
1. Create a new file`,
			expected: []*db.Subtask{
				{
					Title:       "Create a new file",
					Description: "",
					UsesFiles:   nil,
				},
			},
		},
		{
			name: "multiple tasks with descriptions and uses",
			input: `### Tasks
1. Create config file
- Will store application settings
- Contains environment variables
Uses: ` + "`config/settings.yml`" + `, ` + "`config/defaults.yml`" + `

2. Update main function
- Add configuration loading
Uses: ` + "`main.go`",
			expected: []*db.Subtask{
				{
					Title:       "Create config file",
					Description: "Will store application settings\nContains environment variables",
					UsesFiles:   []string{"config/settings.yml", "config/defaults.yml"},
				},
				{
					Title:       "Update main function",
					Description: "Add configuration loading",
					UsesFiles:   []string{"main.go"},
				},
			},
		},
		{
			name: "alternative task header",
			input: `### Task
1. Simple task`,
			expected: []*db.Subtask{
				{
					Title:       "Simple task",
					Description: "",
					UsesFiles:   nil,
				},
			},
		},
		{
			name: "tasks with empty lines between",
			input: `### Tasks
1. First task
- Description one

2. Second task
- Description two`,
			expected: []*db.Subtask{
				{
					Title:       "First task",
					Description: "Description one",
					UsesFiles:   nil,
				},
				{
					Title:       "Second task",
					Description: "Description two",
					UsesFiles:   nil,
				},
			},
		},
		{
			name: "single task from pong",
			input: "### Tasks" + `

9. Update Makefile to include Homebrew-specific include and library search paths
- Modify CFLAGS in Makefile to add -I/opt/homebrew/include
- Modify LDFLAGS in Makefile to add -L/opt/homebrew/lib
Uses: ` + "`Makefile`" + `, ` + "`_apply.sh`",
			expected: []*db.Subtask{
				{
					Title:       "Update Makefile to include Homebrew-specific include and library search paths",
					Description: "Modify CFLAGS in Makefile to add -I/opt/homebrew/include\nModify LDFLAGS in Makefile to add -L/opt/homebrew/lib",
					UsesFiles:   []string{"Makefile", "_apply.sh"},
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := ParseSubtasks(tt.input)

			if len(got) != len(tt.expected) {
				t.Errorf("ParseSubtasks() returned %d subtasks, want %d", len(got), len(tt.expected))
				return
			}

			for i := range got {
				if got[i].Title != tt.expected[i].Title {
					t.Errorf("Subtask[%d].Title = %q, want %q", i, got[i].Title, tt.expected[i].Title)
				}
				if got[i].Description != tt.expected[i].Description {
					t.Errorf("Subtask[%d].Description = %q, want %q", i, got[i].Description, tt.expected[i].Description)
				}
				if !sliceEqual(got[i].UsesFiles, tt.expected[i].UsesFiles) {
					t.Errorf("Subtask[%d].UsesFiles = %v, want %v", i, got[i].UsesFiles, tt.expected[i].UsesFiles)
				}
			}
		})
	}
}

// sliceEqual compares two string slices for equality
func sliceEqual(a, b []string) bool {
	if len(a) != len(b) {
		return false
	}
	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}


================================================
FILE: app/server/model/plan/activate.go
================================================
package plan

import (
	"fmt"
	"log"
	"plandex-server/db"
	"plandex-server/host"
	"plandex-server/model"
	"plandex-server/types"
	"time"

	shared "plandex-shared"
)

func activatePlan(
	clients map[string]model.ClientInfo,
	plan *db.Plan,
	branch string,
	auth *types.ServerAuth,
	prompt string,
	buildOnly,
	autoContext bool,
	sessionId string,
) (*types.ActivePlan, error) {
	log.Printf("Activate plan: plan ID %s on branch %s\n", plan.Id, branch)

	// Just in case this request was made immediately after another stream finished, wait a little to allow for cleanup
	log.Println("Waiting 100ms before checking for active plan")
	time.Sleep(100 * time.Millisecond)
	log.Println("Done waiting, checking for active plan")

	active := GetActivePlan(plan.Id, branch)
	if active != nil {
		log.Printf("Tell: Active plan found for plan ID %s on branch %s\n", plan.Id, branch) // Log if an active plan is found
		return nil, fmt.Errorf("plan %s branch %s already has an active stream on this host", plan.Id, branch)
	}

	modelStream, err := db.GetActiveModelStream(plan.Id, branch)
	if err != nil {
		log.Printf("Error getting active model stream: %v\n", err)
		return nil, fmt.Errorf("error getting active model stream: %v", err)
	}

	if modelStream != nil {
		log.Printf("Tell: Active model stream found for plan ID %s on branch %s on host %s\n", plan.Id, branch, modelStream.InternalIp) // Log if an active model stream is found
		return nil, fmt.Errorf("plan %s branch %s already has an active stream on host %s", plan.Id, branch, modelStream.InternalIp)
	}

	active = CreateActivePlan(
		auth.OrgId,
		auth.User.Id,
		plan.Id,
		branch,
		prompt,
		buildOnly,
		autoContext,
		sessionId,
	)

	modelStream = &db.ModelStream{
		OrgId:      auth.OrgId,
		PlanId:     plan.Id,
		InternalIp: host.Ip,
		Branch:     branch,
	}
	err = db.StoreModelStream(modelStream, active.Ctx, active.CancelFn)
	if err != nil {
		log.Printf("Tell: Error storing model stream for plan ID %s on branch %s: %v\n", plan.Id, branch, err) // Log error storing model stream
		log.Printf("Error storing model stream: %v\n", err)
		log.Printf("Tell: Error storing model stream: %v\n", err) // Log error storing model stream

		active.StreamDoneCh <- &shared.ApiError{Msg: fmt.Sprintf("Error storing model stream: %v", err)}

		return nil, fmt.Errorf("error storing model stream: %v", err)
	}

	active.ModelStreamId = modelStream.Id

	log.Printf("Tell: Model stream stored with ID %s for plan ID %s on branch %s\n", modelStream.Id, plan.Id, branch) // Log successful storage of model stream
	log.Println("Model stream id:", modelStream.Id)

	return active, nil
}


================================================
FILE: app/server/model/plan/build_exec.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"path/filepath"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/model"
	"plandex-server/notify"
	"plandex-server/types"
	"runtime/debug"
	"time"

	shared "plandex-shared"
)

type BuildParams struct {
	Clients       map[string]model.ClientInfo
	AuthVars      map[string]string
	Plan          *db.Plan
	Branch        string
	Auth          *types.ServerAuth
	SessionId     string
	OrgUserConfig *shared.OrgUserConfig
	Settings      *shared.PlanSettings
}

func Build(params BuildParams) (int, error) {
	clients := params.Clients
	authVars := params.AuthVars
	plan := params.Plan
	branch := params.Branch
	auth := params.Auth
	sessionId := params.SessionId
	orgUserConfig := params.OrgUserConfig
	settings := params.Settings

	log.Printf("Build: Called with plan ID %s on branch %s\n", plan.Id, branch)
	log.Println("Build: Starting Build operation")

	state := activeBuildStreamState{
		clients:       clients,
		authVars:      authVars,
		auth:          auth,
		currentOrgId:  auth.OrgId,
		currentUserId: auth.User.Id,
		orgUserConfig: orgUserConfig,
		plan:          plan,
		branch:        branch,
		settings:      settings,
	}

	streamDone := func() {
		active := GetActivePlan(plan.Id, branch)
		if active != nil {
			active.StreamDoneCh <- nil
		}
	}

	onErr := func(err error) (int, error) {
		log.Printf("Build error: %v\n", err)
		streamDone()
		return 0, err
	}

	pendingBuildsByPath, err := state.loadPendingBuilds(sessionId)
	if err != nil {
		return onErr(err)
	}

	if len(pendingBuildsByPath) == 0 {
		log.Println("No pending builds")
		streamDone()
		return 0, nil
	}

	err = db.SetPlanStatus(plan.Id, branch, shared.PlanStatusBuilding, "")

	if err != nil {
		log.Printf("Error setting plan status to building: %v\n", err)
		return onErr(fmt.Errorf("error setting plan status to building: %v", err))
	}

	log.Printf("Starting %d builds\n", len(pendingBuildsByPath))

	for _, pendingBuilds := range pendingBuildsByPath {
		go state.queueBuilds(pendingBuilds)
	}

	return len(pendingBuildsByPath), nil
}

func (state *activeBuildStreamState) queueBuild(activeBuild *types.ActiveBuild) {
	planId := state.plan.Id
	branch := state.branch

	filePath := activeBuild.Path

	// log.Printf("Queue:")
	// spew.Dump(activePlan.BuildQueuesByPath[filePath])

	var isBuilding bool

	UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
		active.BuildQueuesByPath[filePath] = append(active.BuildQueuesByPath[filePath], activeBuild)
		isBuilding = active.IsBuildingByPath[filePath]
	})
	log.Printf("Queued build for file %s\n", filePath)

	if isBuilding {
		log.Printf("Already building file %s\n", filePath)
		return
	} else {
		log.Printf("Not building file %s\n", filePath)

		active := GetActivePlan(planId, branch)
		if active == nil {
			log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
			return
		}

		UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
			active.IsBuildingByPath[filePath] = true
		})

		go state.execPlanBuild(activeBuild)
	}
}

func (state *activeBuildStreamState) queueBuilds(activeBuilds []*types.ActiveBuild) {
	log.Printf("Queueing %d builds\n", len(activeBuilds))

	for _, activeBuild := range activeBuilds {
		state.queueBuild(activeBuild)
	}
}

func (buildState *activeBuildStreamState) execPlanBuild(activeBuild *types.ActiveBuild) {
	if activeBuild == nil {
		log.Println("No active build")
		return
	}

	log.Printf("execPlanBuild - %s\n", activeBuild.Path)
	// log.Println(spew.Sdump(activeBuild))

	planId := buildState.plan.Id
	branch := buildState.branch

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
		return
	}

	defer func() {
		if r := recover(); r != nil {
			log.Printf("execPlanBuild: Panic: %v\n%s\n", r, string(debug.Stack()))

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("execPlanBuild: Panic: %v\n%s", r, string(debug.Stack())))

			activePlan.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Panic in execPlanBuild",
			}
		}
	}()

	filePath := activeBuild.Path

	if !activePlan.IsBuildingByPath[filePath] {
		UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
			ap.IsBuildingByPath[filePath] = true
		})
	}

	fileState := &activeBuildStreamFileState{
		activeBuildStreamState: buildState,
		filePath:               filePath,
		activeBuild:            activeBuild,
		builderRun: hooks.DidFinishBuilderRunParams{
			StartedAt: time.Now(),
			PlanId:    activePlan.Id,
			FilePath:  filePath,
			FileExt:   filepath.Ext(filePath),
		},
	}

	log.Printf("execPlanBuild - %s - calling fileState.loadBuildFile()\n", filePath)
	err := fileState.loadBuildFile(activeBuild)
	if err != nil {
		log.Printf("Error loading build file: %v\n", err)
		fileState.onBuildFileError(fmt.Errorf("error loading build file: %v", err))
		return
	}

	fileState.resolvePreBuildState()

	// unless it's a file operation, stream initial status to client
	if !activeBuild.IsFileOperation() && !fileState.isNewFile {
		log.Printf("execPlanBuild - %s - streaming initial build info\n", filePath)
		// spew.Dump(activeBuild)
		buildInfo := &shared.BuildInfo{
			Path:      filePath,
			NumTokens: 0,
			Finished:  false,
		}
		activePlan.Stream(shared.StreamMessage{
			Type:      shared.StreamMessageBuildInfo,
			BuildInfo: buildInfo,
		})
	} else if activeBuild.IsFileOperation() {
		log.Printf("execPlanBuild - %s - file operation - won't stream initial build info\n", filePath)
	} else if fileState.isNewFile {
		log.Printf("execPlanBuild - %s - new file - won't stream initial build info\n", filePath)
	}

	log.Printf("execPlanBuild - %s - calling fileState.buildFile()\n", filePath)
	fileState.buildFile()
}

func (fileState *activeBuildStreamFileState) buildFile() {
	filePath := fileState.filePath
	activeBuild := fileState.activeBuild
	planId := fileState.plan.Id
	branch := fileState.branch
	currentOrgId := fileState.currentOrgId
	build := fileState.build

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
		return
	}

	log.Printf("Building file %s\n", filePath)
	log.Printf("%d files in context\n", len(activePlan.ContextsByPath))
	// log.Println("activePlan.ContextsByPath files:")
	// for k := range activePlan.ContextsByPath {
	// 	log.Println(k)
	// }

	if activeBuild.IsMoveOp {
		log.Printf("File %s is a move operation. Moving to %s\n", filePath, activeBuild.MoveDestination)

		// For move operations, we split it into two separate builds:
		// 1. A removal build for the source file
		// 2. A creation build for the destination file with the current content
		// This is simpler than handling moves in a single build since our build system
		// is designed around operating on one path at a time
		fileState.activeBuildStreamState.queueBuilds([]*types.ActiveBuild{
			{
				ReplyId:    activeBuild.ReplyId,
				Path:       activeBuild.Path,
				IsRemoveOp: true,
			},
			{
				ReplyId:           activeBuild.ReplyId,
				Path:              activeBuild.MoveDestination,
				FileContent:       fileState.preBuildState,
				FileContentTokens: 0,
			},
		})

		// Mark this move operation as successful since we've queued the actual work
		activeBuild.Success = true

		UpdateActivePlan(planId, branch, func(active *types.ActivePlan) {
			active.IsBuildingByPath[filePath] = false
			active.BuiltFiles[filePath] = true
		})

		// Process the next build in queue (which will be our removal build)
		// We need to explicitly advance the queue for the source path since this
		// current build is holding the 'building' state open
		// The create build for the destination will be handled automatically by the queue logic
		fileState.buildNextInQueue()
		return
	}

	if activeBuild.IsRemoveOp {
		log.Printf("File %s is a remove operation. Removing file.\n", filePath)

		log.Printf("streaming remove build info for file %s\n", filePath)
		buildInfo := &shared.BuildInfo{
			Path:      filePath,
			NumTokens: 0,
			Removed:   true,
			Finished:  true,
		}

		activePlan.Stream(shared.StreamMessage{
			Type:      shared.StreamMessageBuildInfo,
			BuildInfo: buildInfo,
		})

		planRes := &db.PlanFileResult{
			OrgId:          currentOrgId,
			PlanId:         planId,
			PlanBuildId:    build.Id,
			ConvoMessageId: build.ConvoMessageId,
			Path:           filePath,
			Content:        "",
			RemovedFile:    true,
		}
		fileState.onFinishBuildFile(planRes)
		return
	}

	if activeBuild.IsResetOp {
		log.Printf("File %s is a reset operation. Resetting file.\n", filePath)

		err := db.ExecRepoOperation(db.ExecRepoOperationParams{
			OrgId:       currentOrgId,
			UserId:      fileState.currentUserId,
			PlanId:      planId,
			Branch:      branch,
			PlanBuildId: build.Id,
			Scope:       db.LockScopeWrite,
			Reason:      "reset file op",
			Ctx:         activePlan.Ctx,
			CancelFn:    activePlan.CancelFn,
		}, func(repo *db.GitRepo) error {
			now := time.Now()
			return db.RejectPlanFile(currentOrgId, planId, filePath, now)
		})

		if err != nil {
			log.Printf("Error rejecting plan file: %v\n", err)
			fileState.onBuildFileError(fmt.Errorf("error rejecting plan file: %v", err))
			return
		}

		buildInfo := &shared.BuildInfo{
			Path:      filePath,
			NumTokens: 0,
			Finished:  true,
			Removed:   fileState.contextPart == nil,
		}

		activePlan.Stream(shared.StreamMessage{
			Type:      shared.StreamMessageBuildInfo,
			BuildInfo: buildInfo,
		})

		time.Sleep(200 * time.Millisecond)

		fileState.onBuildProcessed(activeBuild)
		return
	}

	if fileState.preBuildState == "" {
		log.Printf("File %s not found in model context or current plan. Creating new file.\n", filePath)

		buildInfo := &shared.BuildInfo{
			Path:      filePath,
			NumTokens: 0,
			Finished:  true,
		}

		log.Printf("streaming new file build info for file %s\n", filePath)

		activePlan.Stream(shared.StreamMessage{
			Type:      shared.StreamMessageBuildInfo,
			BuildInfo: buildInfo,
		})

		// new file
		planRes := &db.PlanFileResult{
			OrgId:          currentOrgId,
			PlanId:         planId,
			PlanBuildId:    build.Id,
			ConvoMessageId: build.ConvoMessageId,
			Path:           filePath,
			Content:        activeBuild.FileContent,
		}

		// log.Println("build exec - new file result")
		// spew.Dump(planRes)
		fileState.onFinishBuildFile(planRes)
		return
	} else {
		currentNumTokens := shared.GetNumTokensEstimate(fileState.preBuildState)

		log.Printf("Current state num tokens: %d\n", currentNumTokens)

		activeBuild.CurrentFileTokens = currentNumTokens
		activePlan.DidEditFiles = true
	}

	// build structured edits strategy now works regardless of language/tree-sitter support
	log.Println("buildFile - building structured edits")
	fileState.buildStructuredEdits()
}

func (fileState *activeBuildStreamFileState) resolvePreBuildState() {
	filePath := fileState.filePath
	currentPlan := fileState.currentPlanState
	planId := fileState.plan.Id
	branch := fileState.branch

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
		return
	}
	contextPart := activePlan.ContextsByPath[filePath]

	var currentState string
	currentPlanFile, fileInCurrentPlan := currentPlan.CurrentPlanFiles.Files[filePath]

	// log.Println("plan files:")
	// spew.Dump(currentPlan.CurrentPlanFiles.Files)

	if fileInCurrentPlan {
		log.Printf("File %s found in current plan.\n", filePath)
		fileState.isNewFile = false
		currentState = currentPlanFile
		// log.Println("\n\nCurrent state:\n", currentState, "\n\n")

	} else if contextPart != nil {
		log.Printf("File %s found in model context. Using context state.\n", filePath)
		fileState.isNewFile = false
		currentState = contextPart.Body
		// log.Println("\n\nCurrent state:\n", currentState, "\n\n")
	} else {
		fileState.isNewFile = true
	}

	fileState.preBuildState = currentState
	fileState.contextPart = contextPart
}


================================================
FILE: app/server/model/plan/build_finish.go
================================================
package plan

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/notify"
	"plandex-server/types"
	"strings"
	"time"

	shared "plandex-shared"
)

func (state *activeBuildStreamFileState) onFinishBuild() {
	log.Println("Build finished")

	planId := state.plan.Id
	branch := state.branch
	currentOrgId := state.currentOrgId
	currentUserId := state.currentUserId
	convoMessageId := state.convoMessageId
	build := state.build

	// first check if any of the messages we're building hasen't finished streaming yet
	stillStreaming := false
	var doneCh chan bool
	ap := GetActivePlan(planId, branch)

	if ap == nil {
		log.Println("onFinishBuild - Active plan not found")
		return
	}

	if ap.CurrentStreamingReplyId == convoMessageId {
		stillStreaming = true
		doneCh = ap.CurrentReplyDoneCh
	}
	if stillStreaming {
		log.Println("Reply is still streaming, waiting for it to finish before finishing build")
		<-doneCh
	}

	// Check again if build is finished
	// (more builds could have been queued while we were waiting for the reply to finish streaming)
	ap = GetActivePlan(planId, branch)

	if ap == nil {
		log.Println("onFinishBuild - Active plan not found")
		return
	}

	if !ap.BuildFinished() {
		log.Println("Build not finished after waiting for reply to finish streaming")
		return
	}

	log.Println("Locking repo for finished build")

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:       currentOrgId,
		UserId:      currentUserId,
		PlanId:      planId,
		Branch:      branch,
		PlanBuildId: build.Id,
		Scope:       db.LockScopeWrite,
		Ctx:         ap.Ctx,
		CancelFn:    ap.CancelFn,
		Reason:      "finish build",
	}, func(repo *db.GitRepo) error {
		// get plan descriptions
		var planDescs []*db.ConvoMessageDescription
		planDescs, err := db.GetConvoMessageDescriptions(currentOrgId, planId)
		if err != nil {
			log.Printf("Error getting pending build descriptions: %v\n", err)
			return fmt.Errorf("error getting pending build descriptions: %v", err)
		}

		var unbuiltDescs []*db.ConvoMessageDescription
		for _, desc := range planDescs {
			if !desc.DidBuild || len(desc.BuildPathsInvalidated) > 0 {
				unbuiltDescs = append(unbuiltDescs, desc)
			}
		}

		// get fresh current plan state
		var currentPlan *shared.CurrentPlanState
		currentPlan, err = db.GetCurrentPlanState(db.CurrentPlanStateParams{
			OrgId:                    currentOrgId,
			PlanId:                   planId,
			ConvoMessageDescriptions: planDescs,
		})
		if err != nil {
			log.Printf("Error getting current plan state: %v\n", err)
			return fmt.Errorf("error getting current plan state: %v", err)
		}

		descErrCh := make(chan error, len(unbuiltDescs))
		for _, desc := range unbuiltDescs {
			if len(desc.Operations) > 0 {
				desc.DidBuild = true
				desc.BuildPathsInvalidated = map[string]bool{}
			}

			go func(desc *db.ConvoMessageDescription) {
				err := db.StoreDescription(desc)

				if err != nil {
					descErrCh <- fmt.Errorf("error storing description: %v", err)
					return
				}

				descErrCh <- nil
			}(desc)
		}

		for range unbuiltDescs {
			err = <-descErrCh
			if err != nil {
				log.Printf("Error storing description: %v\n", err)
				return err
			}
		}

		err = repo.GitAddAndCommit(branch, currentPlan.PendingChangesSummaryForBuild())

		if err != nil {
			if strings.Contains(err.Error(), "nothing to commit") {
				log.Println("Nothing to commit")
				return nil
			}
			return fmt.Errorf("error committing plan build: %v", err)
		}

		log.Println("Plan build committed")

		return nil
	})

	if err != nil {
		log.Printf("Error finishing build: %v\n", err)

		if err.Error() != context.Canceled.Error() {
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error finishing build: %v", err))

			ap.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Error finishing build: " + err.Error(),
			}
		}
		return
	}

	active := GetActivePlan(planId, branch)

	if active != nil && (active.RepliesFinished || active.BuildOnly) {
		active.Finish()
	}
}

func (fileState *activeBuildStreamFileState) onFinishBuildFile(planRes *db.PlanFileResult) {
	planId := fileState.plan.Id
	branch := fileState.branch
	currentOrgId := fileState.currentOrgId
	build := fileState.build
	activeBuild := fileState.activeBuild

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		log.Println("onFinishBuildFile - Active plan not found")
		return
	}

	filePath := fileState.filePath

	log.Printf("onFinishBuildFile: %s\n", filePath)

	if planRes == nil {
		log.Println("onFinishBuildFile - planRes is nil")
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("onFinishBuildFile: planRes is nil"))

		activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error storing plan result: planRes is nil",
		}
		return
	}

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:       currentOrgId,
		UserId:      fileState.currentUserId,
		PlanId:      planId,
		Branch:      branch,
		PlanBuildId: build.Id,
		Scope:       db.LockScopeWrite,
		Ctx:         activePlan.Ctx,
		CancelFn:    activePlan.CancelFn,
		Reason:      "store plan result",
	}, func(repo *db.GitRepo) error {
		log.Println("Storing plan result", planRes.Path)

		err := db.StorePlanResult(planRes)
		if err != nil {
			log.Printf("Error storing plan result: %v\n", err)
			return err
		}

		return nil
	})

	if err != nil {
		log.Printf("Error storing plan build result: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error storing plan build result: %v", err))

		activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error storing plan build result: " + err.Error(),
		}
		return
	}

	fileState.builderRun.FinishedAt = time.Now()
	hooks.ExecHook(hooks.DidFinishBuilderRun, hooks.HookParams{
		Auth:                      fileState.auth,
		Plan:                      fileState.plan,
		DidFinishBuilderRunParams: &fileState.builderRun,
	})

	log.Printf("Finished building file %s - setting activeBuild.Success to true\n", filePath)
	// log.Println(spew.Sdump(activeBuild))

	fileState.onBuildProcessed(activeBuild)
}

func (fileState *activeBuildStreamFileState) onBuildProcessed(activeBuild *types.ActiveBuild) {
	filePath := fileState.filePath
	planId := fileState.plan.Id
	branch := fileState.branch

	activeBuild.Success = true

	stillBuildingPath := fileState.buildNextInQueue()
	if stillBuildingPath {
		return
	}

	log.Printf("No more builds for path %s, checking if entire build is finished\n", filePath)

	buildFinished := false

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.BuiltFiles[filePath] = true
		ap.IsBuildingByPath[filePath] = false
		if ap.BuildFinished() {
			buildFinished = true
		}
	})

	log.Printf("Finished building file %s\n", filePath)

	if buildFinished {
		log.Println("Finished building plan, calling onFinishBuild")
		fileState.onFinishBuild()
	} else {
		log.Println("Finished building file, but plan is not finished")
	}
}

func (fileState *activeBuildStreamFileState) onBuildFileError(err error) {
	planId := fileState.plan.Id
	branch := fileState.branch
	filePath := fileState.filePath
	build := fileState.build
	activeBuild := fileState.activeBuild

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		log.Println("onBuildFileError - Active plan not found")
		return
	}

	log.Printf("Error for file %s: %v\n", filePath, err)

	activeBuild.Success = false
	activeBuild.Error = err

	go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error for file %s: %v", filePath, err))

	activePlan.StreamDoneCh <- &shared.ApiError{
		Type:   shared.ApiErrorTypeOther,
		Status: http.StatusInternalServerError,
		Msg:    err.Error(),
	}

	if err != nil {
		log.Printf("Error storing plan error result: %v\n", err)
	}

	build.Error = err.Error()

	err = db.SetBuildError(build)
	if err != nil {
		log.Printf("Error setting build error: %v\n", err)
	}
}

func (fileState *activeBuildStreamFileState) buildNextInQueue() bool {
	filePath := fileState.filePath
	activePlan := GetActivePlan(fileState.plan.Id, fileState.branch)
	if activePlan == nil {
		log.Println("onFinishBuildFile - Active plan not found")
		return false
	}

	// if more builds are queued, start the next one
	if !activePlan.PathQueueEmpty(filePath) {
		log.Printf("Processing next build for file %s\n", filePath)
		queue := activePlan.BuildQueuesByPath[filePath]
		var nextBuild *types.ActiveBuild
		for _, build := range queue {
			if !build.BuildFinished() {
				nextBuild = build
				break
			}
		}

		if nextBuild != nil {
			log.Println("Calling execPlanBuild for next build in queue")
			go fileState.execPlanBuild(nextBuild)
		}
		return true
	}

	return false
}


================================================
FILE: app/server/model/plan/build_load.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/syntax"
	"plandex-server/types"
	"runtime"
	"runtime/debug"

	shared "plandex-shared"
)

func (state *activeBuildStreamState) loadPendingBuilds(sessionId string) (map[string][]*types.ActiveBuild, error) {
	clients := state.clients
	plan := state.plan
	branch := state.branch
	auth := state.auth

	active, err := activatePlan(clients, plan, branch, auth, "", true, false, sessionId)

	if err != nil {
		log.Printf("Error activating plan: %v\n", err)
	}

	modelStreamId := active.ModelStreamId
	state.modelStreamId = modelStreamId

	var modelContext []*db.Context
	var pendingBuildsByPath map[string][]*types.ActiveBuild
	var settings *shared.PlanSettings
	var orgUserConfig *shared.OrgUserConfig

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   plan.Id,
		Branch:   branch,
		Scope:    db.LockScopeRead,
		Ctx:      active.Ctx,
		CancelFn: active.CancelFn,
		Reason:   "load pending builds",
	}, func(repo *db.GitRepo) error {
		errCh := make(chan error, 4)

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanContexts: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan modelContext: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			res, err := db.GetPlanContexts(auth.OrgId, plan.Id, true, false)
			if err != nil {
				log.Printf("Error getting plan modelContext: %v\n", err)
				errCh <- fmt.Errorf("error getting plan modelContext: %v", err)
				return
			}
			modelContext = res

			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanSettings: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan settings: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			res, err := active.PendingBuildsByPath(auth.OrgId, auth.User.Id, nil)

			if err != nil {
				log.Printf("Error getting pending builds by path: %v\n", err)
				errCh <- fmt.Errorf("error getting pending builds by path: %v", err)
				return
			}

			pendingBuildsByPath = res

			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanSettings: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan settings: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			res, err := db.GetPlanSettings(plan)
			if err != nil {
				log.Printf("Error getting plan settings: %v\n", err)
				errCh <- fmt.Errorf("error getting plan settings: %v", err)
				return
			}

			settings = res
			errCh <- nil
		}()

		go func() {

			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getOrgUserConfig: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting org user config: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			res, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
			if err != nil {
				log.Printf("Error getting org user config: %v\n", err)
				errCh <- fmt.Errorf("error getting org user config: %v", err)
				return
			}

			orgUserConfig = res
			errCh <- nil
		}()

		for i := 0; i < 4; i++ {
			err = <-errCh
			if err != nil {
				log.Printf("Error getting plan data: %v\n", err)
				return err
			}
		}
		return nil
	})

	if err != nil {
		return nil, fmt.Errorf("error getting plan data: %v", err)
	}

	UpdateActivePlan(plan.Id, branch, func(ap *types.ActivePlan) {
		ap.Contexts = modelContext
		for _, context := range modelContext {
			if context.FilePath != "" {
				ap.ContextsByPath[context.FilePath] = context
			}
		}
	})

	state.modelContext = modelContext
	state.settings = settings
	state.orgUserConfig = orgUserConfig

	return pendingBuildsByPath, nil
}

func (state *activeBuildStreamFileState) loadBuildFile(activeBuild *types.ActiveBuild) error {
	currentOrgId := state.currentOrgId
	planId := state.plan.Id
	branch := state.branch
	filePath := state.filePath

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		return fmt.Errorf("active plan not found")
	}

	convoMessageId := activeBuild.ReplyId

	parser, lang, fallbackParser, fallbackLang := syntax.GetParserForPath(filePath)

	if parser != nil {
		validationRes, err := syntax.ValidateWithParsers(activePlan.Ctx, lang, parser, fallbackLang, fallbackParser, state.preBuildState)
		if err != nil {
			log.Printf(" error validating original file syntax: %v\n", err)
			return fmt.Errorf("error validating original file syntax: %v", err)
		}

		state.language = validationRes.Lang
		state.parser = validationRes.Parser

		state.builderRun.Lang = string(validationRes.Lang)

		if validationRes.TimedOut {
			state.syntaxCheckTimedOut = true
		} else if !validationRes.Valid {
			state.preBuildStateSyntaxInvalid = true
		}
	}

	build := &db.PlanBuild{
		OrgId:          currentOrgId,
		PlanId:         planId,
		ConvoMessageId: convoMessageId,
		FilePath:       filePath,
	}
	err := db.StorePlanBuild(build)

	if err != nil {
		log.Printf("Error storing plan build: %v\n", err)
		UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
			ap.IsBuildingByPath[filePath] = false
		})
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error storing plan build: %v", err))

		activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error storing plan build: " + err.Error(),
		}
		return err
	}

	var currentPlan *shared.CurrentPlanState
	var convo []*db.ConvoMessage

	log.Println("Locking repo for load build file")

	err = db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:       currentOrgId,
		UserId:      state.activeBuildStreamState.currentUserId,
		PlanId:      planId,
		Branch:      branch,
		PlanBuildId: build.Id,
		Scope:       db.LockScopeRead,
		Ctx:         activePlan.Ctx,
		CancelFn:    activePlan.CancelFn,
		Reason:      "load build file",
	}, func(repo *db.GitRepo) error {
		errCh := make(chan error, 2)

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getCurrentPlanState: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting current plan state: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			log.Println("loadBuildFile - Getting current plan state")
			res, err := db.GetCurrentPlanState(db.CurrentPlanStateParams{
				OrgId:  currentOrgId,
				PlanId: planId,
			})
			if err != nil {
				log.Printf("Error getting current plan state: %v\n", err)
				UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
					ap.IsBuildingByPath[filePath] = false
				})
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error getting current plan state: %v", err))

				activePlan.StreamDoneCh <- &shared.ApiError{
					Type:   shared.ApiErrorTypeOther,
					Status: http.StatusInternalServerError,
					Msg:    "Error getting current plan state: " + err.Error(),
				}
				errCh <- fmt.Errorf("error getting current plan state: %v", err)
				return
			}
			currentPlan = res

			log.Println("Got current plan state")
			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanConvo: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan convo: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			res, err := db.GetPlanConvo(currentOrgId, planId)
			if err != nil {
				log.Printf("Error getting plan convo: %v\n", err)
				errCh <- fmt.Errorf("error getting plan convo: %v", err)
				return
			}
			convo = res

			errCh <- nil
		}()

		for i := 0; i < 2; i++ {
			err = <-errCh
			if err != nil {
				log.Printf("Error getting plan data: %v\n", err)
				return err
			}
		}

		return nil
	})

	if err != nil {
		log.Printf("Error loading build file: %v\n", err)
		UpdateActivePlan(activePlan.Id, activePlan.Branch, func(ap *types.ActivePlan) {
			ap.IsBuildingByPath[filePath] = false
		})
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error loading build file: %v", err))

		activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error loading build file: " + err.Error(),
		}
		return err
	}

	state.filePath = filePath
	state.convoMessageId = convoMessageId
	state.build = build
	state.currentPlanState = currentPlan
	state.convo = convo

	return nil

}


================================================
FILE: app/server/model/plan/build_race.go
================================================
package plan

import (
	"context"
	"errors"
	"fmt"
	"log"
	"plandex-server/syntax"
	"plandex-server/utils"
	"runtime"
	"runtime/debug"
	"strings"
	"time"
)

type raceResult struct {
	content string
	valid   bool
}

type buildRaceParams struct {
	updated         string
	proposedContent string
	desc            string
	reasons         []syntax.NeedsVerifyReason
	syntaxErrors    []string

	didCallFastApply bool
	fastApplyCh      chan string

	sessionId string
}

func (fileState *activeBuildStreamFileState) buildRace(
	buildCtx context.Context,
	cancelBuild context.CancelFunc,
	params buildRaceParams,
) (raceResult, error) {
	log.Printf("buildRace - starting race for file")
	defer func() {
		log.Printf("buildRace - canceling build context")
		cancelBuild()
	}()

	originalFile := fileState.preBuildState

	updated := params.updated
	proposedContent := params.proposedContent
	desc := params.desc
	reasons := params.reasons
	syntaxErrors := params.syntaxErrors
	fastApplyCh := params.fastApplyCh
	sessionId := params.sessionId
	log.Printf("buildRace - original file length: %d, updated length: %d", len(originalFile), len(updated))
	log.Printf("buildRace - has %d syntax errors and %d verify reasons", len(syntaxErrors), len(reasons))

	maxErrs := 3

	resCh := make(chan raceResult, 1)
	errCh := make(chan error, maxErrs)

	sendRes := func(res raceResult) {
		select {
		case resCh <- res:
		case <-buildCtx.Done():
			log.Printf("buildRace - context canceled, skipping sendRes")
		}
	}

	sendErr := func(err error) {
		select {
		case errCh <- err:
		case <-buildCtx.Done():
			log.Printf("buildRace - context canceled, skipping sendErr")
		}
	}

	startedFallbacks := false

	startWholeFileBuild := func(comments string) {
		log.Printf("buildRace - starting whole file fallback build")
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in startWholeFileBuild: %v\n%s", r, debug.Stack())
					sendErr(fmt.Errorf("error starting whole file build: %v", r))
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			select {
			case <-buildCtx.Done():
				log.Printf("buildRace - context already canceled, skipping whole file build")
				return
			default:
			}

			content, err := fileState.buildWholeFileFallback(buildCtx, proposedContent, desc, comments, sessionId)

			if err != nil {
				if errors.Is(err, context.Canceled) {
					log.Printf("Context canceled during whole file build")
					return
				}

				log.Printf("buildRace - whole file build failed: %v", err)
				sendErr(fmt.Errorf("error building whole file: %w", err))
			} else {
				log.Printf("buildRace - whole file build succeeded")
				sendRes(raceResult{content: content, valid: true})
			}
		}()
	}

	maybeStartFastApply := func(onFail func()) {
		log.Printf("buildRace - starting fast apply")
		if !params.didCallFastApply {
			log.Printf("buildRace - fast apply isn't defined, skipping")
			sendErr(nil) // no error, just no fast apply
			onFail()
			return
		}

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in maybeStartFastApply: %v\n%s", r, debug.Stack())
					sendErr(fmt.Errorf("error starting fast apply: %v", r))
					onFail()
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()
			var fastApplyRes string

			select {
			case fastApplyRes = <-fastApplyCh:
			case <-buildCtx.Done():
				log.Printf("buildRace - context canceled, skipping fast apply")
				sendErr(nil) // no error, just no fast apply
				onFail()
				return
			}

			if fastApplyRes == "" {
				log.Printf("buildRace - fast apply isn't defined or failed to run")
				sendErr(nil) // no error, just no fast apply
				onFail()
				return
			}

			// log.Printf("buildRace - fast apply result:\n\n%s", fastApplyRes)

			fastApplySyntaxErrors := fileState.validateSyntax(buildCtx, fastApplyRes)
			fileState.builderRun.FastApplySyntaxErrors = fastApplySyntaxErrors

			if len(fastApplySyntaxErrors) > 0 {
				log.Printf("buildRace - fast apply succeeded, but has %d syntax errors", len(fastApplySyntaxErrors))
				sendErr(fmt.Errorf("fast apply succeeded, but has %d syntax errors", len(fastApplySyntaxErrors)))
				onFail()
				return
			}

			log.Printf("buildRace - fast apply returned, validating...	")
			validateResult, err := fileState.buildValidateLoop(buildCtx, buildValidateLoopParams{
				originalFile:    originalFile,
				updated:         fastApplyRes,
				proposedContent: proposedContent,
				desc:            desc,
				reasons:         reasons,

				// just validate since we're already building replacements in parallel
				maxAttempts:                1,
				validateOnlyOnFinalAttempt: true,
				isInitial:                  false,
				sessionId:                  sessionId,
			})

			if err != nil {
				if errors.Is(err, context.Canceled) {
					log.Printf("Context canceled during fast apply validation")
					return
				}

				log.Printf("buildRace - fast apply validation failed with error: %v", err)
				sendErr(fmt.Errorf("fast apply validation failed: %w", err))
				onFail()
				return
			}

			if validateResult.valid {
				log.Printf("buildRace - fast apply validation succeeded")
				fileState.builderRun.FastApplySuccess = true
				sendRes(raceResult{content: validateResult.updated, valid: validateResult.valid})
			} else {
				log.Printf("buildRace - fast apply validation failed with problem: %s", validateResult.problem)
				fileState.builderRun.FastApplyFailureResponse = validateResult.problem
				sendErr(fmt.Errorf("fast apply validation failed: %s", validateResult.problem))
				onFail()
				return
			}
		}()
	}

	startFallbacks := func(comments string) {
		startedFallbacks = true
		// try fast apply + validation first if it's defined
		// if it's undefined or fails, start the whole file build fallback
		maybeStartFastApply(func() {
			startWholeFileBuild(comments)
		})
	}

	// If we get an incorrect marker, start the whole file build in the background while the validation/replacement loop continues
	onInitialStream := func(chunk string, buffer string) bool {
		if !startedFallbacks && strings.Contains(buffer, "<PlandexIncorrect/>") && strings.Contains(buffer, "<PlandexComments>") {
			log.Printf("buildRace - detected incorrect marker, triggering whole file build")

			comments := utils.GetXMLContent(buffer, "PlandexComments")

			startFallbacks(comments)
		}
		// keep streaming
		return false
	}

	fileState.builderRun.AutoApplyValidationStartedAt = time.Now()

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in buildRace validation loop: %v\n%s", r, debug.Stack())
				sendErr(fmt.Errorf("error building validate loop: %v", r))
				runtime.Goexit() // don't allow outer function to continue and double-send to channel
			}
		}()

		log.Printf("buildRace - starting validation loop")
		validateResult, err := fileState.buildValidateLoop(buildCtx, buildValidateLoopParams{
			originalFile:         originalFile,
			updated:              updated,
			proposedContent:      proposedContent,
			desc:                 desc,
			reasons:              reasons,
			syntaxErrors:         syntaxErrors,
			initialPhaseOnStream: onInitialStream,
			isInitial:            true,
			sessionId:            sessionId,
		})

		fileState.builderRun.AutoApplyValidationFinishedAt = time.Now()

		if err != nil {
			if errors.Is(err, context.Canceled) {
				log.Printf("Context canceled during buildValidate")
				return
			}

			log.Printf("buildRace - validation loop failed: %v", err)
			sendErr(fmt.Errorf("error building validate loop: %w", err))
		} else {
			log.Printf("buildRace - validation loop finished, valid: %v", validateResult.valid)
			if validateResult.valid {
				log.Printf("buildRace - validation loop succeeded, valid: %v", validateResult.valid)
				sendRes(raceResult{content: validateResult.updated, valid: validateResult.valid})
			} else {
				log.Printf("buildRace - validation loop failed, valid: %v", validateResult.valid)
				sendErr(fmt.Errorf("validation loop failed: %s", validateResult.problem))
			}
		}
	}()

	errs := []error{}
	errChNumReceived := 0

	for {
		select {
		case <-buildCtx.Done():
			log.Printf("buildRace - context canceled")
			return raceResult{}, buildCtx.Err()
		case err := <-errCh:
			errChNumReceived++
			log.Printf("buildRace - error channel received %d: %v\n", errChNumReceived, err)

			if err != nil {
				errs = append(errs, err)
			}

			if errChNumReceived >= maxErrs {
				log.Printf("buildRace - all attempts failed with %d errors", len(errs))
				return raceResult{}, fmt.Errorf("all build attempts failed: %v", errs)
			}

			if !startedFallbacks {
				log.Printf("buildRace - starting build fallbacks")
				startFallbacks("") // since replacements failed, pass an empty string for comments -- this causes whole file build to classify comments first
			}
		case res := <-resCh:
			log.Printf("buildRace - got successful result")
			return res, nil
		}
	}
}


================================================
FILE: app/server/model/plan/build_state.go
================================================
package plan

import (
	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/model"
	"plandex-server/types"

	shared "plandex-shared"

	sitter "github.com/smacker/go-tree-sitter"
)

const MaxBuildErrorRetries = 3 // uses semi-exponential backoff so be careful with this

type activeBuildStreamState struct {
	modelStreamId string
	clients       map[string]model.ClientInfo
	authVars      map[string]string
	auth          *types.ServerAuth
	currentOrgId  string
	currentUserId string
	orgUserConfig *shared.OrgUserConfig
	plan          *db.Plan
	branch        string
	settings      *shared.PlanSettings
	modelContext  []*db.Context
	convo         []*db.ConvoMessage
}

type activeBuildStreamFileState struct {
	*activeBuildStreamState
	filePath                   string
	convoMessageId             string
	build                      *db.PlanBuild
	currentPlanState           *shared.CurrentPlanState
	activeBuild                *types.ActiveBuild
	preBuildState              string
	parser                     *sitter.Parser
	language                   shared.Language
	syntaxCheckTimedOut        bool
	preBuildStateSyntaxInvalid bool
	validationNumRetry         int
	wholeFileNumRetry          int
	isNewFile                  bool
	contextPart                *db.Context

	builderRun hooks.DidFinishBuilderRunParams
}


================================================
FILE: app/server/model/plan/build_structured_edits.go
================================================
package plan

import (
	"context"
	"fmt"
	"log"
	"plandex-server/db"
	diff_pkg "plandex-server/diff"
	"plandex-server/hooks"
	"plandex-server/syntax"
	"plandex-server/utils"
	"runtime"
	"runtime/debug"
	"strings"
	"time"

	shared "plandex-shared"
)

func (fileState *activeBuildStreamFileState) buildStructuredEdits() {
	filePath := fileState.filePath
	activeBuild := fileState.activeBuild
	planId := fileState.plan.Id
	branch := fileState.branch
	originalFile := fileState.preBuildState
	parser := fileState.parser

	if parser == nil {
		log.Printf("buildStructuredEdits - tree-sitter parser is nil for file %s\n", filePath)
	}

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
		fileState.onBuildFileError(fmt.Errorf("active plan not found for plan ID %s and branch %s", planId, branch))
		return
	}

	buildCtx, cancelBuild := context.WithCancel(activePlan.Ctx)

	proposedContent := activeBuild.FileContent
	desc := activeBuild.FileDescription

	descLower := strings.ToLower(desc)
	isReplaceOrRemove := strings.Contains(descLower, "type: replace") || strings.Contains(descLower, "type: remove") || strings.Contains(descLower, "type: overwrite")

	var autoApplyRes *syntax.ApplyChangesResult
	var autoApplySyntaxErrors []string

	calledFastApply := false
	var fastApplyRes string
	fastApplyCh := make(chan string, 1)

	callFastApply := func() {
		log.Printf("buildStructuredEdits - %s - calling fast apply hook\n", filePath)
		fileState.builderRun.DidFastApply = true
		fileState.builderRun.FastApplyStartedAt = time.Now()
		calledFastApply = true

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in callFastApply: %v\n%s", r, debug.Stack())
					fastApplyCh <- ""
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			res, err := hooks.ExecHook(hooks.CallFastApply, hooks.HookParams{
				FastApplyParams: &hooks.FastApplyParams{
					InitialCode: originalFile,
					EditSnippet: proposedContent,
					Language:    fileState.language,
					Ctx:         buildCtx,
				},
			})

			if err != nil {
				log.Printf("buildStructuredEdits - error executing fast apply hook: %v\n", err)
				// empty string acts as a no-op
				fastApplyCh <- ""
				return
			} else if res.FastApplyResult == nil {
				log.Printf("buildStructuredEdits - fast apply hook returned nil result\n")
				// empty string acts as a no-op
				fastApplyCh <- ""
				return
			}

			fastApplyRes = res.FastApplyResult.MergedCode
			log.Printf("buildStructuredEdits - %s - got fast apply hook result\n", filePath)
			// fmt.Printf("buildStructuredEdits - fastApplyRes:\n%s", fastApplyRes)

			fileState.builderRun.FastApplyFinishedAt = time.Now()

			fastApplyCh <- fastApplyRes
		}()
	}

	if isReplaceOrRemove {
		callFastApply()
	}

	log.Printf("buildStructuredEdits - %s - applying changes\n", filePath)
	// Apply plan logic
	log.Printf("buildStructuredEdits - %s - calling ApplyChanges\n", filePath)
	autoApplyRes = syntax.ApplyChanges(
		buildCtx,
		syntax.ApplyChangesParams{
			Original:               originalFile,
			Proposed:               proposedContent,
			Desc:                   desc,
			AddMissingStartEndRefs: true,
			Parser:                 fileState.parser,
			Language:               fileState.language,
		},
	)
	log.Printf("buildStructuredEdits - %s - got ApplyChanges result\n", filePath)
	// log.Printf("buildStructuredEdits - autoApplyRes.NewFile:\n\n%s", autoApplyRes.NewFile)
	log.Println("buildStructuredEdits - autoApplyRes.NeedsVerifyReasons:", autoApplyRes.NeedsVerifyReasons)

	autoApplySyntaxErrors = fileState.validateSyntax(buildCtx, autoApplyRes.NewFile)

	hasNeedsVerifyReasons := len(autoApplyRes.NeedsVerifyReasons) > 0

	autoApplyHasSyntaxErrors := len(autoApplySyntaxErrors) > 0
	autoApplyIsValid := !autoApplyHasSyntaxErrors && !hasNeedsVerifyReasons

	if !autoApplyIsValid && !calledFastApply {
		callFastApply()
	}

	log.Printf("buildStructuredEdits - %s - autoApplyHasSyntaxErrors: %t, hasNeedsVerifyReasons: %t, autoApplyIsValid: %t\n",
		filePath, autoApplyHasSyntaxErrors, hasNeedsVerifyReasons, autoApplyIsValid)

	updated := autoApplyRes.NewFile

	// If no problems, we trust the direct ApplyChanges result
	if autoApplyIsValid {
		log.Printf("buildStructuredEdits - %s - changes are valid, using ApplyChanges result\n", filePath)
		fileState.builderRun.AutoApplySuccess = true
	} else {
		log.Printf("buildStructuredEdits - %s - auto apply has syntax errors or NeedsVerifyReasons", filePath)
		fileState.builderRun.AutoApplyValidationReasons = make([]string, len(autoApplyRes.NeedsVerifyReasons))
		for i, reason := range autoApplyRes.NeedsVerifyReasons {
			fileState.builderRun.AutoApplyValidationReasons[i] = string(reason)
		}

		fileState.builderRun.AutoApplyValidationSyntaxErrors = autoApplySyntaxErrors

		buildRaceParams := buildRaceParams{
			updated:         updated,
			proposedContent: proposedContent,
			desc:            desc,
			reasons:         autoApplyRes.NeedsVerifyReasons,
			syntaxErrors:    autoApplySyntaxErrors,

			didCallFastApply: calledFastApply,
			fastApplyCh:      fastApplyCh,

			sessionId: activePlan.SessionId,
		}

		buildRaceResult, err := fileState.buildRace(buildCtx, cancelBuild, buildRaceParams)
		if err != nil {
			if apiErr, ok := err.(*shared.ApiError); ok {
				activePlan.StreamDoneCh <- apiErr
				return
			} else {
				log.Printf("buildStructuredEdits - %s - error building race: %v\n", filePath, err)
				fileState.onBuildFileError(fmt.Errorf("error building race: %v", err))
			}
			return
		}

		updated = buildRaceResult.content
	}

	// output diff and store build results
	buildInfo := &shared.BuildInfo{
		Path:      filePath,
		NumTokens: 0,
		Finished:  true,
	}
	log.Printf("streaming build info for finished file %s\n", filePath)
	activePlan.Stream(shared.StreamMessage{
		Type:      shared.StreamMessageBuildInfo,
		BuildInfo: buildInfo,
	})
	time.Sleep(50 * time.Millisecond)

	// strip any blank lines from beginning/end of updated file
	updated = utils.StripAddedBlankLines(originalFile, updated)

	log.Printf("buildStructuredEdits - %s - getting diff replacements\n", filePath)
	replacements, err := diff_pkg.GetDiffReplacements(originalFile, updated)
	if err != nil {
		log.Printf("buildStructuredEdits - error getting diff replacements: %v\n", err)
		fileState.onBuildFileError(fmt.Errorf("error getting diff replacements: %v", err))
		return
	}
	log.Printf("buildStructuredEdits - %s - got %d replacements\n", filePath, len(replacements))

	for _, replacement := range replacements {
		replacement.Summary = strings.TrimSpace(desc)
	}

	res := db.PlanFileResult{
		TypeVersion:    1,
		OrgId:          fileState.plan.OrgId,
		PlanId:         fileState.plan.Id,
		PlanBuildId:    fileState.build.Id,
		ConvoMessageId: fileState.convoMessageId,
		Content:        "",
		Path:           filePath,
		Replacements:   replacements,
	}

	log.Printf("buildStructuredEdits - %s - finishing build file\n", filePath)
	fileState.onFinishBuildFile(&res)
}

func (fileState *activeBuildStreamFileState) validateSyntax(buildCtx context.Context, updated string) []string {
	if fileState.parser != nil && !fileState.preBuildStateSyntaxInvalid && !fileState.syntaxCheckTimedOut {
		validationRes, err := syntax.ValidateWithParsers(buildCtx, fileState.language, fileState.parser, "", nil, updated) // fallback parser was already set as fileState.parser if needed during initial preBuildState syntax check
		if err != nil {
			log.Printf("buildStructuredEdits - error validating updated file: %v\n", err)
		} else if validationRes.TimedOut {
			log.Printf("buildStructuredEdits - syntax check timed out for updated file\n")
			fileState.syntaxCheckTimedOut = true
			return nil
		} else {
			return validationRes.Errors
		}
	}

	return nil
}


================================================
FILE: app/server/model/plan/build_validate_and_fix.go
================================================
package plan

import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	diff_pkg "plandex-server/diff"
	"plandex-server/model"
	"plandex-server/model/prompts"
	"plandex-server/syntax"
	"plandex-server/types"
	"plandex-server/utils"
	shared "plandex-shared"
	"strings"
	"time"

	"github.com/sashabaranov/go-openai"
)

const MaxValidationFixAttempts = 3

type buildValidateLoopParams struct {
	originalFile               string
	updated                    string
	proposedContent            string
	desc                       string
	syntaxErrors               []string
	reasons                    []syntax.NeedsVerifyReason
	initialPhaseOnStream       func(chunk string, buffer string) bool
	validateOnlyOnFinalAttempt bool
	maxAttempts                int
	isInitial                  bool
	sessionId                  string
}

type buildValidateLoopResult struct {
	valid   bool
	updated string
	problem string
}

func (fileState *activeBuildStreamFileState) buildValidateLoop(
	ctx context.Context,
	params buildValidateLoopParams,
) (buildValidateLoopResult, error) {
	log.Printf("Starting buildValidateLoop for file: %s", fileState.filePath)

	originalFile := params.originalFile
	updated := params.updated
	proposedContent := params.proposedContent
	desc := params.desc

	syntaxErrors := params.syntaxErrors
	numAttempts := 0

	problems := []string{}

	maxAttempts := MaxValidationFixAttempts
	if params.maxAttempts > 0 {
		maxAttempts = params.maxAttempts
	}

	for numAttempts < maxAttempts {
		currentAttempt := numAttempts + 1
		log.Printf("Starting validation attempt %d/%d", currentAttempt, MaxValidationFixAttempts)

		// check for context cancellation
		if ctx.Err() != nil {
			log.Printf("Context cancelled during attempt %d", currentAttempt)
			return buildValidateLoopResult{}, ctx.Err()
		}

		// reset retry count for each phase
		fileState.validationNumRetry = 0
		log.Printf("Reset validation retry count for attempt %d", currentAttempt)

		var onStream func(chunk string, buffer string) bool
		if numAttempts == 0 {
			onStream = params.initialPhaseOnStream
			log.Printf("Using initial phase onStream handler")
		} else {
			onStream = nil
			log.Printf("No onStream handler for attempt %d", currentAttempt)
		}

		var reasons []syntax.NeedsVerifyReason
		if numAttempts == 0 {
			reasons = params.reasons
			log.Printf("Using initial reasons for validation")
		} else {
			reasons = []syntax.NeedsVerifyReason{}
			log.Printf("Using empty reasons list for attempt %d", currentAttempt)
		}

		modelConfig := fileState.settings.GetModelPack().Builder
		// if available, switch to stronger model after the first attempt failed
		if currentAttempt > 2 && modelConfig.StrongModel != nil {
			log.Printf("Switching to strong model for attempt %d", currentAttempt)
			modelConfig = *modelConfig.StrongModel
		}

		isLastAttempt := numAttempts == maxAttempts-1

		// build validate params
		validateParams := buildValidateParams{
			originalFile:    originalFile,
			updated:         updated,
			proposedContent: proposedContent,
			desc:            desc,
			onStream:        onStream,
			syntaxErrors:    syntaxErrors,
			reasons:         reasons,
			modelConfig:     &modelConfig,
			validateOnly:    isLastAttempt && params.validateOnlyOnFinalAttempt,
			phase:           currentAttempt,
			isInitial:       params.isInitial,
			sessionId:       params.sessionId,
		}

		log.Printf("Calling buildValidate for attempt %d", currentAttempt)
		res, err := fileState.buildValidate(ctx, validateParams)
		if err != nil {
			if errors.Is(err, context.Canceled) {
				log.Printf("Context canceled during buildValidate")
				return buildValidateLoopResult{}, err
			}

			log.Printf("Error in buildValidate during attempt %d: %v", currentAttempt, err)
			return buildValidateLoopResult{}, fmt.Errorf("error building validate: %v", err)
		}
		updated = res.updated

		syntaxErrors = fileState.validateSyntax(ctx, updated)
		log.Printf("Found %d syntax errors after attempt %d", len(syntaxErrors), currentAttempt)

		if res.valid && len(syntaxErrors) == 0 {
			log.Printf("Validation succeeded in attempt %d", currentAttempt)
			return buildValidateLoopResult{
				valid:   res.valid,
				updated: res.updated,
			}, nil
		}

		problems = append(problems, res.problem)

		log.Printf("Validation failed in attempt %d, preparing for next attempt", currentAttempt)

		numAttempts++
	}

	log.Printf("Validation failed after %d attempts", MaxValidationFixAttempts)
	return buildValidateLoopResult{
		valid:   false,
		updated: updated,
		problem: strings.Join(problems, "\n\n"),
	}, nil
}

type buildValidateParams struct {
	originalFile    string
	updated         string
	proposedContent string
	desc            string
	syntaxErrors    []string
	reasons         []syntax.NeedsVerifyReason
	onStream        func(chunk string, buffer string) bool
	phase           int
	modelConfig     *shared.ModelRoleConfig
	validateOnly    bool
	isInitial       bool
	sessionId       string
}

type buildValidateResult struct {
	valid   bool
	updated string
	problem string
}

func (fileState *activeBuildStreamFileState) buildValidate(
	ctx context.Context,
	params buildValidateParams,
) (buildValidateResult, error) {
	log.Printf("Starting buildValidate for phase %d", params.phase)

	auth := fileState.auth
	filePath := fileState.filePath
	clients := fileState.clients
	authVars := fileState.authVars
	modelConfig := params.modelConfig

	originalFile := params.originalFile
	updated := params.updated
	proposedContent := params.proposedContent
	desc := params.desc
	onStream := params.onStream
	syntaxErrors := params.syntaxErrors
	reasons := params.reasons

	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, fileState.settings, fileState.orgUserConfig)

	// Get diff for validation
	log.Printf("Getting diffs between original and updated content")
	diff, err := diff_pkg.GetDiffs(originalFile, updated)
	if err != nil {
		log.Printf("Error getting diffs: %v", err)
		return buildValidateResult{}, fmt.Errorf("error getting diffs: %v", err)
	}

	originalWithLineNums := shared.AddLineNums(originalFile)
	proposedWithLineNums := shared.AddLineNums(proposedContent)

	maxExpectedOutputTokens := shared.GetNumTokensEstimate(originalFile)/2 + shared.GetNumTokensEstimate(proposedContent)

	// Choose prompt and tools based on preferred format

	log.Printf("Building XML validation replacements prompt")
	promptText, headNumTokens := prompts.GetValidationReplacementsXmlPrompt(prompts.ValidationPromptParams{
		Path:                 filePath,
		OriginalWithLineNums: originalWithLineNums,
		Desc:                 desc,
		ProposedWithLineNums: proposedWithLineNums,
		Diff:                 diff,
		SyntaxErrors:         syntaxErrors,
		Reasons:              reasons,
	})

	// log.Printf("Prompt to LLM: %s", promptText)

	log.Printf("Creating initial messages for phase 1")
	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: promptText,
				},
			},
		},
	}
	reqStarted := time.Now()
	fileState.builderRun.ReplacementStartedAt = reqStarted

	if params.validateOnly {
		log.Printf("Making validation-only model request")
	} else {
		log.Printf("Making validation-replacements model request")
	}
	// log.Printf("Messages: %v", messages)

	stop := []string{"<PlandexFinish/>"}
	if params.validateOnly {
		stop = []string{"<PlandexComments>", "<PlandexReplacements>"}
	}

	var willCacheNumTokens int
	isFirstPass := params.isInitial && params.phase == 1
	if !isFirstPass && baseModelConfig.Provider == shared.ModelProviderOpenAI {
		willCacheNumTokens = headNumTokens
	}

	log.Printf("buildValidate - calling model.ModelRequest")
	// spew.Dump(messages)

	// Use ModelRequest for both formats
	res, err := model.ModelRequest(ctx, model.ModelRequestParams{
		Clients:        clients,
		Auth:           auth,
		AuthVars:       authVars,
		Plan:           fileState.plan,
		ModelConfig:    modelConfig,
		Purpose:        "File edit",
		Messages:       messages,
		ModelStreamId:  fileState.modelStreamId,
		ConvoMessageId: fileState.convoMessageId,
		BuildId:        fileState.build.Id,
		ModelPackName:  fileState.settings.GetModelPack().Name,
		Stop:           stop,
		BeforeReq: func() {
			log.Printf("Starting model request")
			fileState.builderRun.ReplacementStartedAt = time.Now()
		},
		AfterReq: func() {
			log.Printf("Finished model request")
			fileState.builderRun.ReplacementFinishedAt = time.Now()
		},
		OnStream: onStream,

		WillCacheNumTokens:    willCacheNumTokens,
		SessionId:             params.sessionId,
		EstimatedOutputTokens: maxExpectedOutputTokens,
		Settings:              fileState.settings,
		OrgUserConfig:         fileState.orgUserConfig,
	})

	if err != nil {
		if errors.Is(err, context.Canceled) {
			log.Printf("Context canceled during model request")
			return buildValidateResult{}, err
		}

		log.Printf("Error calling model: %v", err)
		return fileState.validationRetryOrError(ctx, params, err)
	}

	// log.Printf("Model response:\n\n%s", res.Content)

	fileState.builderRun.GenerationIds = append(fileState.builderRun.GenerationIds, res.GenerationId)
	log.Printf("Added generation ID: %s", res.GenerationId)

	// Handle response based on format
	parseRes, err := handleXMLResponse(fileState, res.Content, originalWithLineNums, updated, params.validateOnly)

	if err != nil {
		log.Printf("Error handling response: %v", err)
		return fileState.validationRetryOrError(ctx, params, err)
	}

	log.Printf("Validation result: valid=%v", parseRes.valid)

	return parseRes, nil
}

func handleXMLResponse(
	fileState *activeBuildStreamFileState,
	content string,
	originalWithLineNums shared.LineNumberedTextType,
	updated string,
	validateOnly bool,
) (buildValidateResult, error) {
	log.Printf("Handling XML response for file: %s", fileState.filePath)

	if strings.Contains(content, "<PlandexCorrect/>") {
		log.Printf("XML response indicates changes are correct")
		fileState.builderRun.ReplacementSuccess = true
		return buildValidateResult{
			valid:   true,
			updated: updated,
		}, nil
	}

	if validateOnly {
		log.Printf("Validation-only mode, skipping replacements")
		return buildValidateResult{
			valid:   false,
			updated: updated,
		}, nil
	}

	originalFileLines := strings.Split(string(originalWithLineNums), "\n")

	incremental := originalWithLineNums

	log.Printf("Processing XML replacement blocks")

	replacementsOuter := utils.GetXMLContent(content, "PlandexReplacements")

	if replacementsOuter == "" {
		log.Printf("No replacements found in XML response")
		return buildValidateResult{
			valid:   false,
			updated: shared.RemoveLineNums(incremental),
			problem: "No replacements found in XML response",
		}, nil
	}

	replacements := utils.GetAllXMLContent(replacementsOuter, "Replacement")

	for i, replacement := range replacements {
		log.Printf("Processing replacement: %d/%d", i+1, len(replacements))

		old := utils.GetXMLContent(replacement, "Old")
		new := utils.GetXMLContent(replacement, "New")

		if old == "" {
			log.Printf("No old content found for replacement")
			return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("no old content found for replacement")
		}

		old = strings.TrimSpace(old)

		// log.Printf("Old content trimmed:\n\n%s", strconv.Quote(old))

		// log.Printf("New content:\n\n%s", strconv.Quote(new))

		if !strings.HasPrefix(old, "pdx-") {
			log.Printf("Old content does not have a line number prefix for first line")
			return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("old content does not have a line number prefix for first line")
		}

		oldLines := strings.Split(old, "\n")

		var lastLine string
		var lastLineNum int
		firstLine := oldLines[0]
		if len(oldLines) > 1 {
			lastLine = oldLines[len(oldLines)-1]
		}

		firstLineNum, err := shared.ExtractLineNumberWithPrefix(firstLine, "pdx-")
		if err != nil {
			log.Printf("Error extracting line number from first line: %v", err)
			return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("error extracting line number from first line: %v", err)
		}

		if lastLine != "" {
			lastLineNum, err = shared.ExtractLineNumberWithPrefix(lastLine, "pdx-")
			if err != nil {
				log.Printf("Error extracting line number from last line: %v", err)
				return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("error extracting line number from last line: %v", err)
			}
		}

		if lastLineNum == 0 {
			if !(firstLineNum > 0 && firstLineNum <= len(originalFileLines)) {
				log.Printf("Invalid line number for first line: %d", firstLineNum)
				return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("invalid line number for first line: %d", firstLineNum)
			}
			old = originalFileLines[firstLineNum-1]
		} else {
			if !(firstLineNum > 0 && firstLineNum <= len(originalFileLines) && lastLineNum > firstLineNum && lastLineNum <= len(originalFileLines)) {
				log.Printf("Invalid line numbers for first and last lines: %d-%d", firstLineNum, lastLineNum)
				return buildValidateResult{valid: false, updated: updated}, fmt.Errorf("invalid line numbers: %d-%d", firstLineNum, lastLineNum)
			}
			old = strings.Join(originalFileLines[firstLineNum-1:lastLineNum], "\n")
		}

		// log.Printf("Applying replacement.\n\nOld:\n\n%s\n\nNew:\n\n%s", old, new)

		incremental = shared.LineNumberedTextType(strings.Replace(string(incremental), old, new, 1))

		// log.Printf("Updated content:\n\n%s", string(incremental))
	}

	var problem string

	if strings.Contains(content, "<PlandexIncorrect/>") {
		split := strings.Split(content, "<PlandexIncorrect/>")
		problem = split[0]
	} else if strings.Contains(content, "<PlandexReplacements>") {
		split := strings.Split(content, "<PlandexReplacements>")
		problem = split[0]
	}

	final := shared.RemoveLineNums(incremental)

	// log.Printf("Final content:\n\n%s", final)

	return buildValidateResult{valid: false, updated: final, problem: problem}, nil
}

func (fileState *activeBuildStreamFileState) validationRetryOrError(buildCtx context.Context, validateParams buildValidateParams, err error) (buildValidateResult, error) {
	log.Printf("Handling validation error for file: %s", fileState.filePath)
	if fileState.validationNumRetry < MaxBuildErrorRetries {
		fileState.validationNumRetry++

		log.Printf("Retrying validation (attempt %d/%d) due to error: %v",
			fileState.validationNumRetry, MaxBuildErrorRetries, err)

		activePlan := GetActivePlan(fileState.plan.Id, fileState.branch)

		if activePlan == nil {
			log.Printf("Active plan not found for plan ID %s and branch %s",
				fileState.plan.Id, fileState.branch)
			return buildValidateResult{}, fmt.Errorf("active plan not found for plan ID %s and branch %s",
				fileState.plan.Id, fileState.branch)
		}

		select {
		case <-buildCtx.Done():
			log.Printf("Context canceled during retry wait")
			return buildValidateResult{}, context.Canceled
		case <-time.After(time.Duration(fileState.validationNumRetry*fileState.validationNumRetry)*200*time.Millisecond + time.Duration(rand.Intn(500))*time.Millisecond):
			log.Printf("Retry wait completed, attempting validation again")
			break
		}

		return fileState.buildValidate(buildCtx, validateParams)
	} else {
		log.Printf("Max retries (%d) exceeded, returning error", MaxBuildErrorRetries)
		return buildValidateResult{}, err
	}
}


================================================
FILE: app/server/model/plan/build_whole_file.go
================================================
package plan

import (
	"context"
	"errors"
	"fmt"
	"log"
	"math/rand"
	"plandex-server/model"
	"plandex-server/model/prompts"
	"plandex-server/types"
	"plandex-server/utils"
	"time"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func (fileState *activeBuildStreamFileState) buildWholeFileFallback(buildCtx context.Context, proposedContent string, desc string, comments string, sessionId string) (string, error) {
	auth := fileState.auth
	filePath := fileState.filePath
	clients := fileState.clients
	authVars := fileState.authVars
	planId := fileState.plan.Id
	branch := fileState.branch
	originalFile := fileState.preBuildState
	config := fileState.settings.GetModelPack().GetWholeFileBuilder()

	activePlan := GetActivePlan(planId, branch)

	if activePlan == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)
		fileState.onBuildFileError(fmt.Errorf("active plan not found for plan ID %s and branch %s", planId, branch))
		return "", fmt.Errorf("active plan not found for plan ID %s and branch %s", planId, branch)
	}

	baseModelConfig := config.GetBaseModelConfig(authVars, fileState.settings, fileState.orgUserConfig)

	originalFileWithLineNums := shared.AddLineNums(originalFile)
	proposedContentWithLineNums := shared.AddLineNums(proposedContent)

	sysPrompt, headNumTokens := prompts.GetWholeFilePrompt(filePath, originalFileWithLineNums, proposedContentWithLineNums, desc, comments)

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: sysPrompt,
				},
			},
		},
	}

	inputTokens := model.GetMessagesTokenEstimate(messages...) + model.TokensPerRequest
	maxExpectedOutputTokens := shared.GetNumTokensEstimate(originalFile + proposedContent)

	modelConfig := config.GetRoleForInputTokens(inputTokens, fileState.settings)
	modelConfig = modelConfig.GetRoleForOutputTokens(maxExpectedOutputTokens, fileState.settings)

	log.Println("buildWholeFile - calling model for whole file write")

	var prediction string

	if baseModelConfig.PredictedOutputEnabled && comments != "" {
		prediction = `
<PlandexWholeFile>
` + originalFile + `
</PlandexWholeFile>
`

	}

	// This allows proper accounting for cached input tokens even when the stream is cancelled -- OpenAI only for now
	var willCacheNumTokens int
	if baseModelConfig.Provider == shared.ModelProviderOpenAI {
		willCacheNumTokens = headNumTokens
	}

	log.Println("buildWholeFile - calling model.ModelRequest")
	// spew.Dump(messages)

	modelRes, err := model.ModelRequest(buildCtx, model.ModelRequestParams{
		Clients:     clients,
		Auth:        auth,
		AuthVars:    authVars,
		Plan:        fileState.plan,
		ModelConfig: &config,
		Purpose:     "File edit",

		Messages:   messages,
		Prediction: prediction,

		ModelStreamId:  fileState.modelStreamId,
		ConvoMessageId: fileState.convoMessageId,
		BuildId:        fileState.build.Id,

		BeforeReq: func() {
			fileState.builderRun.BuiltWholeFile = true
			fileState.builderRun.BuildWholeFileStartedAt = time.Now()
		},

		AfterReq: func() {
			fileState.builderRun.BuildWholeFileFinishedAt = time.Now()
		},

		WillCacheNumTokens:    willCacheNumTokens,
		EstimatedOutputTokens: maxExpectedOutputTokens,

		SessionId:     sessionId,
		Settings:      fileState.settings,
		OrgUserConfig: fileState.orgUserConfig,
	})

	if err != nil {
		if errors.Is(err, context.Canceled) {
			log.Printf("buildWholeFileFallback - context canceled during model request for file %s", filePath)
			return "", err
		}

		return "", fmt.Errorf("error calling model: %v", err)
	}

	fileState.builderRun.GenerationIds = append(fileState.builderRun.GenerationIds, modelRes.GenerationId)
	fileState.builderRun.BuildWholeFileFinishedAt = time.Now()

	content := modelRes.Content

	// log.Printf("buildWholeFile - %s - content:\n%s\n", filePath, content)

	wholeFile := utils.GetXMLContent(content, "PlandexWholeFile")

	if wholeFile == "" {
		log.Printf("buildWholeFile - no whole file found in response\n")
		return fileState.wholeFileRetryOrError(buildCtx, proposedContent, desc, comments, sessionId, fmt.Errorf("no whole file found in response"))
	}

	return wholeFile, nil
}

func (fileState *activeBuildStreamFileState) wholeFileRetryOrError(buildCtx context.Context, proposedContent string, desc string, comments string, sessionId string, err error) (string, error) {
	if fileState.wholeFileNumRetry < MaxBuildErrorRetries {
		fileState.wholeFileNumRetry++

		log.Printf("buildWholeFile - retrying whole file file '%s' due to error: %v\n", fileState.filePath, err)

		activePlan := GetActivePlan(fileState.plan.Id, fileState.branch)

		if activePlan == nil {
			log.Printf("buildWholeFile - active plan not found for plan ID %s and branch %s\n", fileState.plan.Id, fileState.branch)
			// fileState.onBuildFileError(fmt.Errorf("active plan not found for plan ID %s and branch %s", fileState.plan.Id, fileState.branch))
			return "", fmt.Errorf("active plan not found for plan ID %s and branch %s", fileState.plan.Id, fileState.branch)
		}

		select {
		case <-buildCtx.Done():
			log.Printf("buildWholeFile - context canceled\n")
			return "", context.Canceled
		case <-time.After(time.Duration(fileState.wholeFileNumRetry*fileState.wholeFileNumRetry)*200*time.Millisecond + time.Duration(rand.Intn(500))*time.Millisecond):
			break
		}

		return fileState.buildWholeFileFallback(buildCtx, proposedContent, desc, comments, sessionId)
	} else {
		// fileState.onBuildFileError(err)
		return "", err
	}

}


================================================
FILE: app/server/model/plan/commit_msg.go
================================================
package plan

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/model/prompts"
	"plandex-server/notify"
	"plandex-server/types"
	"plandex-server/utils"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescription, *shared.ApiError) {
	auth := state.auth
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	settings := state.settings
	clients := state.clients
	authVars := state.authVars
	orgUserConfig := state.orgUserConfig
	config := settings.GetModelPack().CommitMsg

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("active plan not found for plan %s and branch %s", planId, branch))

		return nil, &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("active plan not found for plan %s and branch %s", planId, branch),
		}
	}

	baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)

	var sysPrompt string
	var tools []openai.Tool
	var toolChoice *openai.ToolChoice

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		sysPrompt = prompts.SysDescribeXml
	} else {
		sysPrompt = prompts.SysDescribe
		tools = []openai.Tool{
			{
				Type:     "function",
				Function: &prompts.DescribePlanFn,
			},
		}
		choice := openai.ToolChoice{
			Type: "function",
			Function: openai.ToolFunction{
				Name: prompts.DescribePlanFn.Name,
			},
		}
		toolChoice = &choice
	}

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: sysPrompt,
				},
			},
		},
		{
			Role: openai.ChatMessageRoleAssistant,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: activePlan.CurrentReplyContent,
				},
			},
		},
	}

	reqParams := model.ModelRequestParams{
		Clients:        clients,
		Auth:           auth,
		AuthVars:       authVars,
		Plan:           plan,
		ModelConfig:    &config,
		Purpose:        "Response summary",
		Messages:       messages,
		ModelStreamId:  state.modelStreamId,
		ConvoMessageId: state.replyId,
		SessionId:      activePlan.SessionId,
		Settings:       settings,
		OrgUserConfig:  orgUserConfig,
	}

	if tools != nil {
		reqParams.Tools = tools
	}
	if toolChoice != nil {
		reqParams.ToolChoice = toolChoice
	}

	modelRes, err := model.ModelRequest(activePlan.Ctx, reqParams)

	if err != nil {
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error during plan description model call: %v", err))

		return nil, &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("error during plan description model call: %v", err),
		}
	}

	log.Println("Plan description model call complete")

	content := modelRes.Content

	var commitMsg string

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		commitMsg = utils.GetXMLContent(content, "commitMsg")
		if commitMsg == "" {
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("no commitMsg tag found in XML response"))

			return nil, &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "No commitMsg tag found in XML response",
			}
		}
	} else {

		if content == "" {
			fmt.Println("no describePlan function call found in response")

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("no describePlan function call found in response"))

			return nil, &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "No describePlan function call found in response. The model failed to generate a valid response.",
			}
		}

		var desc shared.ConvoMessageDescription
		err = json.Unmarshal([]byte(content), &desc)
		if err != nil {
			fmt.Printf("Error unmarshalling plan description response: %v\n", err)

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error unmarshalling plan description response: %v", err))

			return nil, &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    fmt.Sprintf("error unmarshalling plan description response: %v", err),
			}
		}
		commitMsg = desc.CommitMsg
	}

	return &db.ConvoMessageDescription{
		PlanId:    planId,
		CommitMsg: commitMsg,
	}, nil
}

type GenCommitMsgForPendingResultsParams struct {
	Auth      *types.ServerAuth
	Plan      *db.Plan
	Settings  *shared.PlanSettings
	Current   *shared.CurrentPlanState
	SessionId string
	Ctx       context.Context
	Clients   map[string]model.ClientInfo
	AuthVars  map[string]string
}

func GenCommitMsgForPendingResults(params GenCommitMsgForPendingResultsParams) (string, error) {
	auth := params.Auth
	plan := params.Plan
	settings := params.Settings
	current := params.Current
	sessionId := params.SessionId
	ctx := params.Ctx
	clients := params.Clients
	authVars := params.AuthVars

	config := settings.GetModelPack().CommitMsg

	s := ""

	num := 0
	for _, desc := range current.ConvoMessageDescriptions {
		if desc.WroteFiles && desc.DidBuild && len(desc.BuildPathsInvalidated) == 0 && desc.AppliedAt == nil {
			s += desc.CommitMsg + "\n"
			num++
		}
	}

	if num <= 1 {
		return s, nil
	}

	prompt := "Pending changes:\n\n" + s

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompts.SysPendingResults,
				},
			},
		},
		{
			Role: openai.ChatMessageRoleUser,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		},
	}

	modelRes, err := model.ModelRequest(ctx, model.ModelRequestParams{
		Clients:     clients,
		AuthVars:    authVars,
		Auth:        auth,
		Plan:        plan,
		ModelConfig: &config,
		Purpose:     "Commit message",
		Messages:    messages,
		SessionId:   sessionId,
		Settings:    settings,
	})

	if err != nil {
		fmt.Println("Generate commit message error:", err)

		return "", err
	}

	content := modelRes.Content

	if content == "" {
		return "", fmt.Errorf("no response from model")
	}

	return content, nil
}


================================================
FILE: app/server/model/plan/exec_status.go
================================================
package plan

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/model"
	"plandex-server/model/prompts"
	"plandex-server/notify"
	"plandex-server/types"
	"plandex-server/utils"
	"strings"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

// controls the number steps to spent trying to finish a single subtask
// if a subtask is not finished in this number of steps, we'll give up and mark it done
// necessary to prevent infinite loops
const MaxPreviousMessages = 4

type execStatusShouldContinueResult struct {
	subtaskFinished bool
}

func (state *activeTellStreamState) execStatusShouldContinue(currentMessage string, sessionId string, ctx context.Context) (execStatusShouldContinueResult, *shared.ApiError) {
	auth := state.auth
	plan := state.plan
	settings := state.settings
	clients := state.clients
	authVars := state.authVars
	config := settings.GetModelPack().ExecStatus
	orgUserConfig := state.orgUserConfig

	baseModelConfig := config.GetBaseModelConfig(authVars, settings, orgUserConfig)
	currentSubtask := state.currentSubtask

	if currentSubtask == nil {
		log.Printf("[ExecStatus] No current subtask")
		return execStatusShouldContinueResult{
			subtaskFinished: true,
		}, nil
	}

	// Check subtask completion
	completionMarker := fmt.Sprintf("**%s** has been completed", currentSubtask.Title)
	log.Printf("[ExecStatus] Checking for subtask completion marker: %q", completionMarker)
	log.Printf("[ExecStatus] Current subtask: %q", currentSubtask.Title)

	if strings.Contains(currentMessage, completionMarker) {
		log.Printf("[ExecStatus] ✓ Subtask completion marker found")
		return execStatusShouldContinueResult{
			subtaskFinished: true,
		}, nil

		// NOTE: tried using an LLM to verify "suspicious" subtask completions, but in practice led to too many extra LLM calls and disagreement cycles between agent roles (it's finished. no it's note! etc.)
		// now just going back to trusting the completion marker... basically it's better to err on the side of marking tasks done.

		// var potentialProblem bool

		// if len(state.chunkProcessor.replyOperations) == 0 {
		// 	log.Printf("[ExecStatus] ✗ Subtask completion marker found, but there are no operations to execute")
		// 	potentialProblem = true
		// } else {
		// wroteToPaths := map[string]bool{}
		// for _, op := range state.chunkProcessor.replyOperations {
		// 	if op.Type == shared.OperationTypeFile {
		// 		wroteToPaths[op.Path] = true
		// 	}
		// }

		// for _, path := range currentSubtask.UsesFiles {
		// 	if !wroteToPaths[path] {
		// 		log.Printf("[ExecStatus] ✗ Subtask completion marker found, but the operations did not write to the file %q from the 'Uses' list", path)
		// 		potentialProblem = true
		// 		break
		// 	}
		// }
		// }

		// if !potentialProblem {
		// 	log.Printf("[ExecStatus] ✓ Subtask completion marker found and no potential problem - will mark as completed")

		// 	return execStatusShouldContinueResult{
		// 		subtaskFinished: true,
		// 	}, nil
		// } else if currentSubtask.NumTries >= 1 {
		// 	log.Printf("[ExecStatus] ✓ Subtask completion marker found, but the operations are questionable -- marking it done anyway since it's the second try and we can't risk an infinite loop")

		// 	return execStatusShouldContinueResult{
		// 		subtaskFinished: true,
		// 	}, nil
		// } else {
		// 	log.Printf("[ExecStatus] ✗ Subtask completion marker found, but the operations are questionable -- will verify with LLM call")
		// }
	} else {
		log.Printf("[ExecStatus] ✗ No subtask completion marker found in message")
	}

	log.Println("[ExecStatus] Current subtasks state:")
	for i, task := range state.subtasks {
		log.Printf("[ExecStatus] Task %d: %q (finished=%v)", i+1, task.Title, task.IsFinished)
	}

	log.Println("Checking if plan should continue based on exec status")

	fullSubtask := currentSubtask.Title
	fullSubtask += "\n\n" + currentSubtask.Description

	previousMessages := []string{}
	for _, msg := range state.convo {
		if msg.Subtask != nil && msg.Subtask.Title == currentSubtask.Title {
			previousMessages = append(previousMessages, msg.Message)
		}
	}

	if len(previousMessages) >= MaxPreviousMessages {
		log.Printf("[ExecStatus] ✗ Max previous messages reached - will mark as completed and move on to next subtask")
		return execStatusShouldContinueResult{
			subtaskFinished: true,
		}, nil
	}

	prompt := prompts.GetExecStatusFinishedSubtask(prompts.GetExecStatusFinishedSubtaskParams{
		UserPrompt:            state.userPrompt,
		CurrentSubtask:        fullSubtask,
		CurrentMessage:        currentMessage,
		PreviousMessages:      previousMessages,
		PreferredOutputFormat: baseModelConfig.PreferredOutputFormat,
	})

	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		},
	}

	modelRes, err := model.ModelRequest(ctx, model.ModelRequestParams{
		Clients:        clients,
		Auth:           auth,
		AuthVars:       authVars,
		Plan:           plan,
		ModelConfig:    &config,
		Purpose:        "Task completion check",
		Messages:       messages,
		ModelStreamId:  state.modelStreamId,
		ConvoMessageId: state.replyId,
		SessionId:      sessionId,
		Settings:       settings,
		OrgUserConfig:  orgUserConfig,
	})

	if err != nil {
		log.Printf("[ExecStatus] Error in model call: %v", err)
		return execStatusShouldContinueResult{}, nil
	}

	content := modelRes.Content

	var reasoning string
	var subtaskFinished bool

	if baseModelConfig.PreferredOutputFormat == shared.ModelOutputFormatXml {
		reasoning = utils.GetXMLContent(content, "reasoning")
		subtaskFinishedStr := utils.GetXMLContent(content, "subtaskFinished")
		subtaskFinished = subtaskFinishedStr == "true"

		if reasoning == "" || subtaskFinishedStr == "" {
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("execStatusShouldContinue: missing required XML tags in response"))

			return execStatusShouldContinueResult{}, &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Missing required XML tags in response",
			}
		}
	} else {

		if content == "" {
			log.Printf("[ExecStatus] No function response found in model output")
			return execStatusShouldContinueResult{}, nil
		}

		var res types.ExecStatusResponse
		if err := json.Unmarshal([]byte(content), &res); err != nil {
			log.Printf("[ExecStatus] Failed to parse response: %v", err)
			return execStatusShouldContinueResult{}, nil
		}

		reasoning = res.Reasoning
		subtaskFinished = res.SubtaskFinished
	}

	log.Printf("[ExecStatus] Decision: subtaskFinished=%v, reasoning=%v",
		subtaskFinished, reasoning)

	return execStatusShouldContinueResult{
		subtaskFinished: subtaskFinished,
	}, nil
}


================================================
FILE: app/server/model/plan/shutdown.go
================================================
package plan


================================================
FILE: app/server/model/plan/state.go
================================================
package plan

import (
	"context"
	"fmt"
	"log"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/shutdown"
	"plandex-server/types"
	"strings"
	"time"

	shared "plandex-shared"
)

var (
	activePlans types.SafeMap[*types.ActivePlan] = *types.NewSafeMap[*types.ActivePlan]()
)

func GetActivePlan(planId, branch string) *types.ActivePlan {
	return activePlans.Get(strings.Join([]string{planId, branch}, "|"))
}

func CreateActivePlan(orgId, userId, planId, branch, prompt string, buildOnly, autoContext bool, sessionId string) *types.ActivePlan {
	activePlan := types.NewActivePlan(orgId, userId, planId, branch, prompt, buildOnly, autoContext, sessionId)
	key := strings.Join([]string{planId, branch}, "|")

	activePlans.Set(key, activePlan)

	go func() {
		for {
			select {
			case <-activePlan.Ctx.Done():
				log.Printf("case <-activePlan.Ctx.Done(): %s\n", planId)

				err := db.SetPlanStatus(planId, branch, shared.PlanStatusStopped, "")
				if err != nil {
					log.Printf("Error setting plan %s status to stopped: %v\n", planId, err)
				}

				DeleteActivePlan(orgId, userId, planId, branch)

				return
			case apiErr := <-activePlan.StreamDoneCh:
				log.Printf("case apiErr := <-activePlan.StreamDoneCh: %s\n", planId)
				log.Printf("apiErr: %v\n", apiErr)

				if apiErr == nil {
					log.Printf("Plan %s stream completed successfully", planId)

					err := db.SetPlanStatus(planId, branch, shared.PlanStatusFinished, "")
					if err != nil {
						log.Printf("Error setting plan %s status to ready: %v\n", planId, err)
					}

					// cancel *after* the DeleteActivePlan call
					// allows queued operations to complete
					DeleteActivePlan(orgId, userId, planId, branch)
					activePlan.CancelFn()
					return
				} else {
					log.Printf("Error streaming plan %s: %v\n", planId, apiErr)

					go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error streaming plan %s: %v", planId, apiErr))

					err := db.SetPlanStatus(planId, branch, shared.PlanStatusError, apiErr.Msg)
					if err != nil {
						log.Printf("Error setting plan %s status to error: %v\n", planId, err)
					}

					log.Println("Sending error message to client")
					activePlan.Stream(shared.StreamMessage{
						Type:  shared.StreamMessageError,
						Error: apiErr,
					})
					activePlan.FlushStreamBuffer()

					log.Println("Stopping any active summary stream")
					activePlan.SummaryCancelFn()

					log.Println("Waiting 100ms after streaming error before canceling active plan")
					time.Sleep(100 * time.Millisecond)

					// cancel *before* the DeleteActivePlan call below
					// short circuits any active operations
					log.Println("Cancelling active plan")
					activePlan.CancelFn()
					DeleteActivePlan(orgId, userId, planId, branch)
					return
				}
			}
		}
	}()

	return activePlan
}

func DeleteActivePlan(orgId, userId, planId, branch string) {
	log.Printf("Deleting active plan %s - %s - %s\n", planId, branch, orgId)

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		log.Printf("DeleteActivePlan - No active plan found for plan ID %s on branch %s\n", planId, branch)
		return
	}

	ctx, cancelFn := context.WithTimeout(shutdown.ShutdownCtx, 10*time.Second)
	defer cancelFn()

	log.Printf("Clearing uncommitted changes for plan %s - %s - %s\n", planId, branch, orgId)

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    orgId,
		UserId:   userId,
		PlanId:   planId,
		Branch:   branch,
		Scope:    db.LockScopeWrite,
		Ctx:      ctx,
		CancelFn: cancelFn,
		Reason:   "delete active plan",
	}, func(repo *db.GitRepo) error {
		log.Printf("Starting clear uncommitted changes for plan %s - %s - %s\n", planId, branch, orgId)
		err := repo.GitClearUncommittedChanges(branch)
		log.Printf("Finished clear uncommitted changes for plan %s - %s - %s\n", planId, branch, orgId)
		log.Printf("Error: %v\n", err)
		return err
	})

	if err != nil {
		log.Printf("Error clearing uncommitted changes for plan %s: %v\n", planId, err)
	}

	activePlans.Delete(strings.Join([]string{planId, branch}, "|"))

	log.Printf("Deleted active plan %s - %s - %s\n", planId, branch, orgId)
}

func UpdateActivePlan(planId, branch string, fn func(*types.ActivePlan)) {
	activePlans.Update(strings.Join([]string{planId, branch}, "|"), fn)
}

func SubscribePlan(ctx context.Context, planId, branch string) (string, chan string) {
	log.Printf("Subscribing to plan %s\n", planId)
	var id string
	var ch chan string

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		log.Printf("SubscribePlan - No active plan found for plan ID %s on branch %s\n", planId, branch)
		return "", nil
	}

	UpdateActivePlan(planId, branch, func(activePlan *types.ActivePlan) {
		id, ch = activePlan.Subscribe(ctx)
	})
	return id, ch
}

func UnsubscribePlan(planId, branch, subscriptionId string) {
	log.Printf("UnsubscribePlan %s - %s - %s\n", planId, branch, subscriptionId)

	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("No active plan found for plan ID %s on branch %s\n", planId, branch)
		return
	}

	UpdateActivePlan(planId, branch, func(activePlan *types.ActivePlan) {
		activePlan.Unsubscribe(subscriptionId)
		log.Printf("Unsubscribed from plan %s - %s - %s\n", planId, branch, subscriptionId)
	})
}

func NumActivePlans() int {
	return activePlans.Len()
}


================================================
FILE: app/server/model/plan/stop.go
================================================
package plan

import (
	"fmt"
	"plandex-server/db"

	"github.com/sashabaranov/go-openai"
)

func Stop(planId, branch, currentUserId, currentOrgId string) error {
	active := GetActivePlan(planId, branch)

	if active == nil {
		return fmt.Errorf("no active plan with id %s", planId)
	}

	active.SummaryCancelFn()
	active.CancelFn()

	return nil
}

func StorePartialReply(repo *db.GitRepo, planId, branch, currentUserId, currentOrgId string) error {
	active := GetActivePlan(planId, branch)

	if active == nil {
		return fmt.Errorf("no active plan with id %s", planId)
	}

	if !active.BuildOnly && !active.RepliesFinished {
		num := active.MessageNum + 1

		userMsg := db.ConvoMessage{
			OrgId:   currentOrgId,
			PlanId:  planId,
			UserId:  currentUserId,
			Role:    openai.ChatMessageRoleAssistant,
			Tokens:  active.NumTokens,
			Num:     num,
			Stopped: true,
			Message: active.CurrentReplyContent,
		}

		_, err := db.StoreConvoMessage(repo, &userMsg, currentUserId, branch, true)

		if err != nil {
			return fmt.Errorf("error storing convo message: %v", err)
		}
	}

	return nil
}


================================================
FILE: app/server/model/plan/tell_build_pending.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/notify"
	"runtime/debug"

	shared "plandex-shared"
)

func (state *activeTellStreamState) queuePendingBuilds() {
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	auth := state.auth
	clients := state.clients
	authVars := state.authVars
	currentOrgId := state.currentOrgId
	currentUserId := state.currentUserId
	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("execTellPlan: Active plan not found for plan ID %s on branch %s\n", planId, branch)
		return
	}

	defer func() {
		if r := recover(); r != nil {
			log.Printf("panic in queuePendingBuilds: %v\n%s", r, debug.Stack())
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error getting pending builds by path: %v", r))
			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    fmt.Sprintf("Error getting pending builds by path: %v\n%s", r, debug.Stack()),
			}
		}
	}()

	pendingBuildsByPath, err := active.PendingBuildsByPath(auth.OrgId, auth.User.Id, state.convo)

	if err != nil {
		log.Printf("Error getting pending builds by path: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error getting pending builds by path: %v", err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error getting pending builds by path: %v", err),
		}
		return
	}

	if len(pendingBuildsByPath) == 0 {
		log.Println("Tell plan: no pending builds")
		return
	}

	log.Printf("Tell plan: found %d pending builds\n", len(pendingBuildsByPath))
	// spew.Dump(pendingBuildsByPath)

	buildState := &activeBuildStreamState{
		modelStreamId: active.ModelStreamId,
		clients:       clients,
		authVars:      authVars,
		auth:          auth,
		currentOrgId:  currentOrgId,
		currentUserId: currentUserId,
		plan:          plan,
		branch:        branch,
		settings:      state.settings,
		modelContext:  state.modelContext,
		orgUserConfig: state.orgUserConfig,
	}

	for _, pendingBuilds := range pendingBuildsByPath {
		buildState.queueBuilds(pendingBuilds)
	}
}


================================================
FILE: app/server/model/plan/tell_context.go
================================================
package plan

import (
	"fmt"
	"log"
	"plandex-server/types"
	"regexp"
	"sort"
	"strings"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

type formatModelContextParams struct {
	includeMaps          bool
	smartContextEnabled  bool
	includeApplyScript   bool
	baseOnly             bool
	cacheControl         bool
	activeOnly           bool
	autoOnly             bool
	activatePaths        map[string]bool
	activatePathsOrdered []string
	maxTokens            int
}

func (state *activeTellStreamState) formatModelContext(params formatModelContextParams) []*types.ExtendedChatMessagePart {
	log.Println("Tell plan - formatModelContext")

	includeMaps := params.includeMaps
	smartContextEnabled := params.smartContextEnabled
	includeApplyScript := params.includeApplyScript
	currentStage := state.currentStage

	basicOnly := params.baseOnly
	activeOnly := params.activeOnly
	autoOnly := params.autoOnly
	activatePaths := params.activatePaths
	activatePathsOrdered := params.activatePathsOrdered
	if activatePaths == nil {
		activatePaths = map[string]bool{}
	}

	maxTokens := params.maxTokens

	// log all the flags
	log.Printf("Tell plan - formatModelContext - basicOnly: %t, activeOnly: %t, autoOnly: %t, smartContextEnabled: %t, execEnabled: %t, includeMaps: %t, activatePaths: %v, activatePathsOrdered: %v, maxTokens: %d\n",
		basicOnly, activeOnly, autoOnly, smartContextEnabled, includeApplyScript, includeMaps, activatePaths, activatePathsOrdered, params.maxTokens)

	var contextBodies []string = []string{
		"### LATEST PLAN CONTEXT ###",
	}
	addedFilesSet := map[string]bool{}

	uses := map[string]bool{}

	// log.Println("Tell plan - formatModelContext - state.currentSubtask:\n", spew.Sdump(state.currentSubtask))
	// if state.currentSubtask != nil {
	// 	log.Println("Tell plan - formatModelContext - state.currentSubtask.UsesFiles:\n", spew.Sdump(state.currentSubtask.UsesFiles))
	// }
	// log.Println("Tell plan - formatModelContext - currentStage.TellStage:\n", currentStage.TellStage)
	// log.Println("Tell plan - formatModelContext - smartContextEnabled:\n", smartContextEnabled)

	if currentStage.TellStage == shared.TellStageImplementation && smartContextEnabled && state.currentSubtask != nil {
		log.Println("Tell plan - formatModelContext - implementation stage - smart context enabled for current subtask")
		for _, path := range state.currentSubtask.UsesFiles {
			uses[path] = true
		}
		if verboseLogging {
			log.Printf("Tell plan - formatModelContext - uses: %v\n", uses)
		}
	}

	// log.Println("Tell plan - formatModelContext - state.modelContext:\n", spew.Sdump(state.modelContext))

	totalTokens := 0

	type toLoad struct {
		FilePath    string
		Name        string
		Url         string
		NumTokens   int
		Body        string
		ContextType shared.ContextType
		ImageDetail openai.ImageURLDetail
		IsPending   bool
	}
	var toLoadAll []toLoad

	for _, part := range state.modelContext {
		if verboseLogging {
			log.Printf("Tell plan - formatModelContext - part: %s - %s - %s - %d tokens\n", part.ContextType, part.Name, part.FilePath, part.NumTokens)
		}
		if !(part.ContextType == shared.ContextMapType && includeMaps) {
			if basicOnly && part.AutoLoaded {
				if verboseLogging {
					log.Println("Tell plan - formatModelContext - skipping auto loaded part -- basicOnly && part.AutoLoaded")
				}
				continue
			}

			if autoOnly && !part.AutoLoaded {
				if verboseLogging {
					log.Println("Tell plan - formatModelContext - skipping auto loaded part -- autoOnly && !part.AutoLoaded")
				}
				continue
			}
		}

		if currentStage.TellStage == shared.TellStageImplementation && smartContextEnabled && state.currentSubtask != nil && part.ContextType == shared.ContextFileType && !uses[part.FilePath] {
			if verboseLogging {
				log.Println("Tell plan - formatModelContext - skipping part -- currentStage.TellStage == shared.TellStageImplementation && smartContextEnabled && state.currentSubtask != nil && part.ContextType == shared.ContextFileType && !uses[part.FilePath]")
			}
			continue
		}

		if activeOnly && !activatePaths[part.FilePath] {
			if verboseLogging {
				log.Println("Tell plan - formatModelContext - skipping part -- activeOnly && !activatePaths[part.FilePath]")
			}
			continue
		}

		if part.ContextType == shared.ContextMapType && !includeMaps {
			if verboseLogging {
				log.Println("Tell plan - formatModelContext - skipping part -- part.ContextType == shared.ContextMapType && !includeMaps")
			}
			continue
		}

		toLoadAll = append(toLoadAll, toLoad{
			FilePath:    part.FilePath,
			NumTokens:   part.NumTokens,
			Body:        part.Body,
			ContextType: part.ContextType,
			Name:        part.Name,
			Url:         part.Url,
			ImageDetail: part.ImageDetail,
		})

		if part.ContextType == shared.ContextFileType {
			addedFilesSet[part.FilePath] = true
		}
	}

	// Add any current pendingFiles in plan that weren't added to the context
	var currentPlanFiles *shared.CurrentPlanFiles
	var pendingFiles map[string]string = map[string]string{}
	if state.currentPlanState != nil && state.currentPlanState.CurrentPlanFiles != nil && state.currentPlanState.CurrentPlanFiles.Files != nil {
		currentPlanFiles = state.currentPlanState.CurrentPlanFiles
		pendingFiles = state.currentPlanState.CurrentPlanFiles.Files
	}

	for filePath, body := range pendingFiles {
		if !addedFilesSet[filePath] {

			if currentStage.TellStage == shared.TellStageImplementation && smartContextEnabled && !uses[filePath] {
				continue
			}

			if filePath == "_apply.sh" {
				continue
			}

			if activeOnly && !activatePaths[filePath] {
				continue
			}

			numTokens := shared.GetNumTokensEstimate(body)

			toLoadAll = append(toLoadAll, toLoad{
				FilePath:    filePath,
				NumTokens:   numTokens,
				Body:        body,
				ContextType: shared.ContextFileType,
				Name:        filePath,
				IsPending:   true,
			})

			if verboseLogging {
				log.Printf("Tell plan - formatModelContext - added current plan file - %s\n", filePath)
			}
		}
	}

	if len(activatePathsOrdered) > 0 {
		indexByPath := map[string]int{}
		for i, path := range activatePathsOrdered {
			indexByPath[path] = i
		}

		sort.Slice(toLoadAll, func(i, j int) bool {
			iIndex, ok1 := indexByPath[toLoadAll[i].FilePath]
			jIndex, ok2 := indexByPath[toLoadAll[j].FilePath]

			// If neither has an index, sort by Name so we are using a stable order for caching
			if !ok1 && !ok2 {
				return toLoadAll[i].Name < toLoadAll[j].Name
			}

			// If only i doesn't have an index, it goes after j
			if !ok1 {
				return false
			}

			// If only j doesn't have an index, it goes after i
			if !ok2 {
				return true
			}

			// Both have indices, compare them
			return iIndex < jIndex
		})
	}

	for _, part := range toLoadAll {
		totalTokens += part.NumTokens

		if maxTokens > 0 && totalTokens > maxTokens {
			if verboseLogging {
				log.Printf("Tell plan - formatModelContext - total tokens: %d\n", totalTokens)
			}
			break
		}

		var message string
		var fmtStr string
		var args []any

		if part.ContextType == shared.ContextDirectoryTreeType {
			fmtStr = "\n\n- %s | directory tree:\n\n```\n%s\n```"
			args = append(args, part.FilePath, part.Body)
		} else if part.ContextType == shared.ContextFileType {
			// if we're in the context phase and the file is pending, just include that the file is pending, not the full content
			// there is generally enough related context from the conversation and summary to decide on whether to load the file or not
			// without this, the context phase can get overloaded with pending file content
			if currentStage.TellStage == shared.TellStagePlanning &&
				currentStage.PlanningPhase == shared.PlanningPhaseContext &&
				part.IsPending {
				fmtStr = "\n\n- File `%s` has pending changes (%d 🪙)"
				args = append(args, part.FilePath, part.NumTokens)
			} else {

				fmtStr = "\n\n- %s:\n\n```\n%s\n```"

				// use pending file value if available
				var body string
				var found bool
				res, ok := pendingFiles[part.FilePath]
				if ok {
					body = res
					found = true
				}
				if !found {
					body = part.Body
				}

				args = append(args, part.FilePath, body)
			}
		} else if part.ContextType == shared.ContextMapType {
			fmtStr = "\n\n- %s | map:\n\n```\n%s\n```"
			args = append(args, part.FilePath, part.Body)
		} else if part.Url != "" {
			fmtStr = "\n\n- %s:\n\n```\n%s\n```"
			args = append(args, part.Url, part.Body)
		} else if part.ContextType != shared.ContextImageType {
			fmtStr = "\n\n- content%s:\n\n```\n%s\n```"
			args = append(args, part.Name, part.Body)
		}

		if part.ContextType != shared.ContextImageType {
			message = fmt.Sprintf(fmtStr, args...)
			contextBodies = append(contextBodies, message)
		}

		if verboseLogging {
			log.Printf("Tell plan - formatModelContext - added context: %s - %s - %s - %d tokens\n", part.ContextType, part.Name, part.FilePath, part.NumTokens)
		}
	}

	if currentPlanFiles != nil && len(currentPlanFiles.Removed) > 0 {
		contextBodies = append(contextBodies, "*Removed files:*\n")
		for path := range currentPlanFiles.Removed {
			contextBodies = append(contextBodies, fmt.Sprintf("- %s", path))
		}
		contextBodies = append(contextBodies, "These files have been *removed* and are no longer in the plan. If you want to re-add them to the plan, you must explicitly create them again.")

		log.Println("Tell plan - formatModelContext - added removed files")
		log.Println(contextBodies)
	}

	var execScriptLines []string

	if includeApplyScript &&
		// don't show _apply.sh history and content if smart context is enabled and the current subtask doesn't use it
		!(currentStage.TellStage == shared.TellStageImplementation && smartContextEnabled && state.currentSubtask != nil && !uses["_apply.sh"]) {

		execHistory := state.currentPlanState.ExecHistory()

		execScriptLines = append(execScriptLines, execHistory)

		scriptContent, ok := pendingFiles["_apply.sh"]
		var isEmpty bool
		if !ok || scriptContent == "" {
			scriptContent = "[empty]"
			isEmpty = true
		}

		execScriptLines = append(execScriptLines, "*Current* state of _apply.sh script:")
		execScriptLines = append(execScriptLines, fmt.Sprintf("\n\n- _apply.sh:\n\n```\n%s\n```", scriptContent))

		if isEmpty && currentStage.TellStage == shared.TellStagePlanning && currentStage.PlanningPhase != shared.PlanningPhaseContext {
			execScriptLines = append(execScriptLines, "The _apply.sh script is *empty*. You ABSOLUTELY MUST include a '### Commands' section in your response prior to the '### Tasks' section that evaluates whether any commands should be written to _apply.sh during the plan. This is MANDATORY. Do NOT UNDER ANY CIRCUMSTANCES omit this section. If you determine that commands should be added or updated in _apply.sh, you MUST also create a subtask referencing _apply.sh in the '### Tasks' section.")

			if execHistory != "" {
				execScriptLines = append(execScriptLines, "Consider the history of previously executed _apply.sh scripts when determining which commands to include in the new _apply.sh file. Are there any commands that should be run again after code changes? If so, mention them in the '### Commands' section and then include a subtask to include them in the _apply.sh file in the '### Tasks' section.")
			}
		}
	}

	log.Println("Tell plan - formatModelContext - contextMessages:", len(contextBodies))

	textMsg := &types.ExtendedChatMessagePart{
		Type: openai.ChatMessagePartTypeText,
		Text: strings.Join(contextBodies, "\n"),
	}

	res := []*types.ExtendedChatMessagePart{textMsg}

	// now add any images that should be included
	// we'll check later for model image support once the final model config is set
	for _, load := range toLoadAll {
		if load.ContextType == shared.ContextImageType {
			res = append(res, &types.ExtendedChatMessagePart{
				Type: openai.ChatMessagePartTypeText,
				Text: fmt.Sprintf("Image: %s", load.Name),
			})
			res = append(res, &types.ExtendedChatMessagePart{
				Type:     openai.ChatMessagePartTypeImageURL,
				ImageURL: &openai.ChatMessageImageURL{URL: shared.GetImageDataURI(load.Body, load.FilePath), Detail: load.ImageDetail},
			})
		}
	}

	if params.cacheControl && len(res) > 0 {
		res[len(res)-1].CacheControl = &types.CacheControlSpec{
			Type: types.CacheControlTypeEphemeral,
		}
	}

	if len(execScriptLines) > 0 {
		res = append(res, &types.ExtendedChatMessagePart{
			Type: openai.ChatMessagePartTypeText,
			Text: strings.Join(execScriptLines, "\n"),
		})
	}

	res = append(res, &types.ExtendedChatMessagePart{
		Type: openai.ChatMessagePartTypeText,
		Text: "### END OF CONTEXT ###\n\n",
	})

	return res
}

var pathRegex = regexp.MustCompile("`(.+?)`")

type checkAutoLoadContextResult struct {
	autoLoadPaths        []string
	activatePaths        map[string]bool
	hasExplicitPaths     bool
	activatePathsOrdered []string
}

func (state *activeTellStreamState) checkAutoLoadContext() checkAutoLoadContextResult {
	req := state.req
	activePlan := state.activePlan
	contextsByPath := activePlan.ContextsByPath
	currentStage := state.currentStage

	// can only auto load context in planning stage
	// context phase is primary loading phase
	// planning phase can still load additional context files as a backup
	if currentStage.TellStage != shared.TellStagePlanning {
		return checkAutoLoadContextResult{}
	}

	// for chat responses, only auto load context if we're in the context phase
	if req.IsChatOnly && currentStage.PlanningPhase != shared.PlanningPhaseContext {
		return checkAutoLoadContextResult{}
	}

	log.Printf("%d existing contexts by path\n", len(contextsByPath))

	// pick out all potential file paths within backticks
	matches := pathRegex.FindAllStringSubmatch(activePlan.CurrentReplyContent, -1)

	toAutoLoad := map[string]bool{}
	toActivate := map[string]bool{}
	toActivateOrdered := []string{}
	allSet := map[string]bool{}
	allFiles := []string{}

	for _, match := range matches {
		trimmed := strings.TrimSpace(match[1])
		if trimmed == "" {
			continue
		}

		if req.ProjectPaths[trimmed] {
			if !allSet[trimmed] {
				allFiles = append(allFiles, trimmed)
				allSet[trimmed] = true

				toActivate[trimmed] = true
				toActivateOrdered = append(toActivateOrdered, trimmed)
				if contextsByPath[trimmed] == nil {
					toAutoLoad[trimmed] = true
				}

			}
		}
	}

	toAutoLoadPaths := []string{}
	for path := range toAutoLoad {
		toAutoLoadPaths = append(toAutoLoadPaths, path)
	}

	hasExplicitPaths := strings.Contains(activePlan.CurrentReplyContent, "### Files")

	log.Printf("Tell plan - checkAutoLoadContext - toAutoLoad: %v\n", toAutoLoadPaths)
	log.Printf("Tell plan - checkAutoLoadContext - toActivate: %v\n", toActivateOrdered)

	return checkAutoLoadContextResult{
		autoLoadPaths:        toAutoLoadPaths,
		activatePaths:        toActivate,
		activatePathsOrdered: toActivateOrdered,
		hasExplicitPaths:     hasExplicitPaths,
	}
}


================================================
FILE: app/server/model/plan/tell_exec.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"runtime/debug"
	"time"

	"plandex-server/db"
	"plandex-server/hooks"
	"plandex-server/model"
	"plandex-server/notify"
	"plandex-server/types"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
	"github.com/google/uuid"
	"github.com/sashabaranov/go-openai"
)

type TellParams struct {
	Clients  map[string]model.ClientInfo
	AuthVars map[string]string
	Plan     *db.Plan
	Branch   string
	Auth     *types.ServerAuth
	Req      *shared.TellPlanRequest
}

func Tell(params TellParams) error {
	clients := params.Clients
	plan := params.Plan
	branch := params.Branch
	auth := params.Auth
	req := params.Req
	authVars := params.AuthVars

	log.Printf("Tell: Called with plan ID %s on branch %s\n", plan.Id, branch)

	_, err := activatePlan(
		clients,
		plan,
		branch,
		auth,
		req.Prompt,
		false,
		req.AutoContext,
		req.SessionId,
	)

	if err != nil {
		log.Printf("Error activating plan: %v\n", err)
		return err
	}

	go execTellPlan(execTellPlanParams{
		clients:            clients,
		plan:               plan,
		branch:             branch,
		auth:               auth,
		req:                req,
		iteration:          0,
		shouldBuildPending: !req.IsChatOnly && req.BuildMode == shared.BuildModeAuto,
		authVars:           authVars,
	})

	log.Printf("Tell: Tell operation completed successfully for plan ID %s on branch %s\n", plan.Id, branch)
	return nil
}

type execTellPlanParams struct {
	clients                    map[string]model.ClientInfo
	authVars                   map[string]string
	plan                       *db.Plan
	branch                     string
	auth                       *types.ServerAuth
	req                        *shared.TellPlanRequest
	iteration                  int
	missingFileResponse        shared.RespondMissingFileChoice
	shouldBuildPending         bool
	unfinishedSubtaskReasoning string
}

func execTellPlan(params execTellPlanParams) {
	clients := params.clients
	authVars := params.authVars
	plan := params.plan
	branch := params.branch
	auth := params.auth
	req := params.req
	iteration := params.iteration
	missingFileResponse := params.missingFileResponse
	shouldBuildPending := params.shouldBuildPending
	unfinishedSubtaskReasoning := params.unfinishedSubtaskReasoning

	log.Printf("[TellExec] Starting iteration %d for plan %s on branch %s", iteration, plan.Id, branch)

	currentUserId := auth.User.Id
	currentOrgId := auth.OrgId

	active := GetActivePlan(plan.Id, branch)

	if active == nil {
		log.Printf("execTellPlan: Active plan not found for plan ID %s on branch %s\n", plan.Id, branch)
		return
	}

	defer func() {
		if r := recover(); r != nil {
			log.Printf("execTellPlan: Panic: %v\n%s\n", r, string(debug.Stack()))

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("execTellPlan: Panic: %v\n%s", r, string(debug.Stack())))

			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    fmt.Sprintf("Panic in execTellPlan: %v\n%s", r, string(debug.Stack())),
			}
		}
	}()

	if missingFileResponse == "" {
		log.Println("Executing WillExecPlanHook")
		_, apiErr := hooks.ExecHook(hooks.WillExecPlan, hooks.HookParams{
			Auth: auth,
			Plan: plan,
		})

		if apiErr != nil {
			time.Sleep(100 * time.Millisecond)
			active.StreamDoneCh <- apiErr
			return
		}
	}

	planId := plan.Id
	log.Println("execTellPlan - Setting plan status to replying")
	err := db.SetPlanStatus(planId, branch, shared.PlanStatusReplying, "")
	if err != nil {
		log.Printf("Error setting plan %s status to replying: %v\n", planId, err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error setting plan %s status to replying: %v", planId, err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error setting plan status to replying: %v", err),
		}

		log.Printf("execTellPlan: execTellPlan operation completed for plan ID %s on branch %s, iteration %d\n", plan.Id, branch, iteration)
		return
	}
	log.Println("execTellPlan - Plan status set to replying")

	state := &activeTellStreamState{
		modelStreamId:       active.ModelStreamId,
		clients:             clients,
		authVars:            authVars,
		req:                 req,
		auth:                auth,
		currentOrgId:        currentOrgId,
		currentUserId:       currentUserId,
		plan:                plan,
		branch:              branch,
		iteration:           iteration,
		missingFileResponse: missingFileResponse,
	}

	log.Println("execTellPlan - Loading tell plan")
	err = state.loadTellPlan()
	if err != nil {
		return
	}
	log.Println("execTellPlan - Tell plan loaded")

	activatePaths, activatePathsOrdered := state.resolveCurrentStage()

	var tentativeModelConfig shared.ModelRoleConfig
	var tentativeMaxTokens int
	if state.currentStage.TellStage == shared.TellStagePlanning {
		if state.currentStage.PlanningPhase == shared.PlanningPhaseContext {
			log.Println("Tell plan - isContextStage - setting modelConfig to context loader")
			tentativeModelConfig = state.settings.GetModelPack().GetArchitect()
			tentativeMaxTokens = state.settings.GetArchitectEffectiveMaxTokens()
		} else {
			plannerConfig := state.settings.GetModelPack().Planner
			tentativeModelConfig = plannerConfig.ModelRoleConfig
			tentativeMaxTokens = state.settings.GetPlannerEffectiveMaxTokens()
		}
	} else if state.currentStage.TellStage == shared.TellStageImplementation {
		tentativeModelConfig = state.settings.GetModelPack().GetCoder()
		tentativeMaxTokens = state.settings.GetCoderEffectiveMaxTokens()
	} else {
		log.Printf("Tell plan - execTellPlan - unknown tell stage: %s\n", state.currentStage.TellStage)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("execTellPlan: unknown tell stage: %s", state.currentStage.TellStage))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Unknown tell stage",
		}
		return
	}

	ok, tokensWithoutContext := state.dryRunCalculateTokensWithoutContext(tentativeMaxTokens, unfinishedSubtaskReasoning)
	if !ok {
		return
	}

	var planStageSharedMsgs []*types.ExtendedChatMessagePart
	var planningPhaseOnlyMsgs []*types.ExtendedChatMessagePart
	var implementationMsgs []*types.ExtendedChatMessagePart

	if state.currentStage.TellStage == shared.TellStageImplementation {
		implementationMsgs = state.formatModelContext(formatModelContextParams{
			includeMaps:         false,
			smartContextEnabled: req.SmartContext,
			includeApplyScript:  req.ExecEnabled,
		})
	} else if state.currentStage.TellStage == shared.TellStagePlanning {
		// add the shared context between planning and context phases first so it can be cached
		// this is just for the map and any manually loaded contexts - auto contexts will be added later
		planStageSharedMsgs = state.formatModelContext(formatModelContextParams{
			includeMaps:         true,
			smartContextEnabled: req.SmartContext,
			includeApplyScript:  req.ExecEnabled,
			baseOnly:            true,
			cacheControl:        true,
		})

		if state.currentStage.PlanningPhase == shared.PlanningPhaseTasks {
			if req.AutoContext {
				msg := types.ExtendedChatMessage{
					Role:    openai.ChatMessageRoleSystem,
					Content: []types.ExtendedChatMessagePart{},
				}
				for _, part := range planStageSharedMsgs {
					msg.Content = append(msg.Content, *part)
				}
				sharedMsgsTokens := model.GetMessagesTokenEstimate(msg)

				tokensRemaining := tentativeMaxTokens - (sharedMsgsTokens + tokensWithoutContext)

				if tokensRemaining < 0 {
					log.Println("tokensRemaining is negative")
					go notify.NotifyErr(notify.SeverityError, fmt.Errorf("tokensRemaining is negative"))

					active.StreamDoneCh <- &shared.ApiError{
						Type:   shared.ApiErrorTypeOther,
						Status: http.StatusInternalServerError,
						Msg:    "Max tokens exceeded before adding context",
					}
					return
				}

				planningPhaseOnlyMsgs = state.formatModelContext(formatModelContextParams{
					includeMaps:          false,
					smartContextEnabled:  req.SmartContext,
					includeApplyScript:   false, // already included in planStageSharedMsgs
					activeOnly:           true,
					activatePaths:        activatePaths,
					activatePathsOrdered: activatePathsOrdered,
					maxTokens:            int(float64(tokensRemaining) * 0.95), // leave a little extra room
				})
			} else {
				// if auto context is disabled, just dump in any remaining auto contexts, since all basic contexts have already been added in planStageSharedMsgs
				planningPhaseOnlyMsgs = state.formatModelContext(formatModelContextParams{
					includeMaps:         false,
					smartContextEnabled: req.SmartContext,
					includeApplyScript:  false, // already included in planStageSharedMsgs
					autoOnly:            true,
				})
			}
		}
	}

	getTellSysPromptParams := getTellSysPromptParams{
		planStageSharedMsgs:   planStageSharedMsgs,
		planningPhaseOnlyMsgs: planningPhaseOnlyMsgs,
		implementationMsgs:    implementationMsgs,
		contextTokenLimit:     tentativeMaxTokens,
	}

	// log.Println("getTellSysPromptParams:\n", spew.Sdump(getTellSysPromptParams))

	sysParts, err := state.getTellSysPrompt(getTellSysPromptParams)
	if err != nil {
		log.Printf("Error getting tell sys prompt: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error getting tell sys prompt: %v", err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error getting tell sys prompt: %v", err),
		}
		return
	}

	// log.Println("**sysPrompt:**\n", spew.Sdump(sysParts))

	state.messages = []types.ExtendedChatMessage{
		{
			Role:    openai.ChatMessageRoleSystem,
			Content: sysParts,
		},
	}

	promptMessage, ok := state.resolvePromptMessage(unfinishedSubtaskReasoning)
	if !ok {
		return
	}

	// log.Println("messages:\n\n", spew.Sdump(state.messages))

	// log.Println("promptMessage:", spew.Sdump(promptMessage))

	state.tokensBeforeConvo =
		model.GetMessagesTokenEstimate(state.messages...) +
			model.GetMessagesTokenEstimate(*promptMessage) +
			state.latestSummaryTokens +
			model.TokensPerRequest

	// print out breakdown of token usage
	log.Printf("Latest summary tokens: %d\n", state.latestSummaryTokens)
	log.Printf("Total tokens before convo: %d\n", state.tokensBeforeConvo)

	var effectiveMaxTokens int
	if state.currentStage.TellStage == shared.TellStagePlanning {
		if state.currentStage.PlanningPhase == shared.PlanningPhaseContext {
			effectiveMaxTokens = state.settings.GetArchitectEffectiveMaxTokens()
		} else {
			effectiveMaxTokens = state.settings.GetPlannerEffectiveMaxTokens()
		}
	} else if state.currentStage.TellStage == shared.TellStageImplementation {
		effectiveMaxTokens = state.settings.GetCoderEffectiveMaxTokens()
	}

	if state.tokensBeforeConvo > effectiveMaxTokens {
		// token limit already exceeded before adding conversation
		err := fmt.Errorf("token limit exceeded before adding conversation")
		log.Printf("Error: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("token limit exceeded before adding conversation"))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Token limit exceeded before adding conversation",
		}
		return
	}

	if !state.addConversationMessages() {
		return
	}

	// add the prompt message to the end of the messages slice
	if promptMessage != nil {
		state.messages = append(state.messages, *promptMessage)
	} else {
		log.Println("promptMessage is nil")
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("promptMessage is nil"))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Prompt message isn't set",
		}
		return
	}

	state.replyId = uuid.New().String()
	state.replyParser = types.NewReplyParser()

	if missingFileResponse != "" && !state.handleMissingFileResponse(unfinishedSubtaskReasoning) {
		return
	}

	// filter out any messages that are empty
	state.messages = model.FilterEmptyMessages(state.messages)

	log.Printf("\n\nMessages: %d\n", len(state.messages))
	// for _, message := range state.messages {
	// 	log.Printf("%s: %v\n", message.Role, message.Content)
	// }

	requestTokens := model.GetMessagesTokenEstimate(state.messages...) + model.TokensPerRequest
	state.totalRequestTokens = requestTokens

	modelConfig := tentativeModelConfig

	log.Println("Tell plan - setting modelConfig")
	log.Println("Tell plan - requestTokens:", requestTokens)
	log.Println("Tell plan - state.currentStage.TellStage:", state.currentStage.TellStage)
	log.Println("Tell plan - state.currentStage.PlanningPhase:", state.currentStage.PlanningPhase)

	if state.currentStage.TellStage == shared.TellStagePlanning {
		if state.currentStage.PlanningPhase == shared.PlanningPhaseContext {
			log.Println("Tell plan - isContextStage - setting modelConfig to context loader")
			modelConfig = state.settings.GetModelPack().GetArchitect().GetRoleForInputTokens(requestTokens, state.settings)
			log.Println("Tell plan - got modelConfig for context phase")
		} else if state.currentStage.PlanningPhase == shared.PlanningPhaseTasks {
			modelConfig = state.settings.GetModelPack().Planner.GetRoleForInputTokens(requestTokens, state.settings)
			log.Println("Tell plan - got modelConfig for tasks phase")
		}
	} else if state.currentStage.TellStage == shared.TellStageImplementation {
		modelConfig = state.settings.GetModelPack().GetCoder().GetRoleForInputTokens(requestTokens, state.settings)
		log.Println("Tell plan - got modelConfig for implementation stage")
	}

	state.modelConfig = &modelConfig

	baseModelConfig := modelConfig.GetBaseModelConfig(authVars, state.settings, state.orgUserConfig)

	if baseModelConfig == nil {
		log.Println("Tell plan - baseModelConfig is nil")
		log.Println("Tell plan - modelConfig id:", modelConfig.ModelId)

		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("No model config found for: %s", state.modelConfig.ModelId))
		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "No model config found for: " + string(state.modelConfig.ModelId),
		}
		return
	}

	state.baseModelConfig = baseModelConfig

	// if the model doesn't support cache control, remove the cache control spec from the messages
	if !baseModelConfig.SupportsCacheControl {
		for i := range state.messages {
			for j := range state.messages[i].Content {
				if state.messages[i].Content[j].CacheControl != nil {
					state.messages[i].Content[j].CacheControl = nil
				}
			}
		}
	}

	// if the model doesn't support images, remove any image parts from the messages
	if !baseModelConfig.HasImageSupport {
		log.Println("Tell exec - model doesn't support images. Removing image parts from messages. File name will still be included.")

		for i := range state.messages {
			filteredContent := []types.ExtendedChatMessagePart{}
			for _, part := range state.messages[i].Content {
				if part.Type != openai.ChatMessagePartTypeImageURL {
					filteredContent = append(filteredContent, part)
				}
			}
			state.messages[i].Content = filteredContent
		}
	}

	log.Println("tell exec - will send model request with:", spew.Sdump(map[string]interface{}{
		"provider":  baseModelConfig.Provider,
		"modelId":   baseModelConfig.ModelId,
		"modelTag":  baseModelConfig.ModelTag,
		"modelName": baseModelConfig.ModelName,
		"tokens":    requestTokens,
	}))

	_, apiErr := hooks.ExecHook(hooks.WillSendModelRequest, hooks.HookParams{
		Auth: auth,
		Plan: plan,
		WillSendModelRequestParams: &hooks.WillSendModelRequestParams{
			InputTokens:  requestTokens,
			OutputTokens: baseModelConfig.MaxOutputTokens - requestTokens,
			ModelName:    baseModelConfig.ModelName,
			ModelId:      baseModelConfig.ModelId,
			ModelTag:     baseModelConfig.ModelTag,
			IsUserPrompt: true,
		},
	})
	if apiErr != nil {
		active.StreamDoneCh <- apiErr
		return
	}

	state.doTellRequest()

	if shouldBuildPending {
		go state.queuePendingBuilds()
	}

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.CurrentStreamingReplyId = state.replyId
		ap.CurrentReplyDoneCh = make(chan bool, 1)
	})

}

func (state *activeTellStreamState) doTellRequest() {
	clients := state.clients
	authVars := state.authVars
	modelConfig := state.modelConfig
	active := state.activePlan

	fallbackRes := modelConfig.GetFallbackForModelError(state.numErrorRetry, state.didProviderFallback, state.modelErr, authVars, state.settings, state.orgUserConfig)
	modelConfig = fallbackRes.ModelRoleConfig
	stop := []string{"<PlandexFinish/>"}

	baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)

	if fallbackRes.FallbackType == shared.FallbackTypeProvider {
		state.didProviderFallback = true
	}

	// log.Println("Stop:", stop)
	// spew.Dump(state.messages)

	log.Println("modelConfig:", spew.Sdump(map[string]interface{}{
		"modelName": baseModelConfig.ModelName,
		"modelId":   baseModelConfig.ModelId,
		"modelTag":  baseModelConfig.ModelTag,
	}))

	if state.noCacheSupportErr {
		log.Println("Tell exec - request failed with cache support error. Removing cache control breakpoints from messages.")
		for i := range state.messages {
			for j := range state.messages[i].Content {
				if state.messages[i].Content[j].CacheControl != nil {
					state.messages[i].Content[j].CacheControl = nil
				}
			}
		}
	}

	modelReq := types.ExtendedChatCompletionRequest{
		Model:    baseModelConfig.ModelName,
		Messages: state.messages,
		Stream:   true,
		StreamOptions: &openai.StreamOptions{
			IncludeUsage: true,
		},
		Temperature: modelConfig.Temperature,
		TopP:        modelConfig.TopP,
	}

	if baseModelConfig.StopDisabled {
		state.manualStop = stop
	} else {
		modelReq.Stop = stop
	}

	// update state
	state.fallbackRes = fallbackRes
	state.requestStartedAt = time.Now()
	state.originalReq = &modelReq
	state.modelConfig = modelConfig

	// output the modelReq to a json file
	// if jsonData, err := json.MarshalIndent(modelReq, "", "  "); err == nil {
	// 	timestamp := time.Now().Format("2006-01-02-150405")
	// 	filename := fmt.Sprintf("generations/model-request-%s.json", timestamp)
	// 	if err := os.WriteFile(filename, jsonData, 0644); err != nil {
	// 		log.Printf("Error writing model request to file: %v\n", err)
	// 	}
	// } else {
	// 	log.Printf("Error marshaling model request to JSON: %v\n", err)
	// }

	log.Printf("[Tell] doTellRequest retry=%d fallbackRetry=%d using model=%s",
		state.numErrorRetry, state.numFallbackRetry, baseModelConfig.ModelName)

	// start the stream
	stream, err := model.CreateChatCompletionStream(clients, authVars, modelConfig, state.settings, state.orgUserConfig, state.currentOrgId, state.currentUserId, active.ModelStreamCtx, modelReq)
	if err != nil {
		log.Printf("Error starting reply stream: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error starting reply stream: %v", err))
		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error starting reply stream: " + err.Error(),
		}
		return
	}

	// handle stream chunks
	go state.listenStream(stream)
}

func (state *activeTellStreamState) dryRunCalculateTokensWithoutContext(tentativeMaxTokens int, unfinishedSubtaskReasoning string) (bool, int) {
	clone := &activeTellStreamState{
		modelStreamId:       state.modelStreamId,
		clients:             state.clients,
		req:                 state.req,
		auth:                state.auth,
		currentOrgId:        state.currentOrgId,
		currentUserId:       state.currentUserId,
		plan:                state.plan,
		branch:              state.branch,
		iteration:           state.iteration,
		missingFileResponse: state.missingFileResponse,
		settings:            state.settings,
		currentStage:        state.currentStage,
		subtasks:            state.subtasks,
		currentSubtask:      state.currentSubtask,
		convo:               state.convo,
		summaries:           state.summaries,
		latestSummaryTokens: state.latestSummaryTokens,
		userPrompt:          state.userPrompt,
		promptMessage:       state.promptMessage,
		hasContextMap:       state.hasContextMap,
		contextMapEmpty:     state.contextMapEmpty,
		hasAssistantReply:   state.hasAssistantReply,
		modelContext:        state.modelContext,
		activePlan:          state.activePlan,
	}

	sysParts, err := clone.getTellSysPrompt(getTellSysPromptParams{
		contextTokenLimit:    tentativeMaxTokens,
		dryRunWithoutContext: true,
	})

	if err != nil {
		log.Printf("error getting tell sys prompt for dry run token calculation: %v", err)

		msg := "Error getting tell sys prompt for dry run token calculation"
		if err.Error() == AllTasksCompletedMsg {
			msg = "There's no current task to implement. Try a prompt instead of the 'continue' command."
			go notify.NotifyErr(notify.SeverityInfo, msg)
		} else {
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error getting tell sys prompt for dry run token calculation: %v", err))
		}

		state.activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    msg,
		}
		return false, 0
	}

	clone.messages = []types.ExtendedChatMessage{
		{
			Role:    openai.ChatMessageRoleSystem,
			Content: sysParts,
		},
	}

	promptMessage, ok := clone.resolvePromptMessage(unfinishedSubtaskReasoning)
	if !ok {
		return false, 0
	}

	clone.tokensBeforeConvo =
		model.GetMessagesTokenEstimate(clone.messages...) +
			model.GetMessagesTokenEstimate(*promptMessage) +
			clone.latestSummaryTokens +
			model.TokensPerRequest

	var effectiveMaxTokens int
	if clone.currentStage.TellStage == shared.TellStagePlanning {
		if clone.currentStage.PlanningPhase == shared.PlanningPhaseContext {
			effectiveMaxTokens = clone.settings.GetArchitectEffectiveMaxTokens()
		} else {
			effectiveMaxTokens = clone.settings.GetPlannerEffectiveMaxTokens()
		}
	} else if clone.currentStage.TellStage == shared.TellStageImplementation {
		effectiveMaxTokens = clone.settings.GetCoderEffectiveMaxTokens()
	}

	if clone.tokensBeforeConvo > effectiveMaxTokens {
		log.Println("tokensBeforeConvo exceeds max tokens during dry run")
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("tokensBeforeConvo exceeds max tokens during dry run"))

		state.activePlan.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Max tokens exceeded before adding conversation",
		}
		return false, 0
	}

	if !clone.addConversationMessages() {
		return false, 0
	}

	clone.messages = append(clone.messages, *promptMessage)

	return true, model.GetMessagesTokenEstimate(clone.messages...) + model.TokensPerRequest
}


================================================
FILE: app/server/model/plan/tell_load.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/notify"
	"plandex-server/types"
	"runtime"
	"runtime/debug"

	shared "plandex-shared"

	"github.com/jmoiron/sqlx"
	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) loadTellPlan() error {
	clients := state.clients
	authVars := state.authVars
	req := state.req
	auth := state.auth
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	currentUserId := state.currentUserId
	currentOrgId := state.currentOrgId
	iteration := state.iteration
	missingFileResponse := state.missingFileResponse

	err := state.setActivePlan()
	if err != nil {
		return err
	}
	active := state.activePlan

	lockScope := db.LockScopeWrite
	if iteration > 0 || missingFileResponse != "" {
		lockScope = db.LockScopeRead
	}

	var modelContext []*db.Context
	var convo []*db.ConvoMessage
	var promptMsg *db.ConvoMessage
	var summaries []*db.ConvoSummary
	var subtasks []*db.Subtask
	var settings *shared.PlanSettings
	var orgUserConfig *shared.OrgUserConfig
	var latestSummaryTokens int
	var currentPlan *shared.CurrentPlanState

	log.Printf("[TellLoad] Tell plan - loadTellPlan - iteration: %d, missingFileResponse: %s, req.IsUserContinue: %t, lockScope: %s\n", iteration, missingFileResponse, req.IsUserContinue, lockScope)

	db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    auth.OrgId,
		UserId:   auth.User.Id,
		PlanId:   planId,
		Branch:   branch,
		Scope:    lockScope,
		Ctx:      active.Ctx,
		CancelFn: active.CancelFn,
		Reason:   "load tell plan",
	}, func(repo *db.GitRepo) error {
		errCh := make(chan error, 4)

		// get name for plan and rename if it's a draft
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanSettings: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("panic getting plan settings: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			res, err := db.GetPlanSettings(plan)
			if err != nil {
				log.Printf("Error getting plan settings: %v\n", err)
				errCh <- fmt.Errorf("error getting plan settings: %v", err)
				return
			}
			settings = res

			orgUserConfigRes, err := db.GetOrgUserConfig(auth.User.Id, auth.OrgId)
			if err != nil {
				log.Printf("Error getting org user config: %v\n", err)
				errCh <- fmt.Errorf("error getting org user config: %v", err)
				return
			}
			orgUserConfig = orgUserConfigRes

			if plan.Name == "draft" {
				name, err := model.GenPlanName(
					auth,
					plan,
					settings,
					orgUserConfig,
					clients,
					authVars,
					req.Prompt,
					active.SessionId,
					active.Ctx,
				)

				if err != nil {
					log.Printf("Error generating plan name: %v\n", err)
					errCh <- fmt.Errorf("error generating plan name: %v", err)
					return
				}

				err = db.WithTx(active.Ctx, "rename plan", func(tx *sqlx.Tx) error {
					err := db.RenamePlan(planId, name, tx)

					if err != nil {
						log.Printf("Error renaming plan: %v\n", err)
						return fmt.Errorf("error renaming plan: %v", err)
					}

					err = db.IncNumNonDraftPlans(currentUserId, tx)

					if err != nil {
						log.Printf("Error incrementing num non draft plans: %v\n", err)
						return fmt.Errorf("error incrementing num non draft plans: %v", err)
					}

					return nil
				})

				if err != nil {
					log.Printf("Error renaming plan: %v\n", err)
					errCh <- fmt.Errorf("error renaming plan: %v", err)
					return
				}
			}

			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanContexts: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan modelContext: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			if iteration > 0 || missingFileResponse != "" {
				modelContext = active.Contexts
			} else {
				res, err := db.GetPlanContexts(currentOrgId, planId, true, false)
				if err != nil {
					log.Printf("Error getting plan modelContext: %v\n", err)
					errCh <- fmt.Errorf("error getting plan modelContext: %v", err)
					return
				}

				log.Printf("[TellLoad] Tell plan - loadTellPlan - modelContext: %v\n", len(modelContext))
				// for _, part := range modelContext {
				// 	log.Printf("[TellLoad] Tell plan - loadTellPlan - part: %s - %s - %s - %d tokens\n", part.ContextType, part.Name, part.FilePath, part.NumTokens)
				// }

				modelContext = res
			}

			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanConvo: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan convo: %v", r)
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			res, err := db.GetPlanConvo(currentOrgId, planId)
			if err != nil {
				log.Printf("Error getting plan convo: %v\n", err)
				errCh <- fmt.Errorf("error getting plan convo: %v", err)
				return
			}
			convo = res
			UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
				ap.MessageNum = len(convo)
			})

			promptTokens := shared.GetNumTokensEstimate(req.Prompt)
			innerErrCh := make(chan error, 2)

			go func() {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in storeUserMessage: %v\n%s", r, debug.Stack())
						innerErrCh <- fmt.Errorf("error storing user message: %v", r)
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()

				if iteration == 0 && missingFileResponse == "" && !req.IsUserContinue {
					num := len(convo) + 1

					log.Printf("[TellLoad] storing user message | len(convo): %d | num: %d\n", len(convo), num)

					promptMsg = &db.ConvoMessage{
						OrgId:   currentOrgId,
						PlanId:  planId,
						UserId:  currentUserId,
						Role:    openai.ChatMessageRoleUser,
						Tokens:  promptTokens,
						Num:     num,
						Message: req.Prompt,
						Flags: shared.ConvoMessageFlags{
							IsApplyDebug: req.IsApplyDebug,
							IsUserDebug:  req.IsUserDebug,
							IsChat:       req.IsChatOnly,
						},
					}

					log.Println("[TellLoad] storing user message")
					// repo.LogGitRepoState()

					_, err = db.StoreConvoMessage(repo, promptMsg, auth.User.Id, branch, true)

					if err != nil {
						log.Printf("[TellLoad] Error storing user message: %v\n", err)
						innerErrCh <- fmt.Errorf("error storing user message: %v", err)
						return
					}

					UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
						ap.MessageNum = num
					})
				}

				innerErrCh <- nil
			}()

			go func() {
				defer func() {
					if r := recover(); r != nil {
						log.Printf("panic in getPlanSummaries: %v\n%s", r, debug.Stack())
						innerErrCh <- fmt.Errorf("error getting plan summaries: %v", r)
						runtime.Goexit() // don't allow outer function to continue and double-send to channel
					}
				}()

				var convoMessageIds []string

				for _, convoMessage := range convo {
					convoMessageIds = append(convoMessageIds, convoMessage.Id)
				}

				log.Println("getting plan summaries")
				log.Println("convoMessageIds:", convoMessageIds)

				res, err := db.GetPlanSummaries(planId, convoMessageIds)
				if err != nil {
					log.Printf("Error getting plan summaries: %v\n", err)
					innerErrCh <- fmt.Errorf("error getting plan summaries: %v", err)
					return
				}
				summaries = res

				log.Printf("got %d plan summaries", len(summaries))

				if len(summaries) > 0 {
					latestSummaryTokens = shared.GetNumTokensEstimate(summaries[len(summaries)-1].Summary)
				}

				innerErrCh <- nil
			}()

			for i := 0; i < 2; i++ {
				err := <-innerErrCh
				if err != nil {
					errCh <- err
					return
				}
			}

			if promptMsg != nil {
				convo = append(convo, promptMsg)
			}

			errCh <- nil
		}()

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in getPlanSubtasks: %v\n%s", r, debug.Stack())
					errCh <- fmt.Errorf("error getting plan subtasks: %v\n%s", r, debug.Stack())
					runtime.Goexit() // don't allow outer function to continue and double-send to channel
				}
			}()

			res, err := db.GetPlanSubtasks(auth.OrgId, planId)
			if err != nil {
				log.Printf("Error getting plan subtasks: %v\n", err)
				errCh <- fmt.Errorf("error getting plan subtasks: %v", err)
				return
			}
			subtasks = res
			errCh <- nil
		}()

		for i := 0; i < 4; i++ {
			err = <-errCh
			if err != nil {
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error loading plan: %v", err))

				active.StreamDoneCh <- &shared.ApiError{
					Type:   shared.ApiErrorTypeOther,
					Status: http.StatusInternalServerError,
					Msg:    fmt.Sprintf("Error loading plan: %v", err),
				}
				return err
			}
		}

		res, err := db.GetCurrentPlanState(db.CurrentPlanStateParams{
			OrgId:    currentOrgId,
			PlanId:   planId,
			Contexts: modelContext,
		})

		if err != nil {
			return fmt.Errorf("error getting current plan state: %v", err)
		}

		currentPlan = res

		return nil
	})

	if err != nil {
		log.Printf("execTellPlan: error loading tell plan: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error loading tell plan: %v", err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error loading tell plan: %v", err),
		}
		return err
	}

	state.modelContext = modelContext
	state.convo = convo
	state.promptConvoMessage = promptMsg
	state.summaries = summaries
	state.latestSummaryTokens = latestSummaryTokens
	state.settings = settings
	state.currentPlanState = currentPlan
	state.subtasks = subtasks

	for _, subtask := range state.subtasks {
		if !subtask.IsFinished {
			state.currentSubtask = subtask
			break
		}
	}

	log.Printf("[TellLoad] Subtasks: %+v", state.subtasks)
	log.Printf("[TellLoad] Current subtask: %+v", state.currentSubtask)

	state.hasContextMap = false
	state.contextMapEmpty = true
	for _, context := range state.modelContext {
		if context.ContextType == shared.ContextMapType {
			state.hasContextMap = true
			if context.NumTokens > 0 {
				state.contextMapEmpty = false
			}
			break
		}
	}

	state.hasAssistantReply = false
	for _, convoMessage := range state.convo {
		if convoMessage.Role == openai.ChatMessageRoleAssistant {
			state.hasAssistantReply = true
			break
		}
	}

	if iteration == 0 && missingFileResponse == "" {
		UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
			ap.Contexts = state.modelContext

			for _, context := range state.modelContext {
				if context.FilePath != "" {
					ap.ContextsByPath[context.FilePath] = context
				}
			}
		})
	} else if missingFileResponse == "" {
		// reset current reply content and num tokens
		UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
			ap.CurrentReplyContent = ""
			ap.NumTokens = 0
		})
	}

	// if any skipped paths have since been added to context, remove them from skipped paths
	if len(active.SkippedPaths) > 0 {
		var toUnskipPaths []string
		for contextPath := range active.ContextsByPath {
			if active.SkippedPaths[contextPath] {
				toUnskipPaths = append(toUnskipPaths, contextPath)
			}
		}
		if len(toUnskipPaths) > 0 {
			UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
				for _, path := range toUnskipPaths {
					delete(ap.SkippedPaths, path)
				}
			})
		}
	}

	return nil
}

func (state *activeTellStreamState) setActivePlan() error {
	plan := state.plan
	branch := state.branch

	active := GetActivePlan(plan.Id, branch)

	if active == nil {
		return fmt.Errorf("no active plan with id %s", plan.Id)
	}

	state.activePlan = active

	return nil
}


================================================
FILE: app/server/model/plan/tell_missing_file.go
================================================
package plan

import (
	"log"
	"plandex-server/model/prompts"
	"plandex-server/types"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) handleMissingFileResponse(unfinishedSubtaskReasoning string) bool {
	missingFileResponse := state.missingFileResponse
	planId := state.plan.Id
	branch := state.branch
	req := state.req

	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("execTellPlan: Active plan not found for plan ID %s on branch %s\n", planId, branch)
		return false
	}

	log.Println("Missing file response:", missingFileResponse, "setting replyParser")
	// log.Printf("Current reply content:\n%s\n", active.CurrentReplyContent)

	state.replyParser.AddChunk(active.CurrentReplyContent, true)
	res := state.replyParser.Read()
	currentFile := res.CurrentFilePath

	log.Printf("Current file: %s\n", currentFile)
	// log.Println("Current reply content:\n", active.CurrentReplyContent)

	replyContent := active.CurrentReplyContent
	numTokens := active.NumTokens

	if missingFileResponse == shared.RespondMissingFileChoiceSkip {
		replyBeforeCurrentFile := state.replyParser.GetReplyBeforeCurrentPath()
		numTokens = shared.GetNumTokensEstimate(replyBeforeCurrentFile)

		replyContent = replyBeforeCurrentFile
		state.replyParser = types.NewReplyParser()
		state.replyParser.AddChunk(replyContent, true)

		UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
			ap.CurrentReplyContent = replyContent
			ap.NumTokens = numTokens
			ap.SkippedPaths[currentFile] = true
		})

	} else {
		if missingFileResponse == shared.RespondMissingFileChoiceOverwrite {
			UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
				ap.AllowOverwritePaths[currentFile] = true
			})
		}
	}

	state.messages = append(state.messages, types.ExtendedChatMessage{
		Role: openai.ChatMessageRoleAssistant,
		Content: []types.ExtendedChatMessagePart{
			{
				Type: openai.ChatMessagePartTypeText,
				Text: active.CurrentReplyContent,
			},
		},
	})

	if missingFileResponse == shared.RespondMissingFileChoiceSkip {
		res := state.replyParser.FinishAndRead()
		skipPrompt := prompts.GetSkipMissingFilePrompt(res.CurrentFilePath)

		params := prompts.UserPromptParams{
			CreatePromptParams: prompts.CreatePromptParams{
				ExecMode:          req.ExecEnabled,
				AutoContext:       req.AutoContext,
				IsUserDebug:       req.IsUserDebug,
				IsApplyDebug:      req.IsApplyDebug,
				ContextTokenLimit: state.settings.GetPlannerEffectiveMaxTokens(),
			},
			Prompt:                     skipPrompt,
			OsDetails:                  req.OsDetails,
			CurrentStage:               state.currentStage,
			UnfinishedSubtaskReasoning: unfinishedSubtaskReasoning,
		}

		prompt := prompts.GetWrappedPrompt(params) + "\n\n" + skipPrompt // repetition of skip prompt to improve instruction following

		state.messages = append(state.messages, types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleUser,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		})

	} else {
		missingPrompt := prompts.GetMissingFileContinueGeneratingPrompt(res.CurrentFilePath)

		params := prompts.UserPromptParams{
			CreatePromptParams: prompts.CreatePromptParams{
				ExecMode:          req.ExecEnabled,
				AutoContext:       req.AutoContext,
				IsUserDebug:       req.IsUserDebug,
				IsApplyDebug:      req.IsApplyDebug,
				ContextTokenLimit: state.settings.GetPlannerEffectiveMaxTokens(),
			},
			Prompt:                     missingPrompt,
			OsDetails:                  req.OsDetails,
			CurrentStage:               state.currentStage,
			UnfinishedSubtaskReasoning: unfinishedSubtaskReasoning,
		}

		prompt := prompts.GetWrappedPrompt(params) + "\n\n" + missingPrompt // repetition of missing prompt to improve instruction following

		state.messages = append(state.messages, types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleUser,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompt,
				},
			},
		})
	}

	return true
}


================================================
FILE: app/server/model/plan/tell_prompt_message.go
================================================
package plan

import (
	"log"
	"net/http"
	"plandex-server/model/prompts"
	"plandex-server/types"
	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) resolvePromptMessage(
	unfinishedSubtaskReasoning string,
) (*types.ExtendedChatMessage, bool) {
	req := state.req
	active := state.activePlan
	iteration := state.iteration

	var promptMessage *types.ExtendedChatMessage

	state.skipConvoMessages = map[string]bool{}

	lastMessage := state.lastSuccessfulConvoMessage()

	if req.IsUserContinue {
		if lastMessage == nil {
			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeContinueNoMessages,
				Status: http.StatusBadRequest,
				Msg:    "No messages yet. Can't continue plan.",
			}
			return nil, false
		}
		log.Println("User is continuing plan. Last message role:", lastMessage.Role)
	}

	if req.IsChatOnly {
		var prompt string
		if req.IsUserContinue {
			if lastMessage.Role == openai.ChatMessageRoleUser {
				log.Println("User is continuing plan in chat only mode. Last message was user message. Using last user message as prompt")
				content := lastMessage.Message
				prompt = content
				state.userPrompt = content
				state.skipConvoMessages[lastMessage.Id] = true
			} else {
				log.Println("User is continuing plan in chat only mode. Last message was assistant message. Using user continue prompt")
				prompt = prompts.UserContinuePrompt
			}
		} else {
			prompt = req.Prompt
		}

		wrapped := prompts.GetWrappedChatOnlyPrompt(prompts.ChatUserPromptParams{
			CreatePromptParams: prompts.CreatePromptParams{
				AutoContext: req.AutoContext,
				ExecMode:    req.ExecEnabled,
				IsGitRepo:   req.IsGitRepo,
				// no need to pass in IsUserDebug or IsApplyDebug here because it's a chat message
			},
			Prompt:    prompt,
			OsDetails: req.OsDetails,
			// no current task for chat only mode
		})

		promptMessage = &types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleUser,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: wrapped,
				},
			},
		}
	} else if req.IsUserContinue {
		// log.Println("User is continuing plan. Last message:\n\n", lastMessage.Content)
		if lastMessage.Role == openai.ChatMessageRoleUser {
			// if last message was a user message, we want to remove it from the messages array and then use that last message as the prompt so we can continue from where the user left off

			log.Println("User is continuing plan in tell mode. Last message was user message. Using last user message as prompt")
			content := lastMessage.Message

			params := prompts.UserPromptParams{
				CreatePromptParams: prompts.CreatePromptParams{
					ExecMode:          req.ExecEnabled,
					AutoContext:       req.AutoContext,
					IsGitRepo:         req.IsGitRepo,
					ContextTokenLimit: state.settings.GetPlannerEffectiveMaxTokens(),
					// no need to pass in IsUserDebug or IsApplyDebug here because we're continuing
				},
				Prompt:                     content,
				OsDetails:                  req.OsDetails,
				CurrentStage:               state.currentStage,
				UnfinishedSubtaskReasoning: unfinishedSubtaskReasoning,
			}

			promptMessage = &types.ExtendedChatMessage{
				Role: openai.ChatMessageRoleUser,
				Content: []types.ExtendedChatMessagePart{
					{
						Type: openai.ChatMessagePartTypeText,
						Text: prompts.GetWrappedPrompt(params),
					},
				},
			}

			state.userPrompt = content
		} else {

			// if the last message was an assistant message, we'll use the user continue prompt
			log.Println("User is continuing plan in tell mode. Last message was assistant message. Using user continue prompt")

			params := prompts.UserPromptParams{
				CreatePromptParams: prompts.CreatePromptParams{
					ExecMode:          req.ExecEnabled,
					AutoContext:       req.AutoContext,
					IsGitRepo:         req.IsGitRepo,
					ContextTokenLimit: state.settings.GetPlannerEffectiveMaxTokens(),
					// no need to pass in IsUserDebug or IsApplyDebug here because we're continuing
				},
				Prompt:                     prompts.UserContinuePrompt,
				OsDetails:                  req.OsDetails,
				CurrentStage:               state.currentStage,
				UnfinishedSubtaskReasoning: unfinishedSubtaskReasoning,
			}

			promptMessage = &types.ExtendedChatMessage{
				Role: openai.ChatMessageRoleUser,
				Content: []types.ExtendedChatMessagePart{
					{
						Type: openai.ChatMessagePartTypeText,
						Text: prompts.GetWrappedPrompt(params),
					},
				},
			}
		}
	} else {
		var prompt string
		if iteration == 0 {
			prompt = req.Prompt
		} else if state.currentStage.TellStage == shared.TellStageImplementation {
			prompt = prompts.AutoContinueImplementationPrompt
		} else {
			prompt = prompts.AutoContinuePlanningPrompt
		}

		state.userPrompt = prompt

		params := prompts.UserPromptParams{
			CreatePromptParams: prompts.CreatePromptParams{
				ExecMode:          req.ExecEnabled,
				AutoContext:       req.AutoContext,
				IsUserDebug:       req.IsUserDebug,
				IsApplyDebug:      req.IsApplyDebug,
				IsGitRepo:         req.IsGitRepo,
				ContextTokenLimit: state.settings.GetPlannerEffectiveMaxTokens(),
			},
			Prompt:                     prompt,
			OsDetails:                  req.OsDetails,
			CurrentStage:               state.currentStage,
			UnfinishedSubtaskReasoning: unfinishedSubtaskReasoning,
		}

		finalPrompt := prompts.GetWrappedPrompt(params)

		// log.Println("Final prompt:", finalPrompt)

		promptMessage = &types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleUser,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: finalPrompt,
				},
			},
		}
	}

	// log.Println("Prompt message:", promptMessage.Content)

	return promptMessage, true
}


================================================
FILE: app/server/model/plan/tell_stage.go
================================================
package plan

import (
	"log"
	"plandex-server/db"
	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) lastSuccessfulConvoMessage() *db.ConvoMessage {
	for i := len(state.convo) - 1; i >= 0; i-- {
		msg := state.convo[i]
		if msg.Stopped || msg.Flags.HasError {
			continue
		}
		return msg
	}
	return nil
}

func (state *activeTellStreamState) resolveCurrentStage() (activatePaths map[string]bool, activatePathsOrdered []string) {
	req := state.req
	iteration := state.iteration
	hasContextMap := state.hasContextMap
	convo := state.convo
	contextMapEmpty := state.contextMapEmpty

	log.Printf("[resolveCurrentStage] Initial state: hasContextMap: %v, convo len: %d", hasContextMap, len(convo))

	lastConvoMsg := state.lastSuccessfulConvoMessage()

	activatePaths = map[string]bool{}
	activatePathsOrdered = []string{}

	isContinueFromAssistantMsg := false

	if lastConvoMsg != nil {
		isContinueFromAssistantMsg = iteration == 0 && req.IsUserContinue && lastConvoMsg.Role == openai.ChatMessageRoleAssistant
		log.Printf("[resolveCurrentStage] isContinueFromAssistantMsg: %v (IsUserContinue: %v, LastMsgRole: %s)",
			isContinueFromAssistantMsg, req.IsUserContinue, lastConvoMsg.Role)
	} else {
		log.Println("[resolveCurrentStage] No previous successful conversation message found")
	}

	isUserPrompt := false

	if !isContinueFromAssistantMsg {
		isUserPrompt = lastConvoMsg == nil || lastConvoMsg.Role == openai.ChatMessageRoleUser
		log.Printf("[resolveCurrentStage] isUserPrompt: %v", isUserPrompt)
	}

	var tellStage shared.TellStage
	var planningPhase shared.PlanningPhase

	if isUserPrompt {
		tellStage = shared.TellStagePlanning
		log.Println("[resolveCurrentStage] Set tellStage to Planning due to user prompt")
	} else {
		if lastConvoMsg != nil && lastConvoMsg.Flags.DidMakePlan {
			tellStage = shared.TellStageImplementation
			log.Println("[resolveCurrentStage] Set tellStage to Implementation - DidMakePlan: true, IsChatOnly: false")
		} else if lastConvoMsg != nil && lastConvoMsg.Flags.CurrentStage.TellStage == shared.TellStageImplementation {
			tellStage = shared.TellStageImplementation
			log.Println("[resolveCurrentStage] Set tellStage to Implementation - CurrentStage: implementation")
		} else {
			tellStage = shared.TellStagePlanning
			log.Printf("[resolveCurrentStage] Set tellStage to Planning - DidMakePlan: %v, IsChatOnly: %v",
				lastConvoMsg != nil && lastConvoMsg.Flags.DidMakePlan, req.IsChatOnly)
		}
	}

	wasContextStage := false
	if lastConvoMsg != nil {
		flags := lastConvoMsg.Flags
		log.Printf("[resolveCurrentStage] Last convo message flags: %+v", flags)
		if flags.CurrentStage.TellStage == shared.TellStagePlanning && flags.CurrentStage.PlanningPhase == shared.PlanningPhaseContext {
			wasContextStage = true
			activatePaths = lastConvoMsg.ActivatedPaths
			activatePathsOrdered = lastConvoMsg.ActivatedPathsOrdered
			log.Printf("[resolveCurrentStage] Was context stage, copied activatePaths: %v", activatePaths)
		}
	}

	if tellStage == shared.TellStagePlanning {
		if req.AutoContext && hasContextMap && !contextMapEmpty && !wasContextStage {
			planningPhase = shared.PlanningPhaseContext
			log.Printf("[resolveCurrentStage] Set planningPhase to Context - AutoContext: %v, hasContextMap: %v, contextMapEmpty: %v, wasContextStage: %v",
				req.AutoContext, hasContextMap, contextMapEmpty, wasContextStage)
		} else {
			planningPhase = shared.PlanningPhaseTasks
			log.Printf("[resolveCurrentStage] Set planningPhase to Tasks - AutoContext: %v, hasContextMap: %v, contextMapEmpty: %v, wasContextStage: %v",
				req.AutoContext, hasContextMap, contextMapEmpty, wasContextStage)
		}
	}

	state.currentStage = shared.CurrentStage{
		TellStage:     tellStage,
		PlanningPhase: planningPhase,
	}
	log.Printf("[resolveCurrentStage] Final state - TellStage: %s, PlanningPhase: %s", tellStage, planningPhase)

	return activatePaths, activatePathsOrdered
}


================================================
FILE: app/server/model/plan/tell_state.go
================================================
package plan

import (
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/types"
	"time"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

type activeTellStreamState struct {
	activePlan            *types.ActivePlan
	modelStreamId         string
	clients               map[string]model.ClientInfo
	authVars              map[string]string
	req                   *shared.TellPlanRequest
	auth                  *types.ServerAuth
	currentOrgId          string
	currentUserId         string
	orgUserConfig         *shared.OrgUserConfig
	plan                  *db.Plan
	branch                string
	iteration             int
	replyId               string
	modelContext          []*db.Context
	hasContextMap         bool
	contextMapEmpty       bool
	convo                 []*db.ConvoMessage
	promptConvoMessage    *db.ConvoMessage
	currentPlanState      *shared.CurrentPlanState
	missingFileResponse   shared.RespondMissingFileChoice
	summaries             []*db.ConvoSummary
	summarizedToMessageId string
	latestSummaryTokens   int
	userPrompt            string
	promptMessage         *openai.ChatCompletionMessage
	replyParser           *types.ReplyParser
	replyNumTokens        int
	messages              []types.ExtendedChatMessage
	tokensBeforeConvo     int
	totalRequestTokens    int
	settings              *shared.PlanSettings
	subtasks              []*db.Subtask
	currentSubtask        *db.Subtask
	hasAssistantReply     bool
	currentStage          shared.CurrentStage
	chunkProcessor        *chunkProcessor
	generationId          string

	requestStartedAt time.Time
	firstTokenAt     time.Time
	originalReq      *types.ExtendedChatCompletionRequest
	modelConfig      *shared.ModelRoleConfig
	baseModelConfig  *shared.BaseModelConfig
	fallbackRes      shared.FallbackResult

	skipConvoMessages map[string]bool

	manualStop []string

	numErrorRetry       int
	numFallbackRetry    int
	modelErr            *shared.ModelError
	noCacheSupportErr   bool
	didProviderFallback bool
}

type chunkProcessor struct {
	replyOperations                 []*shared.Operation
	chunksReceived                  int
	maybeRedundantOpeningTagContent string
	fileOpen                        bool
	contentBuffer                   string
	awaitingBlockOpeningTag         bool
	awaitingBlockClosingTag         bool
	awaitingOpClosingTag            bool
	awaitingBackticks               bool
}


================================================
FILE: app/server/model/plan/tell_stream_error.go
================================================
package plan

import (
	"context"
	"fmt"
	"log"
	"math/rand"
	"net/http"
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/notify"
	"plandex-server/shutdown"
	"strconv"
	"time"

	shared "plandex-shared"
)

type onErrorParams struct {
	streamErr      error
	streamApiErr   *shared.ApiError
	storeDesc      bool
	convoMessageId string
	commitMsg      string
	canRetry       bool
	modelErr       *shared.ModelError
}

type onErrorResult struct {
	shouldContinueMainLoop bool
	shouldReturn           bool
}

func (state *activeTellStreamState) onError(params onErrorParams) onErrorResult {
	log.Printf("\nStream error: %v\n", params.streamErr)
	streamErr := params.streamErr
	storeDesc := params.storeDesc
	convoMessageId := params.convoMessageId
	commitMsg := params.commitMsg
	modelErr := params.modelErr

	planId := state.plan.Id
	branch := state.branch
	currentOrgId := state.currentOrgId
	summarizedToMessageId := state.summarizedToMessageId

	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("tellStream onError - Active plan not found for plan ID %s on branch %s\n", planId, branch)
		return onErrorResult{
			shouldReturn: true,
		}
	}

	canRetry := params.canRetry
	isFallback := state.fallbackRes.IsFallback

	maxRetries := model.MAX_RETRIES_WITHOUT_FALLBACK
	if isFallback {
		maxRetries = model.MAX_ADDITIONAL_RETRIES_WITH_FALLBACK
	}

	compareRetries := state.numErrorRetry
	if isFallback {
		compareRetries = state.numFallbackRetry
	}

	potentialFallback := state.modelConfig.GetFallbackForModelError(
		state.numErrorRetry,
		state.didProviderFallback,
		modelErr,
		state.authVars,
		state.settings,
		state.orgUserConfig,
	)

	newFallback := false
	if modelErr != nil {
		if !modelErr.Retriable {
			log.Printf("tellStream onError - operation returned non-retriable error: %v", modelErr)
			if !potentialFallback.IsFallback {
				canRetry = false
			} else {
				log.Printf("tellStream onError - operation returned non-retriable error, but has fallback - resetting numFallbackRetry to 0 and continuing to retry")
				state.numFallbackRetry = 0
				// otherwise, continue to retry logic
				canRetry = true
				newFallback = true
			}
		}
	}

	if canRetry {
		log.Println("tellStream onError - canRetry", canRetry)

		if compareRetries >= maxRetries {
			log.Printf("tellStream onError - Max retries reached for plan ID %s on branch %s\n", planId, branch)

			canRetry = false
		}
	}

	if canRetry {
		log.Println("tellStream onError - retrying stream")
		// stop stream via context (ensures we stop child streams too)
		active.CancelModelStreamFn()

		active.ResetModelCtx()

		var retryDelay time.Duration
		if modelErr != nil && modelErr.RetryAfterSeconds > 0 {
			// if the model err has a retry after, then use that with a bit of padding
			retryDelay = time.Duration(int(float64(modelErr.RetryAfterSeconds)*1.1)) * time.Second
		} else {
			// otherwise, use some jitter
			retryDelay = time.Duration(1000+rand.Intn(200)) * time.Millisecond
		}

		cacheSupportErr := modelErr != nil && modelErr.Kind == shared.ErrCacheSupport

		numErrorRetry := state.numErrorRetry
		if modelErr != nil && modelErr.ShouldIncrementRetry() {
			numErrorRetry = numErrorRetry + 1
		}

		log.Printf("tellStream onError - Retry %d/%d - Retrying stream in %v", numErrorRetry, maxRetries, retryDelay)
		time.Sleep(retryDelay)

		state.numErrorRetry = numErrorRetry
		if isFallback && !newFallback && modelErr != nil && modelErr.ShouldIncrementRetry() {
			state.numFallbackRetry = state.numFallbackRetry + 1
		}

		// if we got a cache support error, keep everything the same, including the modelErr (if we're already retrying) so we can make the exact same request again without cache control breakpoints
		if cacheSupportErr {
			state.noCacheSupportErr = true
		} else {
			state.modelErr = modelErr

			if newFallback {
				// if we got a new fallback, we need to reset the noCacheSupportErr flag since we're using a different model now
				state.noCacheSupportErr = false
			}
		}

		// retry the request
		state.doTellRequest()
		return onErrorResult{
			shouldReturn: true,
		}
	}

	storeDescAndReply := func() error {
		log.Println("tellStream onError - storing desc and reply")
		ctx, cancelFn := context.WithTimeout(shutdown.ShutdownCtx, 5*time.Second)

		err := db.ExecRepoOperation(db.ExecRepoOperationParams{
			OrgId:    currentOrgId,
			UserId:   state.currentUserId,
			PlanId:   planId,
			Branch:   branch,
			Scope:    db.LockScopeWrite,
			Ctx:      ctx,
			CancelFn: cancelFn,
			Reason:   "store desc and reply",
		}, func(repo *db.GitRepo) error {
			storedMessage := false
			storedDesc := false

			if convoMessageId == "" {
				hasUnfinishedSubtasks := false
				for _, subtask := range state.subtasks {
					if !subtask.IsFinished {
						hasUnfinishedSubtasks = true
						break
					}
				}

				assistantMsg, msg, err := state.storeAssistantReply(repo, storeAssistantReplyParams{
					flags: shared.ConvoMessageFlags{
						CurrentStage:          state.currentStage,
						HasUnfinishedSubtasks: hasUnfinishedSubtasks,
						HasError:              true,
					},
					subtask:       nil,
					addedSubtasks: nil,
				})
				if err == nil {
					convoMessageId = assistantMsg.Id
					commitMsg = msg
					storedMessage = true
				} else {
					log.Printf("Error storing assistant message after stream error: %v\n", err)
					return err
				}
			}

			if storeDesc && convoMessageId != "" {
				err := db.StoreDescription(&db.ConvoMessageDescription{
					OrgId:                 currentOrgId,
					PlanId:                planId,
					SummarizedToMessageId: summarizedToMessageId,
					WroteFiles:            false,
					ConvoMessageId:        convoMessageId,
					BuildPathsInvalidated: map[string]bool{},
					Error:                 streamErr.Error(),
				})
				if err == nil {
					storedDesc = true
				} else {
					log.Printf("Error storing description after stream error: %v\n", err)
					return err
				}
			}

			if storedMessage || storedDesc {
				err := repo.GitAddAndCommit(branch, commitMsg)
				if err != nil {
					log.Printf("Error committing after stream error: %v\n", err)
					return err
				}
			}

			return nil
		})

		if err != nil {
			log.Printf("Error storing description and reply after stream error: %v\n", err)
			return err
		}

		return nil
	}

	if active.CurrentReplyContent != "" {
		storeDescAndReply() // best effort to store description and reply, ignore errors
	}

	if params.streamApiErr != nil {
		active.StreamDoneCh <- params.streamApiErr
	} else {
		msg := "Stream error: " + streamErr.Error()
		if params.canRetry && state.numErrorRetry >= maxRetries {
			msg += " | Failed after " + strconv.Itoa(state.numErrorRetry) + " retries"
		}

		go notify.NotifyErr(notify.SeverityInfo, fmt.Sprintf("tellStream stream error after %d retries: %v", state.numErrorRetry, streamErr))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    msg,
		}
	}

	return onErrorResult{
		shouldContinueMainLoop: true,
	}
}

func (state *activeTellStreamState) onActivePlanMissingError() {
	planId := state.plan.Id
	branch := state.branch
	log.Printf("Active plan not found for plan ID %s on branch %s\n", planId, branch)
	state.onError(onErrorParams{
		streamErr: fmt.Errorf("active plan not found for plan ID %s on branch %s", planId, branch),
		storeDesc: true,
	})
}


================================================
FILE: app/server/model/plan/tell_stream_finish.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/types"
	"runtime/debug"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
)

const MaxAutoContinueIterations = 200

type handleStreamFinishedResult struct {
	shouldContinueMainLoop bool
	shouldReturn           bool
}

func (state *activeTellStreamState) handleStreamFinished() handleStreamFinishedResult {
	planId := state.plan.Id
	branch := state.branch
	auth := state.auth
	plan := state.plan
	req := state.req
	clients := state.clients
	authVars := state.authVars
	settings := state.settings
	orgUserConfig := state.orgUserConfig
	currentOrgId := state.currentOrgId
	summaries := state.summaries
	convo := state.convo
	iteration := state.iteration
	replyOperations := state.chunkProcessor.replyOperations

	err := state.setActivePlan()
	if err != nil {
		state.onActivePlanMissingError()
		return handleStreamFinishedResult{
			shouldContinueMainLoop: true,
			shouldReturn:           false,
		}
	}

	active := state.activePlan

	time.Sleep(30 * time.Millisecond)
	active.FlushStreamBuffer()
	time.Sleep(100 * time.Millisecond)

	active.Stream(shared.StreamMessage{
		Type: shared.StreamMessageDescribing,
	})
	active.FlushStreamBuffer()

	err = db.SetPlanStatus(planId, branch, shared.PlanStatusDescribing, "")
	if err != nil {
		res := state.onError(onErrorParams{
			streamErr: fmt.Errorf("failed to set plan status to describing: %v", err),
			storeDesc: true,
		})

		return handleStreamFinishedResult{
			shouldContinueMainLoop: res.shouldContinueMainLoop,
			shouldReturn:           res.shouldReturn,
		}
	}

	autoLoadContextResult := state.checkAutoLoadContext()
	checkNewSubtasksResult := state.checkNewSubtasks()

	hasExplicitTasks := checkNewSubtasksResult.hasExplicitTasks
	addedSubtasks := checkNewSubtasksResult.newSubtasks

	checkRemoveSubtasksResult := state.checkRemoveSubtasks()

	removedSubtasks := checkRemoveSubtasksResult.removedSubtasks
	hasExplicitRemoveTasks := checkRemoveSubtasksResult.hasExplicitRemoveTasks

	log.Println("removedSubtasks:\n", spew.Sdump(removedSubtasks))
	log.Println("addedSubtasks:\n", spew.Sdump(addedSubtasks))
	log.Println("hasNewSubtasks:\n", hasExplicitTasks)

	handleDescAndExecStatusRes := state.handleDescAndExecStatus()
	if handleDescAndExecStatusRes.shouldContinueMainLoop || handleDescAndExecStatusRes.shouldReturn {
		return handleDescAndExecStatusRes.handleStreamFinishedResult
	}
	generatedDescription := handleDescAndExecStatusRes.generatedDescription
	subtaskFinished := handleDescAndExecStatusRes.subtaskFinished

	log.Printf("subtaskFinished: %v\n", subtaskFinished)

	storeOnFinishedResult := state.storeOnFinished(storeOnFinishedParams{
		replyOperations:       replyOperations,
		generatedDescription:  generatedDescription,
		subtaskFinished:       subtaskFinished,
		hasNewSubtasks:        hasExplicitTasks,
		autoLoadContextResult: autoLoadContextResult,
		addedSubtasks:         addedSubtasks,
		removedSubtasks:       removedSubtasks,
	})
	if storeOnFinishedResult.shouldContinueMainLoop || storeOnFinishedResult.shouldReturn {
		return storeOnFinishedResult.handleStreamFinishedResult
	}
	allSubtasksFinished := storeOnFinishedResult.allSubtasksFinished

	log.Println("allSubtasksFinished:\n", spew.Sdump(allSubtasksFinished))

	// summarize convo needs to come *after* the reply is stored in order to correctly summarize the latest message
	log.Println("summarizing convo in background")
	// summarize in the background
	go func() {

		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in summarizeConvo: %v\n%s", r, debug.Stack())
				active.StreamDoneCh <- &shared.ApiError{
					Type:   shared.ApiErrorTypeOther,
					Status: http.StatusInternalServerError,
					Msg:    fmt.Sprintf("Error summarizing convo: %v", r),
				}
			}
		}()

		err := summarizeConvo(clients, authVars, settings, orgUserConfig, summarizeConvoParams{
			auth:                  auth,
			plan:                  plan,
			branch:                branch,
			convo:                 convo,
			summaries:             summaries,
			userPrompt:            state.userPrompt,
			currentOrgId:          currentOrgId,
			currentReply:          active.CurrentReplyContent,
			currentReplyNumTokens: active.NumTokens,
			modelPackName:         settings.GetModelPack().Name,
		}, active.SummaryCtx)

		if err != nil {
			log.Printf("Error summarizing convo: %v\n", err)
			active.StreamDoneCh <- err
		}
	}()

	log.Println("Sending active.CurrentReplyDoneCh <- true")

	active.CurrentReplyDoneCh <- true

	log.Println("Resetting active.CurrentReplyDoneCh")

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.CurrentStreamingReplyId = ""
		ap.CurrentReplyDoneCh = nil
	})

	autoLoadPaths := autoLoadContextResult.autoLoadPaths
	log.Printf("len(autoLoadPaths): %d\n", len(autoLoadPaths))
	if len(autoLoadPaths) > 0 {
		log.Println("Sending stream message to load context files")

		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic streaming auto-load context: %v\n%s", r, debug.Stack())
					go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic streaming auto-load context: %v\n%s", r, debug.Stack()))
				}
			}()

			active.Stream(shared.StreamMessage{
				Type:             shared.StreamMessageLoadContext,
				LoadContextFiles: autoLoadPaths,
			})
			active.FlushStreamBuffer()
		}()

		log.Println("Waiting for client to auto load context (30s timeout)")

		select {
		case <-active.Ctx.Done():
			log.Println("Context cancelled while waiting for auto load context")
			state.execHookOnStop(false)
			return handleStreamFinishedResult{
				shouldContinueMainLoop: false,
				shouldReturn:           true,
			}
		case <-time.After(30 * time.Second):
			log.Println("Timeout waiting for auto load context")
			res := state.onError(onErrorParams{
				streamErr: fmt.Errorf("timeout waiting for auto load context response"),
				storeDesc: true,
			})
			return handleStreamFinishedResult{
				shouldContinueMainLoop: res.shouldContinueMainLoop,
				shouldReturn:           res.shouldReturn,
			}
		case <-active.AutoLoadContextCh:
		}
	}

	willContinue := state.willContinuePlan(willContinuePlanParams{
		hasNewSubtasks:      hasExplicitTasks,
		allSubtasksFinished: allSubtasksFinished,
		activatePaths:       autoLoadContextResult.activatePaths,
		removedSubtasks:     hasExplicitRemoveTasks,
		hasExplicitPaths:    autoLoadContextResult.hasExplicitPaths,
	})

	if willContinue {
		log.Println("Auto continue plan")
		// continue plan
		execTellPlan(execTellPlanParams{
			clients:   clients,
			plan:      plan,
			branch:    branch,
			auth:      auth,
			req:       req,
			iteration: iteration + 1,
			authVars:  authVars,
		})
	} else {
		var buildFinished bool
		UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
			buildFinished = ap.BuildFinished()
			ap.RepliesFinished = true
		})

		log.Printf("Won't continue plan. Build finished: %v\n", buildFinished)

		time.Sleep(50 * time.Millisecond)

		if buildFinished {
			log.Println("Reply is finished and build is finished, calling active.Finish()")
			active := GetActivePlan(planId, branch)

			if active == nil {
				state.onActivePlanMissingError()
				return handleStreamFinishedResult{
					shouldContinueMainLoop: true,
					shouldReturn:           false,
				}
			}

			active.Finish()
		} else {
			log.Println("Plan is still building")
			log.Println("Updating status to building")
			err := db.SetPlanStatus(planId, branch, shared.PlanStatusBuilding, "")
			if err != nil {
				log.Printf("Error setting plan status to building: %v\n", err)
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error setting plan status to building: %v", err))

				active.StreamDoneCh <- &shared.ApiError{
					Type:   shared.ApiErrorTypeOther,
					Status: http.StatusInternalServerError,
					Msg:    fmt.Sprintf("Error setting plan status to building: %v", err),
				}

				return handleStreamFinishedResult{
					shouldContinueMainLoop: true,
					shouldReturn:           false,
				}
			}

			log.Println("Sending RepliesFinished stream message")
			active.Stream(shared.StreamMessage{
				Type: shared.StreamMessageRepliesFinished,
			})

		}
	}

	return handleStreamFinishedResult{}
}


================================================
FILE: app/server/model/plan/tell_stream_main.go
================================================
package plan

import (
	"errors"
	"fmt"
	"log"
	"net/http"
	"plandex-server/model"
	"plandex-server/notify"
	"plandex-server/types"
	"runtime/debug"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
)

func (state *activeTellStreamState) listenStream(stream *model.ExtendedChatCompletionStream) {
	defer stream.Close()

	plan := state.plan
	planId := plan.Id
	branch := state.branch

	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf("listenStream - Active plan not found for plan ID %s on branch %s\n", planId, branch)
		return
	}

	defer func() {
		if r := recover(); r != nil {
			log.Printf("listenStream: Panic: %v\n%s\n", r, string(debug.Stack()))

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("listenStream: Panic: %v\n%s", r, string(debug.Stack())))

			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Panic in listenStream",
			}
		}
	}()

	state.chunkProcessor = &chunkProcessor{
		replyOperations:                 []*shared.Operation{},
		chunksReceived:                  0,
		maybeRedundantOpeningTagContent: "",
		fileOpen:                        false,
		contentBuffer:                   "",
		awaitingBlockOpeningTag:         false,
		awaitingBlockClosingTag:         false,
		awaitingBackticks:               false,
	}

	// Create a timer that will trigger if no chunk is received within the specified duration
	firstTokenTimeout := firstTokenTimeout(state.totalRequestTokens, state.baseModelConfig.LocalOnly)
	log.Printf("listenStream - firstTokenTimeout: %s\n", firstTokenTimeout)
	timer := time.NewTimer(firstTokenTimeout)
	defer timer.Stop()
	streamFinished := false

	baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)

	modelProvider := baseModelConfig.Provider
	modelName := baseModelConfig.ModelName

	respCh := make(chan *types.ExtendedChatCompletionStreamResponse)
	streamErrCh := make(chan error)

	// receive chunks from the stream in a separate goroutine so that we can handle errors and timeouts — needed because stream.Recv() blocks forever
	go func() {
		for {
			resp, err := stream.Recv()
			if err != nil {
				streamErrCh <- err
				return
			}
			respCh <- resp
		}
	}()

mainLoop:
	for {
		select {
		case <-active.Ctx.Done():
			// The main modelContext was canceled (not the timer)
			log.Println("\nTell: stream canceled")
			state.execHookOnStop(false)
			return
		case <-timer.C:
			// Timer triggered because no new chunk was received in time
			log.Println("\nTell: stream timeout due to inactivity")
			if streamFinished {
				log.Println("Tell stream finished—timed out waiting for usage chunk")
				state.execHookOnStop(false)
				return
			} else {
				res := state.onError(onErrorParams{
					streamErr: fmt.Errorf("stream timeout due to inactivity: The AI model (%s/%s) is not responding", modelProvider, modelName),
					storeDesc: true,
					canRetry:  active.CurrentReplyContent == "", // if there was no output yet, we can retry
				})

				if res.shouldReturn {
					return
				}
				if res.shouldContinueMainLoop {
					continue mainLoop
				}
			}

		case err := <-streamErrCh:
			log.Printf("listenStream - received from streamErrCh: %v\n", err)

			if err.Error() == "context canceled" {
				log.Println("Tell: stream context canceled")
				state.execHookOnStop(false)
				return
			}

			log.Printf("Tell: error receiving stream chunk: %v\n", err)
			state.execHookOnStop(true)

			var msg string
			name := modelName
			if !strings.Contains(string(modelName), string(modelProvider)) {
				name = shared.ModelName(fmt.Sprintf("%s/%s", modelProvider, modelName))
			}
			if active.CurrentReplyContent == "" {
				msg = fmt.Sprintf("The AI model (%s) didn't respond: %v", name, err)
			} else {
				msg = fmt.Sprintf("The AI model (%s) stopped responding: %v", name, err)
			}
			state.onError(onErrorParams{
				streamErr: errors.New(msg),
				storeDesc: true,
				canRetry:  active.CurrentReplyContent == "", // if there was no output yet, we can retry
			})
			// here we want to return no matter what -- state.onError will decide whether to retry or not
			return
		case response := <-respCh:
			// Successfully received a chunk, reset the timer
			if !timer.Stop() {
				<-timer.C
			}
			timer.Reset(model.ACTIVE_STREAM_CHUNK_TIMEOUT)

			// log.Println("tell stream main: received stream response", spew.Sdump(response))

			if response.ID != "" && state.generationId == "" {
				state.generationId = response.ID
			}

			if state.firstTokenAt.IsZero() {
				state.firstTokenAt = time.Now()
			}

			if response.Error != nil {
				log.Println("listenStream - stream finished with error", spew.Sdump(response.Error))

				baseModelConfig := state.fallbackRes.BaseModelConfig
				modelErr := model.ClassifyModelError(response.Error.Code, response.Error.Message, nil, baseModelConfig.HasClaudeMaxAuth)

				res := state.onError(onErrorParams{
					streamErr: fmt.Errorf("The AI model (%s/%s) stopped streaming with error code %d: %s", modelProvider, modelName, response.Error.Code, response.Error.Message),
					storeDesc: true,
					canRetry:  active.CurrentReplyContent == "",
					modelErr:  &modelErr,
				})
				if res.shouldReturn {
					return
				}
				if res.shouldContinueMainLoop {
					continue mainLoop
				}
			}

			if len(response.Choices) == 0 {
				if response.Usage != nil {
					state.handleUsageChunk(response.Usage)
					return
				}

				log.Println("listenStream - stream finished with no choices", spew.Sdump(response))

				// Previously we'd return an error if there were no choices, but some models do this and then keep streaming, so we'll just log it and continue, waiting for an EOF if there's a problem
				// res := state.onError(onErrorParams{
				// 	streamErr: fmt.Errorf("stream finished with no choices | The model failed to generate a valid response."),
				// 	storeDesc: true,
				// 	canRetry:  true,
				// })
				// if res.shouldReturn {
				// 	return
				// }
				// if res.shouldContinueMainLoop {
				// 	// continue instead of returning so that context cancellation is handled
				// 	continue mainLoop
				// }

				continue mainLoop
			}

			choice := response.Choices[0]

			processChunkRes := state.processChunk(choice)
			if processChunkRes.shouldReturn {
				return
			}

			handleFinished := func() handleStreamFinishedResult {
				streamFinishResult := state.handleStreamFinished()
				if streamFinishResult.shouldReturn || streamFinishResult.shouldContinueMainLoop {
					return streamFinishResult
				}

				// usage can either be included in the final chunk (openrouter) or in a separate chunk (openai)
				// if the usage chunk is included, handle it and then return out of listener
				// otherwise keep listening for the usage chunk
				if response.Usage != nil {
					state.handleUsageChunk(response.Usage)
					return handleStreamFinishedResult{
						shouldReturn: true,
					}
				}

				// Reset the timer for the usage chunk
				if !timer.Stop() {
					<-timer.C
				}
				timer.Reset(model.USAGE_CHUNK_TIMEOUT)
				streamFinished = true

				return handleStreamFinishedResult{
					shouldContinueMainLoop: true,
				}
			}

			if processChunkRes.shouldStop {
				log.Println("Model stream reached stop sequence")

				res := handleFinished()
				if res.shouldReturn {
					return
				}
				continue
			}

			if choice.FinishReason != "" {
				log.Println("Model stream finished")
				log.Println("Finish reason: ", choice.FinishReason)

				if choice.FinishReason == "error" {
					log.Println("Model stream finished with error")

					res := state.onError(onErrorParams{
						streamErr: fmt.Errorf("The AI model (%s/%s) stopped streaming with an error status", modelProvider, modelName),
						storeDesc: true,
						canRetry:  active.CurrentReplyContent == "",
					})
					if res.shouldReturn {
						return
					}
					if res.shouldContinueMainLoop {
						continue mainLoop
					}
				}

				res := handleFinished()
				if res.shouldReturn {
					return
				}
				continue
			} else if response.Usage != nil {
				state.handleUsageChunk(response.Usage)
				return
			}
			// let main loop continue
		}
	}
}

func firstTokenTimeout(tok int, isLocalModel bool) time.Duration {
	const (
		base  = 90 * time.Second
		slope = 90 * time.Second
		step  = 150_000
		cap   = 15 * time.Minute
	)

	// local models can have a long cold start, and timeouts are less relevant
	if isLocalModel {
		return cap
	}

	if tok <= step {
		return base
	}
	extra := time.Duration((tok-step)/step) * slope
	if extra > cap-base {
		extra = cap - base
	}
	return base + extra
}


================================================
FILE: app/server/model/plan/tell_stream_processor.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/types"
	"regexp"
	"runtime/debug"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
)

const verboseLogging = false

var openingTagRegex = regexp.MustCompile(`<PlandexBlock\s+lang="(.+?)"\s+path="(.+?)".*?>`)

type processChunkResult struct {
	shouldReturn bool
	shouldStop   bool
}

func (state *activeTellStreamState) processChunk(choice types.ExtendedChatCompletionStreamChoice) processChunkResult {
	req := state.req
	// missingFileResponse := state.missingFileResponse
	processor := state.chunkProcessor
	replyParser := state.replyParser
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	active := GetActivePlan(planId, branch)

	if active == nil {
		state.onActivePlanMissingError()
		return processChunkResult{}
	}

	defer func() {
		if r := recover(); r != nil {
			log.Printf("processChunk: Panic: %v\n%s\n", r, string(debug.Stack()))

			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("processChunk: Panic: %v\n%s", r, string(debug.Stack())))

			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    fmt.Sprintf("Panic in processChunk: %v\n%s", r, string(debug.Stack())),
			}
		}
	}()

	delta := choice.Delta
	content := delta.Content

	baseModelConfig := state.modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)

	if baseModelConfig.IncludeReasoning && !baseModelConfig.HideReasoning && delta.Reasoning != "" {
		content = delta.Reasoning
	}

	if content == "" {
		return processChunkResult{}
	}

	processor.chunksReceived++

	if verboseLogging {
		log.Printf("Adding chunk to parser: %s\n", content)
		log.Printf("fileOpen: %v\n", processor.fileOpen)
	}

	replyParser.AddChunk(content, true)
	parserRes := replyParser.Read()

	if !processor.fileOpen && parserRes.CurrentFilePath != "" {
		if verboseLogging {
			log.Printf("File open: %s\n", parserRes.CurrentFilePath)
		}
		processor.fileOpen = true
	}

	if processor.fileOpen && strings.HasSuffix(active.CurrentReplyContent+content, "</PlandexBlock>") {
		if verboseLogging {
			log.Println("FinishAndRead because of closing tag")
		}
		parserRes = replyParser.FinishAndRead()
		processor.fileOpen = false
	}

	if processor.fileOpen && parserRes.CurrentFilePath == "" {
		if verboseLogging {
			log.Println("File open but current file path is empty, closing file")
		}
		processor.fileOpen = false
	}

	operations := parserRes.Operations
	state.replyNumTokens = parserRes.TotalTokens
	currentFile := parserRes.CurrentFilePath

	// log.Printf("currentFile: %s\n", currentFile)
	// log.Println("files:")
	// spew.Dump(files)

	// Handle file that is present in project paths but not in context
	// Prompt user for what to do on the client side, stop the stream, and wait for user response before proceeding
	bufferOrStreamRes := processor.bufferOrStream(content, &parserRes, state.currentStage, state.manualStop)

	if currentFile != "" &&
		!req.IsChatOnly &&
		active.ContextsByPath[currentFile] == nil &&
		req.ProjectPaths[currentFile] &&
		!active.AllowOverwritePaths[currentFile] {
		return state.handleMissingFile(bufferOrStreamRes.content, currentFile, bufferOrStreamRes.blockLang)
	}

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.CurrentReplyContent += content
		ap.NumTokens++
	})

	if verboseLogging {
		log.Println("processor before bufferOrStream")
		spew.Dump(processor)
		log.Println("maybeFilePath", parserRes.MaybeFilePath)
		log.Println("currentFilePath", parserRes.CurrentFilePath)
		log.Println("bufferOrStreamRes")
		spew.Dump(bufferOrStreamRes)
	}

	if bufferOrStreamRes.shouldStream {
		active.Stream(shared.StreamMessage{
			Type:       shared.StreamMessageReply,
			ReplyChunk: bufferOrStreamRes.content,
		})
	}

	if verboseLogging {
		log.Println("processor after bufferOrStream")
		spew.Dump(processor)
	}

	if !req.IsChatOnly && len(operations) > len(processor.replyOperations) {
		state.handleNewOperations(&parserRes)
	}

	return processChunkResult{
		shouldStop: bufferOrStreamRes.shouldStop,
	}
}

type bufferOrStreamResult struct {
	shouldStream bool
	content      string
	blockLang    string
	shouldStop   bool
}

func (processor *chunkProcessor) bufferOrStream(content string, parserRes *types.ReplyParserRes, currentStage shared.CurrentStage, manualStopSequences []string) bufferOrStreamResult {
	if len(manualStopSequences) > 0 {
		for _, stopSequence := range manualStopSequences {

			// if the chunk contains the entire stop sequence, stream everything before it then caller can stop the stream
			if strings.Contains(content, stopSequence) {
				split := strings.Split(content, stopSequence)
				if len(split) > 1 {
					return bufferOrStreamResult{
						shouldStream: true,
						content:      split[0],
						shouldStop:   true,
					}
				} else {
					// there was nothing before the stop sequence, so nothing to stream
					return bufferOrStreamResult{
						shouldStream: false,
						shouldStop:   true,
					}
				}
			}

			// otherwise if the buffer plus chunk contains the stop sequence, don't stream anything and stop the stream
			if strings.Contains(processor.contentBuffer+content, stopSequence) {
				log.Printf("bufferOrStream - stop sequence found in buffer plus chunk\n")
				split := strings.Split(content, stopSequence)
				if len(split) > 1 {
					// we'll stream the part before the stop sequence
					return bufferOrStreamResult{
						shouldStream: true,
						content:      split[0],
						shouldStop:   true,
					}
				} else {
					// there was nothing before the stop sequence, so nothing to stream
					return bufferOrStreamResult{
						shouldStream: false,
						shouldStop:   true,
					}
				}
			}

			// otherwise if the buffer plus chunk ends with a prefix of the stop sequence, buffer it and continue

			toCheck := processor.contentBuffer + content
			tailLen := len(stopSequence) - 1
			if tailLen > len(toCheck) {
				tailLen = len(toCheck)
			}
			suffix := toCheck[len(toCheck)-tailLen:]

			if strings.HasPrefix(stopSequence, suffix) {
				log.Printf("bufferOrStream - stop sequence prefix found in buffer plus chunk. buffer and continue\n")
				processor.contentBuffer += content
				return bufferOrStreamResult{
					shouldStream: false,
					content:      content,
				}
			}

		}
	}

	// apart from manual stop sequences, no buffering in planning stages
	if currentStage.TellStage == shared.TellStagePlanning {
		return bufferOrStreamResult{
			shouldStream: true,
			content:      content,
		}
	}

	var shouldStream bool
	var blockLang string

	awaitingTag := processor.awaitingBlockOpeningTag || processor.awaitingBlockClosingTag || processor.awaitingOpClosingTag
	awaitingAny := awaitingTag || processor.awaitingBackticks

	if awaitingAny {
		if verboseLogging {
			log.Println("awaitingAny")
		}
		processor.contentBuffer += content
		content = processor.contentBuffer

		if verboseLogging {
			log.Printf("awaitingBlockOpeningTag: %v\n", processor.awaitingBlockOpeningTag)
			log.Printf("awaitingBlockClosingTag: %v\n", processor.awaitingBlockClosingTag)
			log.Printf("awaitingBackticks: %v\n", processor.awaitingBackticks)
			log.Printf("awaitingOpClosingTag: %v\n", processor.awaitingOpClosingTag)
			log.Printf("content: %q\n", content)
		}
	}

	if processor.awaitingBackticks {
		if strings.Contains(content, "```") {
			processor.awaitingBackticks = false
			content = strings.ReplaceAll(content, "```", "\\`\\`\\`")

			if !(processor.awaitingBlockOpeningTag || processor.awaitingBlockClosingTag) {
				shouldStream = true
			}
		} else if !strings.HasSuffix(content, "`") {
			// fewer than 3 backticks, no need to escape
			processor.awaitingBackticks = false

			if !(processor.awaitingBlockOpeningTag || processor.awaitingBlockClosingTag) {
				shouldStream = true
			}
		}
	}

	if awaitingTag {
		if verboseLogging {
			log.Println("awaitingTag")
		}
		if processor.awaitingBlockOpeningTag {
			if verboseLogging {
				log.Println("processor.awaitingBlockOpeningTag")
			}
			var matchedPrefix bool

			if parserRes.CurrentFilePath != "" {
				matched, replaced := replaceCodeBlockOpeningTag(content, func(lang string) string {
					blockLang = lang
					return "```" + lang
				})

				if matched {
					shouldStream = true
					processor.awaitingBlockOpeningTag = false
					processor.fileOpen = true
					content = replaced
				} else {
					// tag is missing - something is wrong - we shouldn't be here but let's try to recover anyway
					if verboseLogging {
						log.Printf("Opening <PlandexBlock> tag is missing even though parserRes.CurrentFile is set - something is wrong: %s\n", content)
					}
					processor.awaitingBlockOpeningTag = false
					processor.fileOpen = false
					content += "\n```" // add ``` to the end of the line to close the markdown code block
					shouldStream = true
				}
			} else {
				split := strings.Split(content, "<")

				if len(split) > 1 {
					last := split[len(split)-1]
					if verboseLogging {
						log.Printf("last: %s\n", last)
					}
					if strings.HasPrefix(`PlandexBlock lang="`, last) {
						if verboseLogging {
							log.Println("strings.HasPrefix(`PlandexBlock lang=", last)
						}
						shouldStream = false
						matchedPrefix = true
					} else if strings.HasPrefix(last, `PlandexBlock lang="`) {
						if verboseLogging {
							log.Println("partialOpeningTagRegex.MatchString(last)")
						}
						shouldStream = false
						matchedPrefix = true
					} else {
						if verboseLogging {
							log.Println("partialOpeningTagRegex.MatchString(last) is false")
						}
					}
				}
			}

			if !matchedPrefix && parserRes.MaybeFilePath == "" && parserRes.CurrentFilePath == "" {
				// wasn't really a file path / code block
				processor.awaitingBlockOpeningTag = false
				shouldStream = true
			}
		} else if processor.awaitingBlockClosingTag {
			if parserRes.CurrentFilePath == "" {
				if strings.Contains(content, "</PlandexBlock>") {
					shouldStream = true
					processor.awaitingBlockClosingTag = false
					processor.fileOpen = false
					// replace </PlandexBlock> with ``` to close the markdown code block
					content = strings.ReplaceAll(content, "</PlandexBlock>", "```")
				} else {
					log.Printf("Closing </PlandexBlock> tag is missing even though parserRes.CurrentOperation is nil - something is wrong: %s\n", content)
					processor.awaitingBlockClosingTag = false
					shouldStream = true
				}
			}
		} else if processor.awaitingOpClosingTag {
			if verboseLogging {
				log.Printf("awaitingOpClosingTag: %v\n", processor.awaitingOpClosingTag)
			}
			if strings.Contains(content, "<EndPlandexFileOps/>") {
				if verboseLogging {
					log.Printf("Found <EndPlandexFileOps/>\n")
				}
				processor.awaitingOpClosingTag = false
				content = strings.Replace(content, "\n<EndPlandexFileOps/>", "", 1)
				content = strings.Replace(content, "<EndPlandexFileOps/>", "", 1)
				shouldStream = true
			}
		}

	} else {
		if verboseLogging {
			log.Println("not awaiting tag")
		}

		if parserRes.MaybeFilePath != "" && parserRes.CurrentFilePath == "" {
			processor.awaitingBlockOpeningTag = true
		} else {
			// this will set processor.awaitingBlockOpeningTag to true if the content starts with any prefix of<PlandexBlock lang=" *or* any prefix of a full opening tag
			// if the full tag is in the content, it will later get set to false again when the full tag is handled
			split := strings.Split(content, "<")
			if len(split) > 1 {
				last := split[len(split)-1]

				if strings.HasPrefix(`PlandexBlock lang="`, last) {
					processor.awaitingBlockOpeningTag = true
				} else if strings.HasPrefix(last, `PlandexBlock lang="`) {
					processor.awaitingBlockOpeningTag = true
				}
			}
		}

		if parserRes.CurrentFilePath != "" {
			if verboseLogging {
				log.Println("parserRes.CurrentFilePath != \"\"")
			}
			if strings.Contains(content, "</PlandexBlock>") {
				if verboseLogging {
					log.Println("strings.Contains(content, \"</PlandexBlock>\")")
				}
				processor.awaitingBlockClosingTag = true
			} else {
				if verboseLogging {
					log.Println("not strings.Contains(content, \"</PlandexBlock>\")")
				}
				split := strings.Split(content, "<")
				// log.Printf("split: %v\n", split)
				if len(split) > 1 {
					if verboseLogging {
						log.Println("len(split) > 1")
					}
					last := split[len(split)-1]
					// log.Printf("last: %s\n", last)
					if strings.HasPrefix("/PlandexBlock>", last) {
						if verboseLogging {
							log.Println("strings.HasPrefix(\"/PlandexBlock>\", last)")
						}
						processor.awaitingBlockClosingTag = true
					}
				}
			}
		} else if parserRes.FileOperationBlockOpen() {
			if verboseLogging {
				log.Println("parserRes.FileOperationBlockOpen()")
			}
			if strings.Contains(content, "<EndPlandexFileOps/>") {
				if verboseLogging {
					log.Println("strings.Contains(content, \"<EndPlandexFileOps/>\")")
				}
				processor.awaitingOpClosingTag = true
			} else {
				if verboseLogging {
					log.Println("not strings.Contains(content, \"<EndPlandexFileOps/>\")")
				}
				split := strings.Split(content, "<")
				if len(split) > 1 {
					if verboseLogging {
						log.Println("len(split) > 1")
					}
					last := split[len(split)-1]
					if strings.HasPrefix("EndPlandexFileOps/>", last) {
						if verboseLogging {
							log.Println("strings.HasPrefix(\"EndPlandexFileOps/>\", last)")
						}
						processor.awaitingOpClosingTag = true
					}
				}
			}
		} else if strings.Contains(content, "</PlandexBlock>") {
			if verboseLogging {
				log.Println("strings.Contains(content, \"</PlandexBlock>\")")
			}
			content = strings.Replace(content, "</PlandexBlock>", "```", 1)
		} else if strings.Contains(content, "<EndPlandexFileOps/>") {
			if verboseLogging {
				log.Println("strings.Contains(content, \"<EndPlandexFileOps/>\")")
			}
			content = strings.Replace(content, "\n<EndPlandexFileOps/>", "", 1)
			content = strings.Replace(content, "<EndPlandexFileOps/>", "", 1)
		}

		if processor.fileOpen && (strings.Contains(content, "```") || strings.HasSuffix(content, "`")) {
			if verboseLogging {
				log.Println("processor.fileOpen && (strings.Contains(content, \"```\") || strings.HasSuffix(content, \"`\"))")
			}
			processor.awaitingBackticks = true
		}

		var matchedOpeningTag bool
		if processor.fileOpen {
			if verboseLogging {
				log.Println("processor.fileOpen")
			}
			var replaced string

			matchedOpeningTag, replaced = replaceCodeBlockOpeningTag(content, func(lang string) string {
				blockLang = lang
				return "```" + lang
			})

			if verboseLogging {
				log.Println("matchedOpeningTag", matchedOpeningTag)
				log.Println("replaced", replaced)
			}

			if matchedOpeningTag {
				processor.awaitingBlockOpeningTag = false
				content = replaced
			}
		}

		shouldStream = !processor.awaitingBlockOpeningTag && !processor.awaitingBlockClosingTag && !processor.awaitingOpClosingTag && !processor.awaitingBackticks

		if verboseLogging {
			log.Println("processor.awaitingBlockOpeningTag", processor.awaitingBlockOpeningTag)
			log.Println("processor.awaitingBlockClosingTag", processor.awaitingBlockClosingTag)
			log.Println("processor.awaitingOpClosingTag", processor.awaitingOpClosingTag)
			log.Println("processor.awaitingBackticks", processor.awaitingBackticks)

			log.Println("shouldStream", shouldStream)
		}
	}

	if verboseLogging {
		log.Println("returning bufferOrStreamResult")
		log.Println("shouldStream", shouldStream)
		log.Println("content", content)
		log.Println("blockLang", blockLang)
	}

	if shouldStream {
		processor.contentBuffer = ""
	} else {
		processor.contentBuffer = content
	}

	return bufferOrStreamResult{
		shouldStream: shouldStream,
		content:      content,
		blockLang:    blockLang,
	}
}

func (state *activeTellStreamState) handleNewOperations(parserRes *types.ReplyParserRes) {
	processor := state.chunkProcessor
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	clients := state.clients
	auth := state.auth
	authVars := state.authVars
	req := state.req
	replyId := state.replyId
	currentOrgId := state.currentOrgId
	currentUserId := state.currentUserId
	settings := state.settings

	operations := parserRes.Operations

	log.Printf("%d new operations\n", len(operations)-len(processor.replyOperations))

	for i, op := range operations {
		if i < len(processor.replyOperations) {
			continue
		}

		log.Printf("Detected operation: %s\n", op.Name())

		if req.BuildMode == shared.BuildModeAuto {
			log.Printf("Queuing build for %s\n", op.Name())
			// log.Println("Content:")
			// log.Println(strconv.Quote(op.Content))

			buildState := &activeBuildStreamState{
				modelStreamId: state.modelStreamId,
				clients:       clients,
				authVars:      authVars,
				auth:          auth,
				currentOrgId:  currentOrgId,
				currentUserId: currentUserId,
				plan:          plan,
				branch:        branch,
				settings:      settings,
				modelContext:  state.modelContext,
				orgUserConfig: state.orgUserConfig,
			}

			var opContentTokens int
			if op.Type == shared.OperationTypeFile {
				opContentTokens = shared.GetNumTokensEstimate(op.Content)
			} else {
				opContentTokens = op.NumTokens
			}

			// log.Printf("buildState.queueBuilds - op.Description:\n%s\n", op.Description)

			buildState.queueBuilds([]*types.ActiveBuild{{
				ReplyId:           replyId,
				FileDescription:   op.Description,
				FileContent:       op.Content,
				FileContentTokens: opContentTokens,
				Path:              op.Path,
				MoveDestination:   op.Destination,
				IsMoveOp:          op.Type == shared.OperationTypeMove,
				IsRemoveOp:        op.Type == shared.OperationTypeRemove,
				IsResetOp:         op.Type == shared.OperationTypeReset,
			}})
		}
		processor.replyOperations = append(processor.replyOperations, op)
		UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
			ap.Operations = append(ap.Operations, op)
		})
	}

}

func (state *activeTellStreamState) handleMissingFile(content, currentFile, blockLang string) processChunkResult {
	branch := state.branch
	plan := state.plan
	planId := plan.Id
	replyParser := state.replyParser
	iteration := state.iteration
	clients := state.clients
	auth := state.auth
	req := state.req
	authVars := state.authVars

	active := GetActivePlan(planId, branch)

	if active == nil {
		state.onActivePlanMissingError()
		return processChunkResult{}
	}

	log.Printf("Attempting to overwrite a file that isn't in context: %s\n", currentFile)

	// attempting to overwrite a file that isn't in context
	// we will stop the stream and ask the user what to do
	err := db.SetPlanStatus(planId, branch, shared.PlanStatusMissingFile, "")

	if err != nil {
		log.Printf("Error setting plan %s status to prompting: %v\n", planId, err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error setting plan %s status to prompting: %v", planId, err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error setting plan status to prompting: %v", err),
		}
		return processChunkResult{}
	}

	var trimmedReply string

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.MissingFilePath = currentFile
		trimmedReply = replyParser.GetReplyForMissingFile()
		ap.CurrentReplyContent = trimmedReply
	})

	// log.Println("Content:")
	// log.Println(content)

	// log.Println("Block lang:")
	// log.Println(blockLang)

	// log.Println("Trimmed content:")
	// log.Println(trimmedReply)

	// try to replace the code block opening tag in the chunk with an empty string
	// this will remove the code block opening tag if it exists
	splitBy := "```" + blockLang
	split := strings.Split(content, splitBy)
	chunkToStream := split[0] + splitBy + "\n"

	// log.Printf("chunkToStream: %s\n", chunkToStream)

	if chunkToStream != "" {
		log.Printf("Streaming remaining chunk before missing file prompt: %s\n", chunkToStream)
		active.Stream(shared.StreamMessage{
			Type:       shared.StreamMessageReply,
			ReplyChunk: chunkToStream,
		})
		active.FlushStreamBuffer()
		time.Sleep(20 * time.Millisecond)
	}

	log.Printf("Prompting user for missing file: %s\n", currentFile)

	active.Stream(shared.StreamMessage{
		Type:                   shared.StreamMessagePromptMissingFile,
		MissingFilePath:        currentFile,
		MissingFileAutoContext: active.AutoContext,
	})

	log.Printf("Stopping stream for missing file: %s\n", currentFile)
	// log.Printf("Chunk content: %s\n", content)
	// log.Printf("Current reply content: %s\n", active.CurrentReplyContent)

	// stop stream for now
	active.CancelModelStreamFn()

	log.Printf("Stopped stream for missing file: %s\n", currentFile)

	// wait for user response to come in
	var userChoice shared.RespondMissingFileChoice
	select {
	case <-active.Ctx.Done():
		log.Println("Context cancelled while waiting for missing file response")
		state.execHookOnStop(false)
		return processChunkResult{shouldReturn: true}

	case <-time.After(30 * time.Minute): // long timeout here since we're waiting for user input
		log.Println("Timeout waiting for missing file choice")
		state.onError(onErrorParams{
			streamErr: fmt.Errorf("timeout waiting for missing file choice"),
			storeDesc: true,
		})
		return processChunkResult{}

	case userChoice = <-active.MissingFileResponseCh:
	}

	log.Printf("User choice for missing file: %s\n", userChoice)

	active.ResetModelCtx()

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.MissingFilePath = ""
		ap.CurrentReplyContent = replyParser.GetReplyForMissingFile()
	})

	log.Println("Continuing stream")

	// continue plan
	execTellPlan(execTellPlanParams{
		clients:             clients,
		plan:                plan,
		branch:              branch,
		auth:                auth,
		req:                 req,
		iteration:           iteration, // keep the same iteration
		missingFileResponse: userChoice,
		authVars:            authVars,
	})

	return processChunkResult{shouldReturn: true}
}

func getCroppedChunk(uncropped, cropped, chunk string) string {
	uncroppedIdx := strings.Index(uncropped, chunk)
	if uncroppedIdx == -1 {
		return ""
	}
	croppedChunk := cropped[uncroppedIdx:]
	return croppedChunk
}

func replaceCodeBlockOpeningTag(content string, replaceWithFn func(lang string) string) (bool, string) {
	// check for opening tag matching <PlandexBlock lang="..." path="...">
	match := openingTagRegex.FindStringSubmatch(content)

	if match != nil {
		// Found complete opening tag with lang and path attributes
		lang := match[1] // Extract the language from the first capture group
		return true, strings.Replace(content, match[0], replaceWithFn(lang), 1)
	} else if strings.Contains(content, "<PlandexBlock>") {
		// This is a fallback case that should probably be removed since we now require both attributes
		return true, strings.Replace(content, "<PlandexBlock>", replaceWithFn(""), 1)
	}

	return false, ""
}


================================================
FILE: app/server/model/plan/tell_stream_processor_test.go
================================================
package plan

import (
	"plandex-server/types"
	shared "plandex-shared"
	"testing"
)

func TestBufferOrStream(t *testing.T) {
	tests := []struct {
		only            bool
		name            string
		initialState    *chunkProcessor
		chunk           string
		maybeFilePath   string
		currentFilePath string
		isInMoveBlock   bool
		isInRemoveBlock bool
		isInResetBlock  bool
		want            bufferOrStreamResult
		wantState       *chunkProcessor // To verify state transitions
		manualStop      []string
	}{
		{
			name: "streams regular content",
			initialState: &chunkProcessor{
				contentBuffer: "",
			},
			chunk: "some regular text",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "some regular text",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                false,
			},
		},
		{
			name: "buffers partial opening tag",
			initialState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
				fileOpen:                false,
				contentBuffer:           "",
			},
			chunk:           `<Pland`,
			maybeFilePath:   "main.go",
			currentFilePath: "",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                false,
				contentBuffer:           "<Pland",
			},
		},
		{
			name: "converts opening tag",
			initialState: &chunkProcessor{
				fileOpen:                true,
				contentBuffer:           `<PlandexBlock lang="go" path="main.go">` + "\n",
				awaitingBlockOpeningTag: true,
			},
			chunk:           `package`,
			maybeFilePath:   "",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "```go\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                true,
			},
		},
		{
			// occurs when replayParser can't identify a 'maybeFilePath' prior a full opening tag being sent ('maybeFilePath' gets skipped and 'currentFilePath' is set immediately)
			name: "converts opening tag without awaitingOpeningTag",
			initialState: &chunkProcessor{
				fileOpen:                true,
				contentBuffer:           "",
				awaitingBlockOpeningTag: false,
			},
			chunk:           `<PlandexBlock lang="go" path="main.go">` + "\npackage",
			maybeFilePath:   "",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "```go\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                true,
			},
		},
		{
			name: "buffers partial backticks",
			initialState: &chunkProcessor{
				fileOpen:      true,
				contentBuffer: "here's some co",
			},
			chunk:           "de:`",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBackticks: true,
				fileOpen:          true,
			},
		},
		{
			name: "escapes backticks in content",
			initialState: &chunkProcessor{
				fileOpen:          true,
				awaitingBackticks: true,
				contentBuffer:     "here's some code:\n`",
			},
			chunk:           "``\npackage",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "here's some code:\n\\`\\`\\`\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                true,
			},
		},
		{
			name: "buffers partial closing tag",
			initialState: &chunkProcessor{
				fileOpen:                true,
				awaitingBlockClosingTag: false,
				contentBuffer:           "",
			},
			currentFilePath: "main.go",
			chunk:           "\n}</Plan",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockClosingTag: true,
				fileOpen:                true,
				contentBuffer:           "\n}</Plan",
			},
		},
		{
			name: "buffers full closing tag with file open",
			initialState: &chunkProcessor{
				fileOpen:                true,
				awaitingBlockClosingTag: false,
				contentBuffer:           "",
			},
			currentFilePath: "main.go",
			chunk:           "\n}</PlandexBlock>",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockClosingTag: true,
				fileOpen:                true,
				contentBuffer:           "\n}</PlandexBlock>",
			},
		},
		{
			name: "replaces full closing tag with file closed",
			initialState: &chunkProcessor{
				fileOpen:                false,
				awaitingBlockClosingTag: false,
				contentBuffer:           "",
			},
			currentFilePath: "",
			chunk:           "\n}</PlandexBlock>",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "\n}```",
			},
			wantState: &chunkProcessor{
				awaitingBlockClosingTag: false,
				fileOpen:                false,
			},
		},
		{
			name: "replaces full closing tag with file closed and awaiting backticks",
			initialState: &chunkProcessor{
				fileOpen:                false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       true,
				contentBuffer:           "",
			},
			currentFilePath: "",
			chunk:           " ONLY this one-line title and nothing else.`\n</PlandexBlock>\n\nNow let",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      " ONLY this one-line title and nothing else.`\n```\n\nNow let",
			},
			wantState: &chunkProcessor{
				awaitingBlockClosingTag: false,
				fileOpen:                false,
			},
		},
		{
			name: "handles single backticks",
			initialState: &chunkProcessor{
				fileOpen:          true,
				awaitingBackticks: true,
				contentBuffer:     "`file.go`",
			},
			chunk:           "\nsomething",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "`file.go`\nsomething",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       false,
				fileOpen:                true,
			},
		},
		{
			name: "handles close and re-open backticks",
			initialState: &chunkProcessor{
				fileOpen:          true,
				awaitingBackticks: true,
				contentBuffer:     "`file.go`",
			},
			chunk:           "\n`file2.go`",
			currentFilePath: "main.go",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				awaitingBlockClosingTag: false,
				awaitingBackticks:       true,
				fileOpen:                true,
				contentBuffer:           "`file.go`\n`file2.go`",
			},
		},
		{
			name:          "buffers for end of file operations",
			initialState:  &chunkProcessor{},
			isInMoveBlock: true,
			chunk:         "\n<EndPlandexFileOps/>\nmore",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingOpClosingTag: true,
				contentBuffer:        "\n<EndPlandexFileOps/>\nmore",
			},
		},
		{
			name: "replaces full end of file operations tag",
			initialState: &chunkProcessor{
				awaitingOpClosingTag: true,
				contentBuffer:        "\n<EndPlandexFileOps/>\nmore",
			},
			chunk: " stuff",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "\nmore stuff",
			},
			wantState: &chunkProcessor{
				awaitingOpClosingTag: false,
			},
		},
		{
			name: "buffers for end of file operations with partial tag",
			initialState: &chunkProcessor{
				awaitingOpClosingTag: true,
			},
			chunk: "\n<EndPlandex",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingOpClosingTag: true,
				contentBuffer:        "\n<EndPlandex",
			},
		},
		{
			name: "replaces end of file operation closing partial tag",
			initialState: &chunkProcessor{
				awaitingOpClosingTag: true,
				contentBuffer:        "\n<EndPlandex",
			},
			chunk: "FileOps/>\nmore",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "\nmore",
			},
			wantState: &chunkProcessor{
				awaitingOpClosingTag: false,
			},
		},
		{
			name:         "buffers for partial opening tag with no file path label",
			initialState: &chunkProcessor{},
			chunk:        "something<Pland",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
			},
		},
		{
			name: "continues buffering partial opening tag with no file path label",
			initialState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
				contentBuffer:           "something<Pland",
			},
			chunk: "exBlock lang=\"go\" path=\"main",
			want: bufferOrStreamResult{
				shouldStream: false,
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
				contentBuffer:           "something<PlandexBlock lang=\"go\" path=\"main",
			},
		},
		{
			name: "replaces opening tag with no file path label when it completes",
			initialState: &chunkProcessor{
				awaitingBlockOpeningTag: true,
				contentBuffer:           "something\n<Pland",
				fileOpen:                true,
			},
			currentFilePath: "main.go",
			chunk:           "exBlock lang=\"go\" path=\"main.go\">\npackage",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "something\n```go\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				fileOpen:                true,
			},
		},
		{
			name: "replaces full opening tag without file path label",
			initialState: &chunkProcessor{
				fileOpen: true,
			},
			currentFilePath: "main.go",
			chunk:           "something\n<PlandexBlock lang=\"go\" path=\"main.go\">\npackage",
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "something\n```go\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				fileOpen:                true,
			},
		},

		{
			name:         "stop tag entirely in one chunk",
			initialState: &chunkProcessor{}, // empty buffer
			chunk:        "hello <PlandexFinish/>bye",
			manualStop:   []string{"<PlandexFinish/>"},
			want: bufferOrStreamResult{
				shouldStream: true,     // stream only the prefix
				content:      "hello ", // text before the tag
				shouldStop:   true,     // tell caller to stop
			},
			wantState: &chunkProcessor{
				contentBuffer: "", // nothing left buffered
			},
		},
		{
			name: "stop tag split across two chunks (prefix + rest)",
			only: true, // helper if you want to run just this one
			initialState: &chunkProcessor{
				contentBuffer: "", // begins empty
			},
			// FIRST CHUNK —— just a proper prefix
			chunk:      "<PlandexFin", // no '<' in second part
			manualStop: []string{"<PlandexFinish/>"},
			want: bufferOrStreamResult{
				shouldStream: false, // nothing streams yet
				shouldStop:   false, // not complete, keep going
			},
			wantState: &chunkProcessor{
				contentBuffer: "<PlandexFin", // prefix is buffered
			},
		},
		{
			// SECOND CHUNK —— completes the tag; nothing should stream
			name: "stop tag split across two chunks (completes)",
			initialState: &chunkProcessor{
				contentBuffer: "<PlandexFin", // leftover from previous call
			},
			chunk:      "ish/>\nmore text", // completes tag + trailing text
			manualStop: []string{"<PlandexFinish/>"},
			want: bufferOrStreamResult{
				shouldStream: false, // do NOT leak "more text"
				shouldStop:   true,  // signal caller to stop
			},
			wantState: &chunkProcessor{
				contentBuffer: "<PlandexFinish/>", // may keep full tag inside
			},
		},
		{
			name: "stop prefix turns out to be different tag, falls through to other parsing logic",
			initialState: &chunkProcessor{
				contentBuffer: "<Plandex",
			},
			chunk:      "Blo",
			manualStop: []string{"<PlandexFinish/>"},
			want: bufferOrStreamResult{
				shouldStream: false,
				shouldStop:   false,
			},
			wantState: &chunkProcessor{
				contentBuffer:           "<PlandexBlo",
				awaitingBlockOpeningTag: true,
			},
		},
		{
			name: "stop prefix turns out to be different tag, falls through to other parsing logic #2",
			initialState: &chunkProcessor{
				contentBuffer: "something\n<Plandex",
			},
			chunk:      "exBlock lang=\"go\" path=\"main.go\">\npackage",
			manualStop: []string{"<PlandexFinish/>"},
			want: bufferOrStreamResult{
				shouldStream: true,
				content:      "something\n```go\npackage",
			},
			wantState: &chunkProcessor{
				awaitingBlockOpeningTag: false,
				fileOpen:                true,
			},
		},
	}

	only := map[int]bool{}
	for i, tt := range tests {
		if tt.only {
			only[i] = true
		}
	}

	for i, tt := range tests {
		if len(only) > 0 && !only[i] {
			continue
		}

		t.Run(tt.name, func(t *testing.T) {
			processor := tt.initialState

			got := processor.bufferOrStream(tt.chunk, &types.ReplyParserRes{
				MaybeFilePath:   tt.maybeFilePath,
				CurrentFilePath: tt.currentFilePath,
				IsInMoveBlock:   tt.isInMoveBlock,
				IsInRemoveBlock: tt.isInRemoveBlock,
				IsInResetBlock:  tt.isInResetBlock,
			}, shared.CurrentStage{
				TellStage: shared.TellStageImplementation,
			}, tt.manualStop)

			if got.shouldStream != tt.want.shouldStream {
				t.Errorf("shouldStream = %v, want %v", got.shouldStream, tt.want.shouldStream)
			}
			if got.shouldStream && got.content != tt.want.content {
				t.Errorf("content = %q, want %q", got.content, tt.want.content)
			}

			// Check all state transitions
			if processor.fileOpen != tt.wantState.fileOpen {
				t.Errorf("fileOpen = %v, want %v", processor.fileOpen, tt.wantState.fileOpen)
			}
			if processor.awaitingBlockOpeningTag != tt.wantState.awaitingBlockOpeningTag {
				t.Errorf("awaitingOpeningTag = %v, want %v", processor.awaitingBlockOpeningTag, tt.wantState.awaitingBlockOpeningTag)
			}
			if processor.awaitingBlockClosingTag != tt.wantState.awaitingBlockClosingTag {
				t.Errorf("awaitingClosingTag = %v, want %v", processor.awaitingBlockClosingTag, tt.wantState.awaitingBlockClosingTag)
			}
			if processor.awaitingBackticks != tt.wantState.awaitingBackticks {
				t.Errorf("awaitingBackticks = %v, want %v", processor.awaitingBackticks, tt.wantState.awaitingBackticks)
			}

			if tt.wantState.contentBuffer != "" {
				if processor.contentBuffer != tt.wantState.contentBuffer {
					t.Errorf("content buffer = %q, want %q", processor.contentBuffer, tt.wantState.contentBuffer)
				}
			}

			// Check buffer is reset when it should be
			if tt.want.shouldStream && processor.contentBuffer != "" {
				t.Error("content buffer should be reset after streaming")
			}
		})
	}
}


================================================
FILE: app/server/model/plan/tell_stream_status.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	shared "plandex-shared"
	"runtime/debug"
)

type handleDescAndExecStatusResult struct {
	handleStreamFinishedResult
	subtaskFinished      bool
	generatedDescription *db.ConvoMessageDescription
}

func (state *activeTellStreamState) handleDescAndExecStatus() handleDescAndExecStatusResult {
	currentOrgId := state.currentOrgId
	summarizedToMessageId := state.summarizedToMessageId
	planId := state.plan.Id
	branch := state.branch
	replyOperations := state.chunkProcessor.replyOperations

	active := GetActivePlan(planId, branch)
	if active == nil {
		state.onActivePlanMissingError()
		return handleDescAndExecStatusResult{
			handleStreamFinishedResult: handleStreamFinishedResult{
				shouldContinueMainLoop: true,
				shouldReturn:           false,
			},
		}
	}

	var generatedDescription *db.ConvoMessageDescription
	var subtaskFinished bool

	var errCh = make(chan *shared.ApiError, 2)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in genPlanDescription: %v\n%s", r, debug.Stack())
				errCh <- &shared.ApiError{
					Type:   shared.ApiErrorTypeOther,
					Status: http.StatusInternalServerError,
					Msg:    fmt.Sprintf("Error generating plan description: %v", r),
				}
			}
		}()

		if len(replyOperations) > 0 {
			log.Println("Generating plan description")

			res, err := state.genPlanDescription()
			if err != nil {
				errCh <- err
				return
			}

			generatedDescription = res
			generatedDescription.OrgId = currentOrgId
			generatedDescription.SummarizedToMessageId = summarizedToMessageId
			generatedDescription.WroteFiles = true
			generatedDescription.Operations = replyOperations

			log.Println("Generated plan description.")
		}
		errCh <- nil
	}()

	if state.currentStage.TellStage == shared.TellStageImplementation {
		go func() {
			defer func() {
				if r := recover(); r != nil {
					log.Printf("panic in execStatusShouldContinue: %v\n%s", r, debug.Stack())
					errCh <- &shared.ApiError{
						Type:   shared.ApiErrorTypeOther,
						Status: http.StatusInternalServerError,
						Msg:    fmt.Sprintf("Error getting exec status: %v", r),
					}
				}
			}()

			log.Println("Getting exec status")
			var err *shared.ApiError
			res, err := state.execStatusShouldContinue(active.CurrentReplyContent, active.SessionId, active.Ctx)
			if err != nil {
				errCh <- err
				return
			}

			subtaskFinished = res.subtaskFinished

			log.Printf("subtaskFinished: %v\n", subtaskFinished)

			errCh <- nil
		}()

	} else {
		errCh <- nil
	}

	for i := 0; i < 2; i++ {
		err := <-errCh
		if err != nil {
			res := state.onError(onErrorParams{
				streamApiErr: err,
				storeDesc:    true,
			})
			return handleDescAndExecStatusResult{
				handleStreamFinishedResult: handleStreamFinishedResult{
					shouldContinueMainLoop: res.shouldContinueMainLoop,
					shouldReturn:           res.shouldReturn,
				},
				subtaskFinished:      subtaskFinished,
				generatedDescription: generatedDescription,
			}
		}
	}

	return handleDescAndExecStatusResult{
		handleStreamFinishedResult: handleStreamFinishedResult{},
		subtaskFinished:            subtaskFinished,
		generatedDescription:       generatedDescription,
	}
}

type willContinuePlanParams struct {
	hasNewSubtasks      bool
	removedSubtasks     bool
	allSubtasksFinished bool
	activatePaths       map[string]bool
	hasExplicitPaths    bool
}

func (state *activeTellStreamState) willContinuePlan(params willContinuePlanParams) bool {
	hasNewSubtasks := params.hasNewSubtasks
	removedSubtasks := params.removedSubtasks
	allSubtasksFinished := params.allSubtasksFinished
	activatePaths := params.activatePaths
	currentSubtask := state.currentSubtask

	log.Printf("[willContinuePlan] currentStage: %v", state.currentStage)

	log.Printf("[willContinuePlan] Initial state - hasNewSubtasks: %v, allSubtasksFinished: %v, tellStage: %v, planningPhase: %v, iteration: %d, autoContinue: %v",
		hasNewSubtasks, allSubtasksFinished, state.currentStage.TellStage, state.currentStage.PlanningPhase, state.iteration, state.req.AutoContinue)

	if state.currentStage.TellStage == shared.TellStagePlanning {
		log.Println("[willContinuePlan] In planning stage")

		// always continue to response or planning phase after context phase
		if state.currentStage.PlanningPhase == shared.PlanningPhaseContext {

			// if it's the context stage but it's chat mode and no files were loaded, don't continue
			if state.req.IsChatOnly && len(activatePaths) == 0 {
				log.Println("[willContinuePlan] Chat only - no files loaded - stopping")
				return false
			}

			// if no files were listed explicitly in a ### Files section, don't continue if it's chat mode
			if state.req.IsChatOnly && !params.hasExplicitPaths {
				log.Println("[willContinuePlan] Chat only - no files loaded - stopping")
				return false
			}

			log.Println("[willContinuePlan] In context phase - continuing to planning phase")
			return true
		}

		if state.req.IsChatOnly {
			log.Println("[willContinuePlan] Chat only - stopping")
			return false
		}

		// otherwise, if auto-continue is disabled, never continue
		if !state.req.AutoContinue {
			log.Println("[willContinuePlan] Auto-continue disabled - stopping")
			return false
		}

		// if there are new subtasks, continue
		if hasNewSubtasks && !allSubtasksFinished {
			log.Println("[willContinuePlan] Has new subtasks - continuing")
			return true
		}

		if removedSubtasks && !allSubtasksFinished {
			log.Println("[willContinuePlan] Removed subtasks - continuing")
			return true
		}

		// if all subtasks are finished, don't continue
		log.Printf("[willContinuePlan] Checking subtasks finished - allSubtasksFinished: %v, will continue: %v",
			allSubtasksFinished, !allSubtasksFinished)

		log.Printf("[willContinuePlan] currentSubtask: %v", currentSubtask)

		return !allSubtasksFinished && currentSubtask != nil

	} else if state.currentStage.TellStage == shared.TellStageImplementation {
		log.Println("[willContinuePlan] In implementation stage")

		// if all subtasks are finished, don't continue
		if allSubtasksFinished {
			log.Println("[willContinuePlan] All subtasks finished - stopping")
			return false
		}

		// if we've automatically continued too many times, don't continue
		if state.iteration >= MaxAutoContinueIterations {
			log.Printf("[willContinuePlan] Reached max iterations (%d) - stopping", MaxAutoContinueIterations)
			return false
		}

		// otherwise, continue with implementation
		log.Println("[willContinuePlan] Continuing implementation")
		return true
	}

	log.Printf("[willContinuePlan] Unknown tell stage: %v - won't continue", state.currentStage.TellStage)
	return false
}


================================================
FILE: app/server/model/plan/tell_stream_store.go
================================================
package plan

import (
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/types"
	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

type storeOnFinishedParams struct {
	replyOperations       []*shared.Operation
	generatedDescription  *db.ConvoMessageDescription
	subtaskFinished       bool
	hasNewSubtasks        bool
	autoLoadContextResult checkAutoLoadContextResult
	addedSubtasks         []*db.Subtask
	removedSubtasks       []string
}

type storeOnFinishedResult struct {
	handleStreamFinishedResult
	allSubtasksFinished bool
}

func (state *activeTellStreamState) storeOnFinished(params storeOnFinishedParams) storeOnFinishedResult {
	replyOperations := params.replyOperations
	generatedDescription := params.generatedDescription
	subtaskFinished := params.subtaskFinished
	hasNewSubtasks := params.hasNewSubtasks
	autoLoadContextResult := params.autoLoadContextResult
	currentOrgId := state.currentOrgId
	currentUserId := state.currentUserId
	planId := state.plan.Id
	branch := state.branch
	summarizedToMessageId := state.summarizedToMessageId
	active := state.activePlan
	addedSubtasks := params.addedSubtasks
	removedSubtasks := params.removedSubtasks
	var allSubtasksFinished bool

	log.Println("[storeOnFinished] Locking repo to store assistant reply and description")

	err := db.ExecRepoOperation(db.ExecRepoOperationParams{
		OrgId:    currentOrgId,
		UserId:   currentUserId,
		PlanId:   planId,
		Branch:   branch,
		Scope:    db.LockScopeWrite,
		Ctx:      active.Ctx,
		CancelFn: active.CancelFn,
		Reason:   "store on finished",
	}, func(repo *db.GitRepo) error {
		log.Println("storeOnFinished: hasNewSubtasks", hasNewSubtasks)
		log.Println("storeOnFinished: subtaskFinished", subtaskFinished)
		log.Println("storeOnFinished: removedSubtasks", removedSubtasks)

		messageSubtask := state.currentSubtask

		// first resolve subtask state
		if hasNewSubtasks || len(removedSubtasks) > 0 || subtaskFinished {
			if subtaskFinished && state.currentSubtask != nil {
				log.Printf("[storeOnFinished] Marking subtask as finished: %q", state.currentSubtask.Title)
				state.currentSubtask.IsFinished = true

				log.Printf("[storeOnFinished] Current subtask state after marking as finished: %+v", state.currentSubtask)
			}

			log.Printf("[storeOnFinished] Storing plan subtasks (hasNewSubtasks=%v, subtaskFinished=%v)", hasNewSubtasks, subtaskFinished)
			log.Printf("[storeOnFinished] Current subtasks state before storing:")
			for i, task := range state.subtasks {
				log.Printf("[storeOnFinished] Task %d: %q (finished=%v)", i+1, task.Title, task.IsFinished)
			}

			state.currentSubtask = nil
			allSubtasksFinished = true
			for _, subtask := range state.subtasks {
				if !subtask.IsFinished {
					state.currentSubtask = subtask
					allSubtasksFinished = false
					break
				}
			}

			if state.currentSubtask != nil {
				log.Printf("[storeOnFinished] Set new current subtask: %q", state.currentSubtask.Title)
			} else {
				log.Println("[storeOnFinished] No new current subtask set")
			}
			log.Printf("[storeOnFinished] All subtasks finished: %v", allSubtasksFinished)
		} else if state.currentSubtask != nil && !subtaskFinished {
			log.Printf("[storeOnFinished] Current subtask is not finished: %q", state.currentSubtask.Title)
			state.currentSubtask.NumTries++
		}

		log.Println("storeOnFinished: state.currentSubtask", state.currentSubtask)
		log.Println("storeOnFinished: state.subtasks", state.subtasks)
		log.Println("storeOnFinished: state.currentStage", state.currentStage)

		var flags shared.ConvoMessageFlags

		flags.CurrentStage = state.currentStage

		if len(replyOperations) > 0 {
			flags.DidWriteCode = true
		}
		if hasNewSubtasks {
			log.Println("storeOnFinished: hasNewSubtasks")
			flags.DidMakePlan = true
		}
		if len(removedSubtasks) > 0 {
			log.Println("storeOnFinished: len(removedSubtasks) > 0")
			flags.DidMakePlan = true
			flags.DidRemoveTasks = true
		}
		if len(autoLoadContextResult.autoLoadPaths) > 0 {
			flags.DidLoadContext = true
		}
		if subtaskFinished && messageSubtask != nil {
			flags.DidCompleteTask = true
		}
		if allSubtasksFinished {
			log.Println("storeOnFinished: allSubtasksFinished")
			flags.DidCompletePlan = true
		}
		if hasNewSubtasks && (state.req.IsApplyDebug || state.req.IsUserDebug) {
			log.Println("storeOnFinished: hasNewSubtasks && (state.req.IsApplyDebug || state.req.IsUserDebug)")
			flags.DidMakeDebuggingPlan = true
		}

		log.Println("storeOnFinished: flags", flags)

		assistantMsg, convoCommitMsg, err := state.storeAssistantReply(repo, storeAssistantReplyParams{
			flags:                flags,
			subtask:              messageSubtask,
			addedSubtasks:        addedSubtasks,
			activatePaths:        autoLoadContextResult.activatePaths,
			activatePathsOrdered: autoLoadContextResult.activatePathsOrdered,
			removedSubtasks:      removedSubtasks,
		}) // updates state.convo

		if err != nil {
			state.onError(onErrorParams{
				streamErr: fmt.Errorf("failed to store assistant message: %v", err),
				storeDesc: true,
			})
			return err
		}

		log.Println("getting description for assistant message: ", assistantMsg.Id)

		var description *db.ConvoMessageDescription
		if len(replyOperations) == 0 {
			description = &db.ConvoMessageDescription{
				OrgId:                 currentOrgId,
				PlanId:                planId,
				ConvoMessageId:        assistantMsg.Id,
				SummarizedToMessageId: summarizedToMessageId,
				BuildPathsInvalidated: map[string]bool{},
				WroteFiles:            false,
			}
		} else {
			description = generatedDescription
			description.ConvoMessageId = assistantMsg.Id
		}

		log.Println("[storeOnFinished] Storing description")
		err = db.StoreDescription(description)

		if err != nil {
			state.onError(onErrorParams{
				streamErr:      fmt.Errorf("failed to store description: %v", err),
				storeDesc:      false,
				convoMessageId: assistantMsg.Id,
				commitMsg:      convoCommitMsg,
			})
			return err
		}
		log.Println("[storeOnFinished] Description stored")

		// store subtasks
		err = db.StorePlanSubtasks(currentOrgId, planId, state.subtasks)
		if err != nil {
			log.Printf("Error storing plan subtasks: %v\n", err)
			state.onError(onErrorParams{
				streamErr:      fmt.Errorf("failed to store plan subtasks: %v", err),
				storeDesc:      false,
				convoMessageId: assistantMsg.Id,
				commitMsg:      convoCommitMsg,
			})
			return err
		}

		log.Println("Comitting after store on finished")

		err = repo.GitAddAndCommit(branch, convoCommitMsg)
		if err != nil {
			state.onError(onErrorParams{
				streamErr:      fmt.Errorf("failed to commit: %v", err),
				storeDesc:      false,
				convoMessageId: assistantMsg.Id,
				commitMsg:      convoCommitMsg,
			})
			return err
		}
		log.Println("Assistant reply, description, and subtasks committed")

		return nil
	})

	if err != nil {
		log.Printf("Error storing on finished: %v\n", err)
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error storing on finished: %v", err))

		active.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("Error storing on finished: %v", err),
		}
		return storeOnFinishedResult{
			handleStreamFinishedResult: handleStreamFinishedResult{
				shouldContinueMainLoop: true,
				shouldReturn:           false,
			},
			allSubtasksFinished: false,
		}
	}

	return storeOnFinishedResult{
		handleStreamFinishedResult: handleStreamFinishedResult{},
		allSubtasksFinished:        allSubtasksFinished,
	}
}

type storeAssistantReplyParams struct {
	flags                shared.ConvoMessageFlags
	subtask              *db.Subtask
	addedSubtasks        []*db.Subtask
	activatePaths        map[string]bool
	activatePathsOrdered []string
	removedSubtasks      []string
}

func (state *activeTellStreamState) storeAssistantReply(repo *db.GitRepo, params storeAssistantReplyParams) (*db.ConvoMessage, string, error) {
	flags := params.flags
	subtask := params.subtask
	addedSubtasks := params.addedSubtasks
	activatePaths := params.activatePaths
	activatePathsOrdered := params.activatePathsOrdered
	removedSubtasks := params.removedSubtasks

	currentOrgId := state.currentOrgId
	currentUserId := state.currentUserId
	planId := state.plan.Id
	branch := state.branch
	auth := state.auth
	replyNumTokens := state.replyNumTokens
	replyId := state.replyId
	convo := state.convo
	num := len(convo) + 1

	log.Printf("storing assistant reply | len(convo) %d | num %d\n", len(convo), num)

	activePlan := state.activePlan

	// fmt.Println("raw message: ", activePlan.CurrentReplyContent)

	assistantMsg := db.ConvoMessage{
		Id:                    replyId,
		OrgId:                 currentOrgId,
		PlanId:                planId,
		UserId:                currentUserId,
		Role:                  openai.ChatMessageRoleAssistant,
		Tokens:                replyNumTokens,
		Num:                   num,
		Message:               activePlan.CurrentReplyContent,
		Flags:                 flags,
		Subtask:               subtask,
		AddedSubtasks:         addedSubtasks,
		ActivatedPaths:        activatePaths,
		ActivatedPathsOrdered: activatePathsOrdered,
		RemovedSubtasks:       removedSubtasks,
	}

	commitMsg, err := db.StoreConvoMessage(repo, &assistantMsg, auth.User.Id, branch, false)

	if err != nil {
		log.Printf("Error storing assistant message: %v\n", err)
		return nil, "", err
	}

	UpdateActivePlan(planId, branch, func(ap *types.ActivePlan) {
		ap.MessageNum = num
		ap.StoredReplyIds = append(ap.StoredReplyIds, replyId)
	})

	convo = append(convo, &assistantMsg)
	state.convo = convo

	return &assistantMsg, commitMsg, err
}


================================================
FILE: app/server/model/plan/tell_stream_usage.go
================================================
package plan

import (
	"fmt"
	"log"
	"plandex-server/hooks"
	"plandex-server/notify"
	"runtime/debug"

	"github.com/davecgh/go-spew/spew"
	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) handleUsageChunk(usage *openai.Usage) {
	auth := state.auth
	plan := state.plan
	generationId := state.generationId

	log.Println("Tell stream usage:")
	log.Println(spew.Sdump(usage))

	var cachedTokens int
	if usage.PromptTokensDetails != nil {
		cachedTokens = usage.PromptTokensDetails.CachedTokens
	}

	sessionId := state.activePlan.SessionId

	modelConfig := state.modelConfig
	baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in handleUsageChunk: %v\n%s", r, debug.Stack())
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in handleUsageChunk: %v\n%s", r, debug.Stack()))
			}
		}()

		_, apiErr := hooks.ExecHook(hooks.DidSendModelRequest, hooks.HookParams{
			Auth: auth,
			Plan: plan,
			DidSendModelRequestParams: &hooks.DidSendModelRequestParams{
				InputTokens:    usage.PromptTokens,
				OutputTokens:   usage.CompletionTokens,
				CachedTokens:   cachedTokens,
				ModelId:        baseModelConfig.ModelId,
				ModelTag:       baseModelConfig.ModelTag,
				ModelName:      baseModelConfig.ModelName,
				ModelProvider:  baseModelConfig.Provider,
				ModelPackName:  state.settings.GetModelPack().Name,
				ModelRole:      modelConfig.Role,
				Purpose:        "Response",
				GenerationId:   generationId,
				PlanId:         plan.Id,
				ModelStreamId:  state.modelStreamId,
				ConvoMessageId: state.replyId,

				RequestStartedAt: state.requestStartedAt,
				Streaming:        true,
				FirstTokenAt:     state.firstTokenAt,
				Req:              state.originalReq,
				StreamResult:     state.activePlan.CurrentReplyContent,
				ModelConfig:      state.modelConfig,

				SessionId: sessionId,
			},
		})

		if apiErr != nil {
			log.Printf("handleUsageChunk - error executing DidSendModelRequest hook: %v", apiErr)
		}
	}()
}

func (state *activeTellStreamState) execHookOnStop(sendStreamErr bool) {
	generationId := state.generationId

	log.Printf("execHookOnStop - sendStreamErr: %t\n", sendStreamErr)

	planId := state.plan.Id
	branch := state.branch
	auth := state.auth
	plan := state.plan
	active := GetActivePlan(planId, branch)

	if active == nil {
		log.Printf(" Active plan not found for plan ID %s on branch %s\n", planId, branch)
		return
	}

	modelConfig := state.modelConfig
	baseModelConfig := modelConfig.GetBaseModelConfig(state.authVars, state.settings, state.orgUserConfig)

	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in execHookOnStop: %v\n%s", r, debug.Stack())
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in execHookOnStop: %v\n%s", r, debug.Stack()))
			}
		}()

		_, apiErr := hooks.ExecHook(hooks.DidSendModelRequest, hooks.HookParams{
			Auth: auth,
			Plan: plan,
			DidSendModelRequestParams: &hooks.DidSendModelRequestParams{
				InputTokens:     state.totalRequestTokens,
				OutputTokens:    active.NumTokens,
				ModelId:         baseModelConfig.ModelId,
				ModelTag:        baseModelConfig.ModelTag,
				ModelName:       baseModelConfig.ModelName,
				ModelProvider:   baseModelConfig.Provider,
				ModelPackName:   state.settings.GetModelPack().Name,
				ModelRole:       modelConfig.Role,
				Purpose:         "Response",
				GenerationId:    generationId,
				PlanId:          plan.Id,
				ModelStreamId:   state.modelStreamId,
				ConvoMessageId:  state.replyId,
				StoppedEarly:    true,
				UserCancelled:   !sendStreamErr,
				HadError:        sendStreamErr,
				NoReportedUsage: true,

				RequestStartedAt: state.requestStartedAt,
				Streaming:        true,
				FirstTokenAt:     state.firstTokenAt,
				Req:              state.originalReq,
				StreamResult:     state.activePlan.CurrentReplyContent,
				ModelConfig:      state.modelConfig,

				SessionId: active.SessionId,
			},
		})

		if apiErr != nil {
			log.Printf("execHookOnStop - error executing DidSendModelRequest hook: %v", apiErr)
		}
	}()

}


================================================
FILE: app/server/model/plan/tell_subtasks.go
================================================
package plan

import (
	"fmt"
	"log"
	"plandex-server/db"
	"plandex-server/model/parse"
	shared "plandex-shared"
	"strings"

	"github.com/davecgh/go-spew/spew"
)

func (state *activeTellStreamState) formatSubtasks() string {
	subtasksText := "### LATEST PLAN TASKS ###\n\n"

	var current *db.Subtask

	for idx, subtask := range state.subtasks {
		subtasksText += fmt.Sprintf("%d. %s\n", idx+1, subtask.Title)
		if subtask.Description != "" {
			subtasksText += "\n" + subtask.Description + "\n"
		}
		if len(subtask.UsesFiles) > 0 {
			subtasksText += "Uses: "
			usesFiles := []string{}
			for _, file := range subtask.UsesFiles {
				usesFiles = append(usesFiles, fmt.Sprintf("`%s`", file))
			}
			subtasksText += strings.Join(usesFiles, ", ") + "\n"
		}
		subtasksText += "Done: "
		if subtask.IsFinished {
			subtasksText += "yes"
		} else {
			subtasksText += "no"
		}
		subtasksText += "\n"

		if state.currentSubtask != nil && subtask.Title == state.currentSubtask.Title && state.currentStage.TellStage == shared.TellStageImplementation {
			current = subtask
			subtasksText += "Current subtask: yes"
		}

		subtasksText += "\n"
	}

	if current != nil && state.currentStage.TellStage == shared.TellStageImplementation {
		subtasksText += fmt.Sprintf("\n### Current subtask\n%s\n", current.Title)
		if current.Description != "" {
			subtasksText += "\n" + current.Description + "\n"
		}
		if len(current.UsesFiles) > 0 {
			subtasksText += "Uses: "
			usesFiles := []string{}
			for _, file := range current.UsesFiles {
				usesFiles = append(usesFiles, fmt.Sprintf("`%s`", file))
			}
			subtasksText += strings.Join(usesFiles, ", ") + "\n"
		}
	} else if state.currentStage.TellStage == shared.TellStagePlanning {
		if state.currentStage.PlanningPhase == shared.PlanningPhaseTasks {
			subtasksText += `
			
			Remember, you are in the *PLANNING* phase and ABSOLUTELY MUST NOT implement any of the subtasks. You MUST NOT write any code or create any files. You can ONLY add or remove subtasks with a '### Tasks' section or a '### Remove Tasks' section. You CANNOT implement any of the subtasks in this response. Follow the PLANNING instructions. The existing subtasks are included for your reference so that you can see what has been planned so far, what has been done, and what is left to do, so that you can add or remove subtasks as needed. DO NOT implement any of the subtasks in this response-follow the instructions for the PLANNING phase.

		`
		} else if state.currentStage.PlanningPhase == shared.PlanningPhaseContext {
			subtasksText += `
			
			Remember, you are in the *CONTEXT* phase. You MUST NOT implement any of the subtasks. You MUST NOT write any code or create any files. You MUST NOT make a plan with a '### Tasks' section or a '### Remove Tasks' section. Follow the instructions for the CONTEXT phase-they are summarized for you in the [SUMMARY OF INSTRUCTIONS] section. The existing subtasks are included for your reference so that you can see what has been planned so far, what has been done, and what is left to do. DO NOT implement any of the subtasks in this response Do NOT add or remove subtasks. Follow the instructions for the CONTEXT phase.

		`
		}
	}

	return subtasksText
}

type checkNewSubtasksResult struct {
	hasExplicitTasks bool
	newSubtasks      []*db.Subtask
}

func (state *activeTellStreamState) checkNewSubtasks() checkNewSubtasksResult {
	activePlan := GetActivePlan(state.plan.Id, state.branch)

	if activePlan == nil {
		return checkNewSubtasksResult{
			hasExplicitTasks: false,
			newSubtasks:      nil,
		}
	}

	content := activePlan.CurrentReplyContent

	subtasks := parse.ParseSubtasks(content)

	if len(subtasks) == 0 {
		log.Println("No new subtasks found")
		return checkNewSubtasksResult{
			hasExplicitTasks: false,
			newSubtasks:      nil,
		}
	}

	log.Println("Found new subtasks:", len(subtasks))
	// log.Println(spew.Sdump(subtasks))

	subtasksByName := map[string]*db.Subtask{}

	// Only index unfinished subtasks by name
	for _, subtask := range state.subtasks {
		if !subtask.IsFinished {
			subtasksByName[subtask.Title] = subtask
		}
	}

	var newSubtasks []*db.Subtask
	var updatedSubtasks []*db.Subtask

	// Keep finished subtasks
	for _, subtask := range state.subtasks {
		if subtask.IsFinished {
			updatedSubtasks = append(updatedSubtasks, subtask)
		}
	}

	// Add new subtasks if they don't exist
	for _, subtask := range subtasks {
		if subtasksByName[subtask.Title] == nil {
			newSubtasks = append(newSubtasks, subtask)
			updatedSubtasks = append(updatedSubtasks, subtask)
		}
	}

	state.subtasks = updatedSubtasks

	var currentSubtaskName string
	if state.currentSubtask != nil {
		currentSubtaskName = state.currentSubtask.Title
	}

	found := false
	for _, subtask := range state.subtasks {
		if subtask.Title == currentSubtaskName {
			found = true
			state.currentSubtask = subtask
			break
		}
	}
	if !found {
		state.currentSubtask = nil
	}

	if state.currentSubtask == nil {
		for _, subtask := range state.subtasks {
			if !subtask.IsFinished {
				state.currentSubtask = subtask
				break
			}
		}
	}

	// log.Println("state.subtasks:\n", spew.Sdump(state.subtasks))
	log.Println("state.currentSubtask:\n", spew.Sdump(state.currentSubtask))

	return checkNewSubtasksResult{
		hasExplicitTasks: len(subtasks) > 0,
		newSubtasks:      newSubtasks,
	}
}

type checkRemoveSubtasksResult struct {
	hasExplicitRemoveTasks bool
	removedSubtasks        []string
}

func (state *activeTellStreamState) checkRemoveSubtasks() checkRemoveSubtasksResult {
	activePlan := GetActivePlan(state.plan.Id, state.branch)

	if activePlan == nil {
		return checkRemoveSubtasksResult{
			hasExplicitRemoveTasks: false,
			removedSubtasks:        nil,
		}
	}

	content := activePlan.CurrentReplyContent

	// Parse tasks to remove
	tasksToRemove := parse.ParseRemoveSubtasks(content)

	if len(tasksToRemove) == 0 {
		log.Println("No tasks to remove found")
		return checkRemoveSubtasksResult{
			hasExplicitRemoveTasks: false,
			removedSubtasks:        nil,
		}
	}

	log.Println("Found tasks to remove:", len(tasksToRemove))
	// log.Println(spew.Sdump(tasksToRemove))

	// Create a map of task titles to remove for efficient lookup
	removeMap := make(map[string]bool)
	for _, task := range tasksToRemove {
		removeMap[task] = true
	}

	var removedSubtasks []*db.Subtask
	var remainingSubtasks []*db.Subtask

	// Keep tasks that aren't in the remove list
	for _, subtask := range state.subtasks {
		if removeMap[subtask.Title] {
			// Only track unfinished tasks that are being removed
			if !subtask.IsFinished {
				removedSubtasks = append(removedSubtasks, subtask)
			}
		} else {
			remainingSubtasks = append(remainingSubtasks, subtask)
		}
	}

	state.subtasks = remainingSubtasks

	// Update current subtask if it was removed
	if state.currentSubtask != nil && removeMap[state.currentSubtask.Title] {
		state.currentSubtask = nil
		// Find the first unfinished subtask to set as current
		for _, subtask := range state.subtasks {
			if !subtask.IsFinished {
				state.currentSubtask = subtask
				break
			}
		}
	}

	removedSubtaskTitles := []string{}
	for _, subtask := range removedSubtasks {
		removedSubtaskTitles = append(removedSubtaskTitles, subtask.Title)
	}
	log.Println("removedSubtaskTitles:\n", spew.Sdump(removedSubtaskTitles))

	return checkRemoveSubtasksResult{
		hasExplicitRemoveTasks: len(tasksToRemove) > 0,
		removedSubtasks:        removedSubtaskTitles,
	}
}


================================================
FILE: app/server/model/plan/tell_summary.go
================================================
package plan

import (
	"context"
	"errors"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/model"
	"plandex-server/model/prompts"
	"plandex-server/notify"
	"plandex-server/types"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
	"github.com/sashabaranov/go-openai"
)

func (state *activeTellStreamState) addConversationMessages() bool {
	summaries := state.summaries
	tokensBeforeConvo := state.tokensBeforeConvo
	active := GetActivePlan(state.plan.Id, state.branch)

	convo := []*db.ConvoMessage{}
	for _, msg := range state.convo {
		if state.skipConvoMessages != nil && state.skipConvoMessages[msg.Id] {
			continue
		}
		convo = append(convo, msg)
	}

	if active == nil {
		log.Println("summarizeMessagesIfNeeded - Active plan not found")
		return false
	}

	conversationTokens := 0
	tokensUpToTimestamp := make(map[int64]int)
	convoMessagesById := make(map[string]*db.ConvoMessage)
	for _, convoMessage := range convo {
		conversationTokens += convoMessage.Tokens + model.TokensPerMessage + model.TokensPerName
		timestamp := convoMessage.CreatedAt.UnixNano() / int64(time.Millisecond)
		tokensUpToTimestamp[timestamp] = conversationTokens
		convoMessagesById[convoMessage.Id] = convoMessage
		// log.Printf("Timestamp: %s | Tokens: %d | Total: %d | conversationTokens\n", convoMessage.Timestamp, convoMessage.Tokens, conversationTokens)
	}

	log.Printf("Conversation tokens: %d\n", conversationTokens)
	log.Printf("Max conversation tokens: %d\n", state.settings.GetPlannerMaxConvoTokens())

	// log.Println("Tokens up to timestamp:")
	// spew.Dump(tokensUpToTimestamp)

	log.Printf("Total tokens: %d\n", tokensBeforeConvo+conversationTokens)
	log.Printf("Max tokens: %d\n", state.settings.GetPlannerEffectiveMaxTokens())

	var summary *db.ConvoSummary
	if (tokensBeforeConvo+conversationTokens) > state.settings.GetPlannerEffectiveMaxTokens() ||
		conversationTokens > state.settings.GetPlannerMaxConvoTokens() {
		log.Println("Token limit exceeded. Attempting to reduce via conversation summary.")

		// log.Printf("(tokensBeforeConvo+conversationTokens) > state.settings.GetPlannerEffectiveMaxTokens(): %v\n", (tokensBeforeConvo+conversationTokens) > state.settings.GetPlannerEffectiveMaxTokens())
		// log.Printf("conversationTokens > state.settings.GetPlannerMaxConvoTokens(): %v\n", conversationTokens > state.settings.GetPlannerMaxConvoTokens())

		log.Printf("Num summaries: %d\n", len(summaries))

		// token limit exceeded after adding conversation
		// get summary for as much as the conversation as necessary to stay under the token limit
		for _, s := range summaries {
			timestamp := s.LatestConvoMessageCreatedAt.UnixNano() / int64(time.Millisecond)

			tokens, ok := tokensUpToTimestamp[timestamp]

			log.Printf("Last message timestamp: %d | found: %v\n", timestamp, ok)
			log.Printf("Tokens up to timestamp: %d\n", tokens)

			if !ok {
				// try a fallback by id instead of timestamp, in case timestamp rounding caused it to be missing
				convoMessage, ok := convoMessagesById[s.LatestConvoMessageId]

				if ok {
					timestamp = convoMessage.CreatedAt.UnixNano() / int64(time.Millisecond)
					tokens, ok = tokensUpToTimestamp[timestamp]
				}

				if !ok {
					// instead of erroring here as we did previously, we'll just log and continue
					// if no summary is found, we still handle it as an error below
					// but this way we don't error out completely for  a single detached summary

					log.Println("conversation summary timestamp not found in conversation")
					log.Println("timestamp:", timestamp)

					// log.Println("Conversation summary:")
					// spew.Dump(s)

					log.Println("tokensUpToTimestamp:")
					log.Println(spew.Sdump(tokensUpToTimestamp))

					go notify.NotifyErr(notify.SeverityInfo, fmt.Errorf("conversation summary timestamp not found in conversation"))

					continue
				}
			}

			updatedConversationTokens := (conversationTokens - tokens) + s.Tokens
			savedTokens := conversationTokens - updatedConversationTokens

			log.Printf("Conversation summary tokens: %d\n", tokens)
			log.Printf("Updated conversation tokens: %d\n", updatedConversationTokens)
			log.Printf("Saved tokens: %d\n", savedTokens)

			if updatedConversationTokens <= state.settings.GetPlannerMaxConvoTokens() &&
				(tokensBeforeConvo+updatedConversationTokens) <= state.settings.GetPlannerEffectiveMaxTokens() {
				log.Printf("Summarizing up to %s | saving %d tokens\n", s.LatestConvoMessageCreatedAt.Format(time.RFC3339), savedTokens)
				summary = s
				conversationTokens = updatedConversationTokens
				break
			}
		}

		if summary == nil && tokensBeforeConvo+conversationTokens > state.settings.GetPlannerEffectiveMaxTokens() {
			err := errors.New("couldn't get under token limit with conversation summary")
			log.Printf("Error: %v\n", err)
			go notify.NotifyErr(notify.SeverityInfo, fmt.Errorf("couldn't get under token limit with conversation summary"))

			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Couldn't get under token limit with conversation summary",
			}
			return false
		}
	}

	var latestSummary *db.ConvoSummary
	if len(summaries) > 0 {
		latestSummary = summaries[len(summaries)-1]
	}

	if summary == nil {
		for _, convoMessage := range convo {
			// this gets added later in tell_exec.go
			if state.promptConvoMessage != nil && convoMessage.Id == state.promptConvoMessage.Id {
				continue
			}

			state.messages = append(state.messages, types.ExtendedChatMessage{
				Role: openai.ChatMessageRoleUser,
				Content: []types.ExtendedChatMessagePart{
					{
						Type: openai.ChatMessagePartTypeText,
						Text: convoMessage.Message,
					},
				},
			})

			// add the latest summary as a conversation message if this is the last message summarized, in order to reinforce the current state of the plan to the model
			if latestSummary != nil && convoMessage.Id == latestSummary.LatestConvoMessageId {
				state.messages = append(state.messages, types.ExtendedChatMessage{
					Role: openai.ChatMessageRoleAssistant,
					Content: []types.ExtendedChatMessagePart{
						{
							Type: openai.ChatMessagePartTypeText,
							Text: latestSummary.Summary,
						},
					},
				})
			}
		}
	} else {
		if (tokensBeforeConvo + conversationTokens) > state.settings.GetPlannerEffectiveMaxTokens() {
			go notify.NotifyErr(notify.SeverityError, fmt.Errorf("token limit still exceeded after summarizing conversation"))

			active.StreamDoneCh <- &shared.ApiError{
				Type:   shared.ApiErrorTypeOther,
				Status: http.StatusInternalServerError,
				Msg:    "Token limit still exceeded after summarizing conversation",
			}
			return false
		}
		state.summarizedToMessageId = summary.LatestConvoMessageId
		state.messages = append(state.messages, types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleAssistant,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: summary.Summary,
				},
			},
		})

		// add messages after the last message in the summary
		for _, convoMessage := range convo {
			// this gets added later in tell_exec.go
			if state.promptConvoMessage != nil && convoMessage.Id == state.promptConvoMessage.Id {
				continue
			}

			if convoMessage.CreatedAt.After(summary.LatestConvoMessageCreatedAt) {
				state.messages = append(state.messages, types.ExtendedChatMessage{
					Role: openai.ChatMessageRoleUser,
					Content: []types.ExtendedChatMessagePart{
						{
							Type: openai.ChatMessagePartTypeText,
							Text: convoMessage.Message,
						},
					},
				})

				// add the latest summary as a conversation message if this is the last message summarized, in order to reinforce the current state of the plan to the model
				if latestSummary != nil && convoMessage.Id == latestSummary.LatestConvoMessageId {
					state.messages = append(state.messages, types.ExtendedChatMessage{
						Role: openai.ChatMessageRoleAssistant,
						Content: []types.ExtendedChatMessagePart{
							{
								Type: openai.ChatMessagePartTypeText,
								Text: latestSummary.Summary,
							},
						},
					})
				}
			}
		}
	}

	return true
}

type summarizeConvoParams struct {
	auth                  *types.ServerAuth
	plan                  *db.Plan
	branch                string
	convo                 []*db.ConvoMessage
	summaries             []*db.ConvoSummary
	userPrompt            string
	currentReply          string
	currentReplyNumTokens int
	currentOrgId          string
	modelPackName         string
}

func summarizeConvo(clients map[string]model.ClientInfo, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, params summarizeConvoParams, ctx context.Context) *shared.ApiError {
	plan := params.plan
	planId := plan.Id
	log.Printf("summarizeConvo: Called for plan ID %s on branch %s\n", planId, params.branch)
	log.Printf("summarizeConvo: Starting summarizeConvo for planId: %s\n", planId)

	branch := params.branch
	convo := params.convo
	summaries := params.summaries
	userPrompt := params.userPrompt
	currentReply := params.currentReply
	active := GetActivePlan(planId, branch)

	config := settings.GetModelPack().PlanSummary

	if active == nil {
		log.Printf("Active plan not found for plan ID %s and branch %s\n", planId, branch)

		return &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("active plan not found for plan ID %s and branch %s", planId, branch),
		}
	}

	log.Println("Generating plan summary for planId:", planId)

	// log.Printf("planId: %s\n", planId)
	// log.Printf("convo: ")
	// spew.Dump(convo)
	// log.Printf("summaries: ")
	// spew.Dump(summaries)
	// log.Printf("promptMessage: ")
	// spew.Dump(promptMessage)
	// log.Printf("currentOrgId: %s\n", currentOrgId)

	var summaryMessages []*types.ExtendedChatMessage
	var latestSummary *db.ConvoSummary
	var numMessagesSummarized int = 0
	var latestMessageSummarizedAt time.Time
	var latestMessageId string
	if len(summaries) > 0 {
		latestSummary = summaries[len(summaries)-1]
		numMessagesSummarized = latestSummary.NumMessages
	}

	// log.Println("Generating plan summary - latest summary:")
	// spew.Dump(latestSummary)

	// log.Println("Generating plan summary - convo:")
	// spew.Dump(convo)

	numTokens := 0

	if latestSummary == nil {
		for _, convoMessage := range convo {
			summaryMessages = append(summaryMessages, &types.ExtendedChatMessage{
				Role: openai.ChatMessageRoleUser,
				Content: []types.ExtendedChatMessagePart{
					{
						Type: openai.ChatMessagePartTypeText,
						Text: convoMessage.Message,
					},
				},
			})
			latestMessageId = convoMessage.Id
			latestMessageSummarizedAt = convoMessage.CreatedAt
			numMessagesSummarized++
			numTokens += convoMessage.Tokens + model.TokensPerMessage + model.TokensPerName
		}
	} else {
		summaryMessages = append(summaryMessages, &types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleAssistant,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: latestSummary.Summary,
				},
			},
		})

		numTokens += latestSummary.Tokens + model.TokensPerMessage + model.TokensPerName

		var found bool
		for _, convoMessage := range convo {
			if convoMessage.Id == latestSummary.LatestConvoMessageId {
				found = true
				continue
			}
			if found {
				summaryMessages = append(summaryMessages, &types.ExtendedChatMessage{
					Role: openai.ChatMessageRoleUser,
					Content: []types.ExtendedChatMessagePart{
						{
							Type: openai.ChatMessagePartTypeText,
							Text: convoMessage.Message,
						},
					},
				})
				numMessagesSummarized++
				numTokens += convoMessage.Tokens + model.TokensPerMessage + model.TokensPerName
			}
		}

		latestConvoMessage := convo[len(convo)-1]
		latestMessageId = latestConvoMessage.Id
		latestMessageSummarizedAt = latestConvoMessage.CreatedAt
	}

	log.Println("generating summary - latestMessageId:", latestMessageId)
	log.Println("generating summary - latestMessageSummarizedAt:", latestMessageSummarizedAt)

	if userPrompt != "" {
		if userPrompt != prompts.UserContinuePrompt && userPrompt != prompts.AutoContinuePlanningPrompt && userPrompt != prompts.AutoContinueImplementationPrompt {
			summaryMessages = append(summaryMessages, &types.ExtendedChatMessage{
				Role: openai.ChatMessageRoleUser,
				Content: []types.ExtendedChatMessagePart{
					{
						Type: openai.ChatMessagePartTypeText,
						Text: userPrompt,
					},
				},
			})

			tokens := shared.GetNumTokensEstimate(userPrompt)
			numTokens += tokens + model.TokensPerMessage + model.TokensPerName
		}
	}

	if currentReply != "" {
		summaryMessages = append(summaryMessages, &types.ExtendedChatMessage{
			Role: openai.ChatMessageRoleAssistant,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: currentReply,
				},
			},
		})

		numTokens += params.currentReplyNumTokens + model.TokensPerMessage + model.TokensPerName
	}

	log.Printf("Calling model for plan summary. Summarizing %d messages\n", len(summaryMessages))

	// log.Println("Generating summary - summary messages:")
	// spew.Dump(summaryMessages)

	// latestSummaryCh := make(chan *db.ConvoSummary, 1)
	// active.LatestSummaryCh = latestSummaryCh

	summary, apiErr := model.PlanSummary(clients, authVars, settings, orgUserConfig, config, model.PlanSummaryParams{
		Conversation:                summaryMessages,
		ConversationNumTokens:       numTokens,
		LatestConvoMessageId:        latestMessageId,
		LatestConvoMessageCreatedAt: latestMessageSummarizedAt,
		NumMessages:                 numMessagesSummarized,
		Auth:                        params.auth,
		Plan:                        plan,
		ModelPackName:               params.modelPackName,
		ModelStreamId:               active.ModelStreamId,
		SessionId:                   active.SessionId,
	}, ctx)

	if apiErr != nil {
		log.Printf("summarizeConvo: Error generating plan summary for plan %s: %v\n", planId, apiErr)
		return apiErr
	}

	log.Printf("summarizeConvo: Summary generated and stored for plan %s\n", planId)

	// log.Println("Generated summary:")
	// spew.Dump(summary)

	err := db.StoreSummary(summary)

	if err != nil {
		log.Printf("Error storing plan summary for plan %s: %v\n", planId, err)
		return &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("error storing plan summary for plan %s: %v", planId, err),
		}
	}

	// latestSummaryCh <- summary

	return nil
}


================================================
FILE: app/server/model/plan/tell_sys_prompt.go
================================================
package plan

import (
	"errors"
	"fmt"
	"log"
	"plandex-server/model/prompts"
	"plandex-server/types"
	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

const AllTasksCompletedMsg = "All tasks have been completed. There is no current task to implement."

type getTellSysPromptParams struct {
	planStageSharedMsgs   []*types.ExtendedChatMessagePart
	planningPhaseOnlyMsgs []*types.ExtendedChatMessagePart
	implementationMsgs    []*types.ExtendedChatMessagePart
	contextTokenLimit     int
	dryRunWithoutContext  bool
}

func (state *activeTellStreamState) getTellSysPrompt(params getTellSysPromptParams) ([]types.ExtendedChatMessagePart, error) {
	planningSharedMsgs := params.planStageSharedMsgs
	plannerOnlyMsgs := params.planningPhaseOnlyMsgs
	implementationMsgs := params.implementationMsgs
	contextTokenLimit := params.contextTokenLimit
	req := state.req
	active := state.activePlan
	currentStage := state.currentStage

	sysParts := []types.ExtendedChatMessagePart{}

	createPromptParams := prompts.CreatePromptParams{
		ExecMode:          req.ExecEnabled,
		AutoContext:       req.AutoContext,
		IsUserDebug:       req.IsUserDebug,
		IsApplyDebug:      req.IsApplyDebug,
		IsGitRepo:         req.IsGitRepo,
		ContextTokenLimit: contextTokenLimit,
	}

	// log.Println("getTellSysPrompt - prompt params:", spew.Sdump(params))

	if currentStage.TellStage == shared.TellStagePlanning {
		if len(planningSharedMsgs) == 0 && !params.dryRunWithoutContext {
			log.Println("planningSharedMsgs is empty - required for planning stage")
			return nil, fmt.Errorf("planningSharedMsgs is empty - required for planning stage")
		}

		for _, msg := range planningSharedMsgs {
			sysParts = append(sysParts, *msg)
		}

		if currentStage.PlanningPhase == shared.PlanningPhaseContext {
			log.Println("Planning phase is context -- adding auto context prompt")

			var txt string
			if req.IsChatOnly {
				txt = prompts.GetAutoContextChatPrompt(createPromptParams)
			} else {
				txt = prompts.GetAutoContextTellPrompt(createPromptParams)
			}

			sysParts = append(sysParts, types.ExtendedChatMessagePart{
				Type: openai.ChatMessagePartTypeText,
				Text: txt,
				CacheControl: &types.CacheControlSpec{
					Type: types.CacheControlTypeEphemeral,
				},
			})
		} else if currentStage.PlanningPhase == shared.PlanningPhaseTasks {

			var txt string
			if req.IsChatOnly {
				txt = prompts.GetChatSysPrompt(createPromptParams)
			} else {
				txt = prompts.GetPlanningPrompt(createPromptParams)
			}

			if len(state.subtasks) > 0 {
				sysParts = append(sysParts, types.ExtendedChatMessagePart{
					Type: openai.ChatMessagePartTypeText,
					Text: txt,
				})
				sysParts = append(sysParts, types.ExtendedChatMessagePart{
					Type: openai.ChatMessagePartTypeText,
					Text: state.formatSubtasks(),
					CacheControl: &types.CacheControlSpec{
						Type: types.CacheControlTypeEphemeral,
					},
				})
			} else {
				sysParts = append(sysParts, types.ExtendedChatMessagePart{
					Type: openai.ChatMessagePartTypeText,
					Text: txt,
					CacheControl: &types.CacheControlSpec{
						Type: types.CacheControlTypeEphemeral,
					},
				})
			}

			if !req.IsChatOnly {
				if len(active.SkippedPaths) > 0 {
					skippedPrompt := prompts.SkippedPathsPrompt
					for skippedPath := range active.SkippedPaths {
						skippedPrompt += fmt.Sprintf("- %s\n", skippedPath)
					}
					sysParts = append(sysParts, types.ExtendedChatMessagePart{
						Type: openai.ChatMessagePartTypeText,
						Text: skippedPrompt,
					})
				}
			}
		}

		for _, msg := range plannerOnlyMsgs {
			sysParts = append(sysParts, *msg)
		}

		if len(implementationMsgs) > 0 {
			return nil, fmt.Errorf("implementationMsgs not supported during planning phase")
		}

	} else if currentStage.TellStage == shared.TellStageImplementation {
		if state.currentSubtask == nil {
			return nil, errors.New(AllTasksCompletedMsg)
		}

		if len(state.subtasks) > 0 {
			sysParts = append(sysParts, types.ExtendedChatMessagePart{
				Type: openai.ChatMessagePartTypeText,
				Text: prompts.GetImplementationPrompt(state.currentSubtask.Title),
			})
			sysParts = append(sysParts,
				types.ExtendedChatMessagePart{
					Type: openai.ChatMessagePartTypeText,
					Text: state.formatSubtasks(),
					CacheControl: &types.CacheControlSpec{
						Type: types.CacheControlTypeEphemeral,
					},
				})
		} else {
			sysParts = append(sysParts, types.ExtendedChatMessagePart{
				Type: openai.ChatMessagePartTypeText,
				Text: prompts.GetImplementationPrompt(state.currentSubtask.Title),
				CacheControl: &types.CacheControlSpec{
					Type: types.CacheControlTypeEphemeral,
				},
			})
		}

		if !req.IsChatOnly {
			if len(active.SkippedPaths) > 0 {
				skippedPrompt := prompts.SkippedPathsPrompt
				for skippedPath := range active.SkippedPaths {
					skippedPrompt += fmt.Sprintf("- %s\n", skippedPath)
				}
				sysParts = append(sysParts, types.ExtendedChatMessagePart{
					Type: openai.ChatMessagePartTypeText,
					Text: skippedPrompt,
				})
			}
		}

		if implementationMsgs != nil {
			for _, msg := range implementationMsgs {
				sysParts = append(sysParts, *msg)
			}
		} else if !params.dryRunWithoutContext {
			log.Println("implementationMsgs is nil - required for implementation stage")
			return nil, fmt.Errorf("implementationMsgs is nil - required for implementation stage")
		}

		if planningSharedMsgs != nil {
			log.Println("planningSharedMsgs not supported during implementation stage - only basic or smart context is supported")
			return nil, fmt.Errorf("planningSharedMsgs not supported during implementation stage - only basic or smart context is supported")
		}
	}

	return sysParts, nil
}


================================================
FILE: app/server/model/plan/utils.go
================================================
package plan

import (
	"plandex-server/types"
	"strings"
)

func StripBackticksWrapper(s string) string {
	check := strings.TrimSpace(s)
	split := strings.Split(check, "\n")

	if len(split) > 2 {
		firstLine := strings.TrimSpace(split[0])
		secondLine := strings.TrimSpace(split[1])
		lastLine := strings.TrimSpace(split[len(split)-1])
		if types.LineMaybeHasFilePath(firstLine) && strings.HasPrefix(secondLine, "```") {
			if lastLine == "```" {
				return strings.Join(split[1:len(split)-1], "\n")
			}
		} else if strings.HasPrefix(firstLine, "```") && lastLine == "```" {
			return strings.Join(split[1:len(split)-1], "\n")
		}
	}

	return s
}


================================================
FILE: app/server/model/prompts/apply_exec.go
================================================
package prompts

const ApplyScriptSharedPrompt = `
## _apply.sh file and command execution

**Execution mode is enabled.** 

In addition to creating and updating files with code blocks, you can also execute commands on the user's machine by writing to a another *special path*: _apply.sh

### Core _apply.sh Concepts

The _apply.sh script is a special file that allows execution of commands on the user's machine. This script will be executed EXACTLY ONCE after ALL files from ALL subtasks have been created or updated. The entire script runs as a single unit in the root directory of the plan.

#### Core Restrictions

You ABSOLUTELY MUST NOT:
- Use _apply.sh to create files or directories (use code blocks instead - necessary directories will be created automatically)
- Use _apply.sh for file operations (move/remove/reset) on files in context
- Include shebang lines or error handling (this is handled externally)
- Give _apply.sh execution privileges (this is handled externally)
- Tell users to run the script (it runs automatically)
- Use separate script files unless specifically requested or absolutely necessary due to complexity

#### Safety and Security

BE CAREFUL AND CONSERVATIVE when making changes to the user's machine:
- Only make changes that are strictly necessary for the plan
- If a command is highly risky, tell the user to run it themselves
- Do not run malicious commands, commands that will harm the user's machine, or commands intended to cause harm to other systems, networks, or people.
- Prefer local changes over global system changes (e.g., npm install --save-dev over --global)
- Only modify files/directories in the root directory of the plan unless specifically directed otherwise
- Unless some commands are risky/dangerous, include ALL commands in _apply.sh rather than telling users to run them later

#### Avoid User Prompts

Avoid user prompts. Make reasonable default choices rather than prompting the user for input. The _apply.sh script MUST be able to run successfully in a non-interactive context.

#### Keep It Lightweight And Simple

The _apply.sh script should be lightweight and shouldn't do too much work. *Offload to separate files* in the plan if a lot of scripting is needed. _apply.sh doesn't get written to the user's project, so anything that might be valuable to save, reuse, and version control should be in a separate file. You can chmod and execute those separate files from _apply.sh. _apply.sh is for 'throwaway' commands that only need to be run once after the plan is applied to the user's project, like installing dependencies, running tests, or runing a start command. It shouldn't be complex.

Do not use fancy bash constructs that can be difficult to debug or cause portability problems. Keep it very straightforward so there's a 0% chance of bugs in the _apply.sh script.

ABSOLUTELY DO NOT use the _apply.sh script to generate config files, project files, instructions, documentation, or any other necessary files. The _apply.sh script MUST NOT create files or directories—this must be done ONLY with code blocks. Create those files like any other files in the plan using code blocks. Do NOT include any large context blocks of any kind in the _apply.sh script. Use separate files for large content. Keep the _apply.sh script lightweight, simple, and focused only on executing necessary commands.

#### Startup Logic

` + ApplyScriptStartupLogic + `

❌ DO NOT include complex startup logic or commands with flags in _apply.sh:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
echo "Importing project resources..."
godot --headless --quit

# Check if the main scene file exists
if [ ! -f "scenes/main.tscn" ]; then
   echo "Error: Main scene file 'scenes/main.tscn' not found."
   exit 1
fi

echo "Validating main scene file..."
if ! godot --headless --check-only --quit scenes/main.tscn; then
   echo "Error: The main scene file 'scenes/main.tscn' contains errors."
   exit 1
fi

echo "Checking for resource loading issues..."
if ! godot --headless --check-only --quit project.godot; then
   echo "Error: The project contains resource loading issues."
   exit 1
fi

echo "Starting Godot project..."
godot --position 100,100 --resolution 1280x720 --verbose
</PlandexBlock>

✅ DO include complex startup logic or commands with flags in a *separate file* in the project, created with a *code block*, not in _apply.sh:

- run.sh:
<PlandexBlock lang="bash" path="run.sh">
#!/bin/bash
set -euo pipefail

echo "Importing project resources..."
godot --headless --quit

# Check if the main scene file exists
if [ ! -f "scenes/main.tscn" ]; then
   echo "Error: Main scene file 'scenes/main.tscn' not found."
   exit 1
fi

echo "Validating main scene file..."
if ! godot --headless --check-only --quit scenes/main.tscn; then
   echo "Error: The main scene file 'scenes/main.tscn' contains errors."
   exit 1
fi

echo "Checking for resource loading issues..."
if ! godot --headless --check-only --quit project.godot; then
   echo "Error: The project contains resource loading issues."
   exit 1
fi

echo "Starting Godot project..."
godot --position 100,100 --resolution 1280x720 --verbose
</PlandexBlock>

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
chmod +x run.sh
./run.sh
</PlandexBlock>

#### Command Preservation Rules

The _apply.sh script accumulates commands during the plan:
- ALL commands must be preserved until successful application
- Each update ADDS to or MODIFIES existing commands but NEVER removes them
- When updating an existing command, modify it rather than duplicating it
- After successful application, the script resets to empty
- Current state and history of previously executed scripts will be provided in the prompt
- Use script history to inform what commands might need to be re-run

#### Dependencies and Tools

When handling tools and dependencies:

1. Context-based Assumptions:
- Make reasonable assumptions about installed tools based on:
  * The user's operating system
  * Files and paths in the context
  * Project structure and existing configuration
  * Conversation history
- For example, if working with an existing Node.js project (has package.json), do NOT include commands to install Node.js/npm
- Similarly for other languages/frameworks: don't install Go for a Go project, Python for a Python project, etc.

2. Checking for Tools:
- For tools that aren't clearly present in context:
  * Always check if the tool is installed before using it
  * Either install missing tools or exit with a clear error
  * Make the check specific and informative
- If no commands need to be run, do not write anything to _apply.sh

3. Dependency Management:
- DO NOT install dependencies that are already used in the project
- Only install new dependencies that are specifically needed for new features
- When working with an entirely new project, you can include basic tooling installation
- When adding to an existing project, assume core tooling is present

For example, in an existing Node.js project:
❌ DO NOT: Install Node.js or npm
❌ DO NOT: Reinstall dependencies listed in package.json
✅ DO: Install only new packages needed for new features
✅ DO: Check for specific tools needed for new functionality

#### Avoid Heavy Commands Unless Directed

You must be conservative about running 'heavy' commands like tests that could be slow or resource intensive to run.

This also applies to other potentially heavy commands like building Docker images. Use your best judgement.

#### Additional Requirements

Script execution:
- Assumes bash/zsh shell is available (OS/shell details provided in prompt)
- The script runs in the root directory of the plan
- All commands execute as a single unit after all file operations are complete

Special cases:
- If the plan includes other script files aside from _apply.sh, they must be given execution privileges and run from _apply.sh
- Only use separate script files if specifically requested or if the number of commands is too large for a single _apply.sh
- When using separate scripts, they must be run from _apply.sh, not manually by the user

Running programs:
- If appropriate, include commands to run the actual program
- For example: after 'make', include the command to run the program
- After 'npm install', include 'npm start' if appropriate
- Use judgment on the best way to run/execute the implemented plan
- Running web servers and browsers:
  * Launch the default browser with the appropriate localhost URL after starting the server
  * When writing a web server that connects to a port, use a port environment variable or command line argument to specify the port number. If you include a fallback port, you can use a common port in the context of the project like 3000 or 8080. Include a port override in the _apply.sh script that uses an UNCOMMON port number that is unlikely to be in use.
  * Try multiple ports so if a port is in use, the server won't fail to start  
  * When starting a web server that needs a browser launched:
      * CRITICAL: ALWAYS run the server in the background using & or the script will block and never reach the browser launch
      * Add a brief sleep to allow the server to start (use your judgment based on the server type and the complexity of the server startup process how long is reasonable)
      * ALWAYS use the special command 'plandex browser [urls...]' to launch the browser with one or more URLs. This command is provided by Plandex and is available on all operating systems. Substitute the actual URL or URLs you want to open in place of [urls...]. This special command *blocks* and streams the browser output to the console. So if you need to run other commands *after* the browser is launched, you must background the browser command and correclty handle cleanup like other background processes. If the browser command exits with an error, kill any other background processes and exit the entire script with a non-zero exit code.

      Example:
         # INCORRECT - will block and never launch browser:
         npm start
         plandex browser http://localhost:$PORT 
         
         # CORRECT - runs in background, waits, then launches browser:
         npm start &
         SERVER_PID=$!
         sleep 3
         plandex browser http://localhost:$PORT || {
            kill $SERVER_PID
            exit 1
         }
         wait $SERVER_PID
            
      NOTE: when running anything in the background, you must handle the possibility that the process might fail so that no orphaned processes remain.
      - ALWAYS use 'plandex browser' to open the browser and load urls. Do NOT use 'open' or 'xdg-open' or any other command to open the browser. USE 'plandex browser' instead.
      * When using the 'plandex browser' command, you ABSOLUTE MUST EXPLICITLY kill all other processes and exit the script with a non-zero exit code if the browser command fails. It is CRITICAL that you DO NOT omit this. The 'plandex browser' command will fail if there are any uncaught errors or console.error logs in the browser.
      *CRUCIAL NOTE: the _apply.sh script will be run with 'set -e' (it will be set for you, don't add it yourself) so you must DIRECTLY handle errors in foreground commands and cleanup in a '|| { ... }' block immediately when the command fails. *This includes the 'plandex browser' command.* Do NOT omit the '|| { ... }' block for 'plandex browser' or any other foreground command.

      Example:
         ## INCORRECT - will not kill other processes and will not exit on browser failure:
         npm start &
         SERVER_PID=$!
         sleep 3
         plandex browser http://localhost:$PORT
         wait $SERVER_PID

         ## INCORRECT - will not cleanup on failure due to 'set -e':
         npm start &
         SERVER_PID=$!
         sleep 3
         plandex browser http://localhost:$PORT

         if [ $? -ne 0 ]; then
            kill $SERVER_PID
            exit 1
         fi
         wait $SERVER_PID

         ## CORRECT - will kill other processes and exit on browser failure, correctly handles 'set -e' with '|| { ... }' block:
         npm start &
         SERVER_PID=$!
         sleep 3
         plandex browser http://localhost:$PORT || {  
            kill $SERVER_PID
            exit 1
         }
         wait $SERVER_PID
`

const ApplyScriptPlanningPrompt = ApplyScriptSharedPrompt + `

## Planning _apply.sh Updates

When planning tasks that involve command execution, always consider the natural hierarchy of commands:
1. First install any required packages/dependencies
2. Then run any necessary build commands
3. Finally run any test/execution commands

### Good Practices for Task Organization

When organizing subtasks that involve writing to _apply.sh:
- Write dependency installations close to the subtasks that introduce them
- Group related commands together when they're part of the same logical change
- Commands like 'make', 'npm install', or 'npm run build' that affect the whole project should appear only ONCE
- If adding a command that's already in _apply.sh, plan to update the existing command rather than duplicating it

### Bad Practices to Avoid

DO NOT:
- Plan to write the same command multiple times (e.g., 'make' after each file update)
- Create separate subtasks just to write a single command to _apply.sh
- Add new 'npm install' commands when you could update an existing one
- Plan to run the same program multiple times

### Example of Good Task Organization

Good task structure:
1. Add authentication feature
   - Update auth-related files
   - Write to _apply.sh: npm install auth-package

2. Add other features
   - Update feature files
   - Write to _apply.sh: npm install other-package

3. Build and run
   - Write to _apply.sh: 
     npm run build
     npm start

### Task Planning Guidelines

When breaking down tasks:
- Remember the single execution model - all commands run after all files are updated
- Consider dependencies between tasks and their required commands
- Group related file changes and their associated commands together
- Think about the logical ordering of commands
- Include _apply.sh in the 'Uses:' list for any subtask that will modify it

### Command Strategy

Think strategically about command execution:
- Plan command ordering based on dependencies
- Consider what will be needed after file changes are complete
- Group related commands together
- Plan for proper error handling and dependency checking
- Consider the user's environment and likely installed tools
- For web applications and web servers:
  * Use port environment variables or command line arguments to specify the port number. If you include a fallback port, you can use a common port in the context of the project like 3000 or 8080. Include a port override in the _apply.sh script that uses an UNCOMMON port number that is unlikely to be in use.
  * Include default browser launch commands after server start
` + ApplyScriptResetUpdatePlanningPrompt

const ApplyScriptImplementationPrompt = ApplyScriptSharedPrompt + `

## Implementing _apply.sh Updates

Remember that the _apply.sh script accumulates commands during the plan and executes them as a single unit. When adding new commands, carefully consider:
- Dependencies between commands (what needs to run before what)
- Whether similar commands already exist that should be updated rather than duplicated
- How your commands fit into the overall hierarchy (install → build → test/run)

### Creating and Updating _apply.sh

The script must be written using a correctly formatted code block:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
# Code goes here
</PlandexBlock>

CRITICAL rules:
- ALWAYS include the file path label exactly as shown above
- NEVER leave out the file path label when writing to _apply.sh
- There must be NO lines between the file path and opening <PlandexBlock> tag
- Use lang="bash" in the <PlandexBlock> tag

When writing to _apply.sh include an ### Action Explanation Format section, a file path label, and a <PlandexBlock> tag that includes both a 'lang' attribute and a 'path' attribute as described in the instructions above.

If the current state of the _apply.sh script is *empty*, follow ALL instructions for *creating a new file* when writing to _apply.sh. Include the *entire* _apply.sh script in the code block.

If the current state of the _apply.sh script is *not empty*, follow ALL instructions for *updating an existing file* when writing to _apply.sh.

### Command Output and Error Handling

DO NOT hide or filter command output. For example, DO NOT do this:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
if ! make clean && make; then                                             
    echo "Error: Compilation failed"                                      
    exit 1                                                                
fi
</PlandexBlock>

Instead, show all command output:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
make clean
make
</PlandexBlock>

### Script Organization and Comments

The script should be:
- Written defensively to fail gracefully
- Organized logically with similar commands grouped
- Commented only when necessary for understanding
- Clear and maintainable

Include logging ONLY for:
- Error conditions
- Long-running operations
- DO NOT log script start/end (handled externally)

### Command Preservation

When updating an existing script:
1. Review current contents carefully
2. Preserve ALL existing commands exactly
3. Add new commands while maintaining existing ones
4. Verify no commands were accidentally removed/modified

Example of proper update:

Starting script:
npm install typescript
npm run build

Adding test command (CORRECT):
npm install typescript
npm run build
npm test

Adding test command (INCORRECT - NEVER DO THIS):
npm test

### Tool and Dependency Checks

When checking for required tools:

✅ DO:
- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
if ! command -v tool > /dev/null; then
    echo "Error: tool is not installed"
    exit 1
fi
</PlandexBlock>

✅ DO group related dependency installations:
- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
npm install --save-dev \
    package1 \
    package2 \
    package3
</PlandexBlock>

❌ DO NOT hide command output:
- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
npm install --quiet package1
</PlandexBlock>

### Examples

Good example of complete script:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
# Check for required tools
if ! command -v node > /dev/null; then
    echo "Error: node is not installed"
    exit 1
fi

if ! command -v npm > /dev/null; then
    echo "Error: npm is not installed"
    exit 1
fi

# Install dependencies
echo "Installing project dependencies..."
npm install --save-dev \
    "@types/react@^18.0.0" \
    "typescript@^4.9.0" \
    "prettier@^2.8.0"

# Find an available port
export PORT=3400
while ! nc -z localhost $PORT && [ $PORT -lt 3410 ]; do
  export PORT=$((PORT + 1))
done

# Build and start in background
npm run build
npm start & 
SERVER_PID=$!

# Wait briefly for server to be ready
sleep 3

# Launch browser
plandex browser http://localhost:$PORT || {
   kill $SERVER_PID
   exit 1
}
wait $SERVER_PID
</PlandexBlock>

Note the usage of & to run the server in the background. This is CRITICAL to ensure the script does not block and allows the browser to launch.

* If you run multiple processes in parallel with &, you ABSOLUTELY MUST handle partial failure by immediately exiting the script if any process returns a non-zero code.
   * For example, store process PIDs, wait on all processes, check $?, kill all processes if a failure is detected, and exit with that code.
EXAMPLE:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
# Build assets first
npm install
npm run build

# Start Node in background, maybe with --inspect
echo "Starting Node server with inspector on port 9229..."
node --inspect=0.0.0.0:9229 server.js &
pidNode=$!

# Start Python app in background
echo "Starting Python service..."
python main.py &
pidPy=$!

# Wait for the *first* process to exit (success or failure)
echo "Waiting for either Node or Python to exit..."
wait $pidNode $pidPy
exit_code=$?

if [ $exit_code -ne 0 ]; then
  echo "⚠️ One process exited with an error. Stopping everything..."
  kill $pidNode $pidPy 2>/dev/null
  exit $exit_code
fi

# If we get here, the first process that ended did so with success code
# We still need to wait on the other process
echo "First process ended successfully, waiting for the second to exit..."
wait $pidNode
wait $pidPy
</PlandexBlock>

Note on example: notice there's no advanced job control (e.g. setsid, disown, etc.) is needed because the wrapper script handles cleanup. The processes remain in the same process group and are killed when the wrapper script exits. And notice that if either job fails, the wrapper script kills all the jobs and exits with the correct output and error code.

If you only run one background job or run them sequentially, you do not need partial-failure logic. Only include logic for handling partial failures if it's really necessary—otherwise, keep it simple: you can just run the commands and let the wrapper script handle cleanup. For example:

- _apply.sh:
<PlandexBlock lang="bash" path="_apply.sh">
# Run the server in the background
npm start &

# Run the tests in the foreground  
npm test
</PlandexBlock>

In this case, the wrapper script will handle cleanup automatically.

- Plandex automatically wraps ` + "`_apply.sh`" + ` in a script that enables job control and kills all processes if the user interrupts. Do NOT add ` + "`trap`" + `, ` + "`setsid`" + `, ` + "`nohup`" + `, or ` + "`disown`" + ` commands.
- If you run multiple processes (e.g., ` + "`node server.js &`" + ` plus ` + "`python main.py &`" + `), you must handle partial failures by checking their exit codes. For example:
  - ` + "`pidA=$!`" + ` after launching the first process
  - Launch the second, ` + "`pidB=$!`" + `
  - Use ` + "`wait $pidA $pidB`" + ` or check each PID. If one fails (` + "`exit_code != 0`" + `), kill the other.
- If you only have a single process to run, you may simply do ` + "`command &`" + ` and then ` + "`wait`" + `. The wrapper script ensures no leftover processes remain if the user presses Ctrl+C.
- Don't run commands that may daemonize themselves or change their process group unless absolutely necessary since it complicates the cleanup process. The wrapper script cannot reliably handle processes that daemonize themselves or change their process group, so if you really must run such commands, you MUST ALWAYS include code to ensure they are cleaned up properly and reliably before exiting.

* You will be provided with the user's OS in the prompt. DO NOT include commands for other operating systems, just the user's specified OS.
* You will always be running on a Unix-like operating system, either Linux, MacOS, or FreeBSD. You'll never be running on Windows.
` + ExitCodePrompt + ApplyScriptResetUpdateImplementationPrompt

const ApplyScriptResetUpdateSharedPrompt = `
## Script State and Reset Behavior

When the user applies the plan, the _apply.sh will be executed. 

CRITICAL: The _apply.sh script accumulates ALL commands needed for the plan. Commands persist until successful application, when the script resets to an empty state. This reset ONLY happens after successful application.

The current state of the _apply.sh script and history of previously executed scripts will be included in your prompt in this format:

Previously executed _apply.sh:
` + "```" + `
npm install typescript express
npm run build
npm start
` + "```" + `

Previously executed _apply.sh:
` + "```" + `
npm install jest
npm test
` + "```" + `

*Current* state of _apply.sh script:
[empty]

(Note that when the *Current* state of _apply.sh is empty, it will be shown as "[empty]" in the context.)

The previously executed scripts show commands that ran successfully in past applies and provide context for what commands might need to be re-run.
`

const ApplyScriptResetUpdatePlanningPrompt = ApplyScriptResetUpdateSharedPrompt + `
## Planning with Script State

When planning tasks (and subtasks) that involve command execution, you must consider how the ` + "`_apply.sh`" + ` script evolves during the plan. ` + "`_apply.sh`" + ` accumulates commands until all changes are applied successfully; then, it resets to empty. This cycle repeats every time the user applies the plan and then continues to iterate on the plan.

### 1. Command Accumulation
- ALL commands in _apply.sh persist until successful application, at which point it is cleared
- Group related commands in logical subtasks
- Consider dependencies between commands
- Plan command ordering carefully

### 2. After Reset (Post-Success)
- **Script Empties**: Once ` + "`_apply.sh`" + ` has been successfully executed, it's cleared.
- **No Unnecessary Repeats**: For future tasks, avoid re-adding commands (e.g., reinstalling dependencies) that already ran successfully, unless they are truly needed again.
- **Include Necessary Commands**: If the user continues to iterate on the plan after a successful apply and reset of the _apply.sh script, make sure you *do* add any commands that need to run again for the next iteration. For example, if there is a command that runs the program, and the _apply.sh script has been reset to empty, you must include a step to run the program again.

### Common Command Patterns

- **Build Commands**: Run after source changes (e.g., ` + "`make`" + `, ` + "`npm run build`" + `, ` + "`cargo build`" + `).
- **Test Commands**: Run after code changes that require verification (e.g., ` + "`npm test`" + `, ` + "`go test`" + `, etc.).
- **Startup/Execution**: Start or run the program once built (e.g., ` + "`./app`" + `, ` + "`npm start`" + `).
- **Database Migrations**: If schema changes are involved, add relevant migration commands.
- **Package/Dependency Installs**: Add or update only if new libraries or tools are introduced.
- **Web Server**: Start the server again after source changes, dependency updates, etc.

### Example of Task Organization

1. **Add Authentication Feature**
   - Update or create relevant files (e.g. ` + "`auth_controller.js`" + `, ` + "`auth_routes.py`" + `).
   - In ` + "`_apply.sh`" + `, install new auth-related dependencies (e.g. ` + "`npm install auth-lib`" + `).
   - Include build or test commands if needed.

2. **Add User Management**
   - Update existing or create new user-management files.
   - If new libraries are introduced, add them in ` + "`_apply.sh`" + ` (avoid re-installing old ones).
   - Update existing build/test steps if relevant.

3. **Final Build and Run**
   - In ` + "`_apply.sh`" + `, include all final build commands (e.g. ` + "`make`" + `, ` + "`npm run build`" + `).
   - Run the application if desired (e.g. ` + "`npm start`" + ` or ` + "`./myapp`" + `).
   - If tests have changed, also include them here (e.g. ` + "`npm test`" + `).

### Good Practices

- **Check Script State**: If ` + "`_apply.sh`" + ` is not empty, modify existing commands in place. If it's empty (post-success), add only new or relevant commands.
- **Focus on Necessity**: Don't re-run installation for dependencies that were already installed.
- **Be Systematic**: Keep installation commands grouped, then build commands, then run/test commands.

### Final Reminder

Plan your subtasks so that installation, build, and run commands appear **only where they're actually required**—and be sure to keep them minimal after the script resets.

### Always consider _apply.sh

When planning and breaking down tasks, *always* consider whether a task for writing to the _apply.sh file is needed. Consider the current state of the _apply.sh file when making this decision.

Imagine this scenario:

1. You have previously made a plan for the user which included an _apply.sh file.
2. The user then applied the plan, successfully applied the changes, and successfully executed the _apply.sh script, causing it to be reset to empty.
3. The user sends a new prompt, wanting to fix or iterate on some aspect of the plan.

Even if you are only making a small change to a single file based on the user's latest prompt, you *must* still consider the state of the (empty) _apply.sh file and whether it needs to be created again.

If your updates to the _apply.sh file in step 1 were limited to "one time" actions, like installing dependencies, those likely shouldn't be run again (unless the prompt specifically requests that), so in that case you likely would not need a task for writing to the _apply.sh file.

However, if your updates to the _apply.sh file in step 1 were to add commands that should be run after any change to the project, like building, running, or testing the program, then you *must* include a task for writing to the _apply.sh file.

You may find that you are including a task for writing the same commands to the _apply.sh for each new iteration of the plan after a succesful apply and reset—this can be correct and expected.

🔄 CRITICAL: _apply.sh RESET BEHAVIOR
Remember, after successful execution, _apply.sh ALWAYS resets to empty.
You MUST ALWAYS consider adding build/run commands again after ANY source changes.
If the _apply.sh script previously had a build/run command, and then it was reset to empty after being successfully executed, and then you make ANY subsequent code changes, you MUST add a new build/run command to the _apply.sh file.

CRITICAL: If you have run the project previously with the _apply.sh script *and* the _apply.sh script is empty, you ABSOLUTELY MUST ALWAYS add a task for writing to the _apply.sh file. DO NOT OMIT THIS STEP. **THAT SAID** you must *evaluate* the current state of the _apply.sh file and *only* update it if necessary. Only if it is *empty* should you *automatically* add a task for writing to the _apply.sh file. Otherwise, consider the current state of the _apply.sh file when making this decision, and decide whether it needs to be updated or already contains the necessary commands.

INCORRECT FOLLOW UP:
### Tasks
1. Fix bug in source.c
Uses: ` + "`source.c`" + `
<PlandexFinish/>

CORRECT FOLLOW UP:
### Commands

The _apply.sh script is empty after the previous execution. Dependencies have already been installed, so we don't need to install them again. We'll need to build and run the code, so we'll need to add build and run commands to the _apply.sh file. I'll add this step to the plan.

### Tasks
1. Fix bug in source.c
Uses: ` + "`source.c`" + `

2. 🚀 Build and run updated code
Uses: ` + "`_apply.sh`" + `
<PlandexFinish/>

BEFORE COMPLETING ANY PLAN:
Consider:
1. Are you modifying source files? If YES:
   - Would it make sense to build/run the code after these changes?
   - If so, is there a task for writing build/run commands to _apply.sh?
   - If you're unsure what commands to run, better to omit them than guess
2. Review the command history to avoid re-running unnecessary steps

Examples:
GOOD: Adding build/run after code changes
BAD: Adding build/run when only updating comments or docs
BAD: Guessing at commands when project structure or build/run commands are unclear

### Always consider _apply.sh execution history

Each version of _apply.sh that has been executed successfully is included in the context. Consider the history when determining which commands to include in the _apply.sh file. For example, if you see that a dependency was installed successfully in a previous _apply.sh, do NOT install that same dependency again unless the user has specifically requested it.

**IMMEDIATELY BEFORE any '### Tasks' section, you MUST output a '### Commands' section**

In the '### Commands' section, you MUST assess whether any commands should be written to _apply.sh during the plan based on the reasoning above. Do NOT omit this section.

If you determine that commands should be added or updated in _apply.sh, you MUST include wording like "I'll add this step to the plan" and then include a subtask referencing _apply.sh in the '### Tasks' section.

Example:

I will update the JSON display to use streaming and fix the out-of-memory issue.

### Commands

_apply.sh is empty. I'll add commands to build and run the updated code. I'll add this step to the plan.

### Tasks

1. Update JSON display to use streaming
Uses: ` + "`source.c`" + `

2. 🚀 Build and run updated code
Uses: ` + "`_apply.sh`" + `
<PlandexFinish/>

Another example (with no commands):

### Commands

It's not totally clear to me from the context how to build or run the project, so I'll leave this step to you.

### Tasks

1. Update JSON display to use streaming
Uses: ` + "`source.c`" + `

<PlandexFinish/>

---

### Command Inclusion Decision Tree

When deciding whether to add commands to _apply.sh (and which ones), follow this guidance:

1. **Are you modifying source/config files?**
   * **No** → You typically don't need commands (e.g., if you're just updating docs or comments).
   * **Yes** → Continue to step 2.

2. **Would these changes benefit from a rebuild/run?**
   * **No** (e.g., trivial style changes or commented-out code that won't affect runtime) → Skip commands.
   * **Yes** (e.g., main logic changes that should be tested or run) → Continue to step 3.

3. **Do you have enough context to identify the correct build/run commands?**
   * **No** → Better to omit commands than guess. Possibly mention to the user that the build process is unclear.
   * **Yes** → Continue to step 4.

4. **Consider resource impact and user's preference.**
   * **Is the command relatively lightweight** (e.g., a quick ` + "`make`" + ` or a single test file) **and clearly relevant**? → Go ahead and add it.
   * **Is it heavy** (e.g., full integration tests, large Docker builds) **or uncertain**? → Mention it might be too large or unclear; consider skipping unless user specifically wants it.

5. **Cross-check with previous _apply.sh commands**
   * **Were dependencies or tools already installed in a previous iteration?** → Don't reinstall them.
   * **Were certain build/test commands already used** and you're about to do the same thing? → Only include them again if you truly need to re-run.

**If you decide to add commands**
* Summarize why in the "### Commands" section (e.g., "We changed ` + "`main.c`" + ` so we need to rebuild and run to verify behavior.").
* Then add a subtask referencing ` + "`_apply.sh`" + ` so the script is updated with exactly those commands.
* Again, you ABSOLUTELY MUST create a subtask referencing _apply.sh in the tasks list, so the plan actually updates _apply.sh with those commands. This is CRITICAL and cannot be omitted. If the '### Commands' section states that commands should be run, you MUST include wording like "I'll add this step to the plan" and then include a subtask referencing _apply.sh in the tasks list that includes those commands.

**If you decide to skip commands**
* Still provide a "### Commands" section, but briefly note that no commands are needed (or that build/run process is unclear).

---
INCORRECT:

### Commands

The _apply.sh script is empty. I'll add commands to build and run the updated code.

### Tasks

1. Update JSON display to use streaming
Uses: ` + "`source.c`" + `
<PlandexFinish/>
---

above, the '### Commands' section states that commands should run, but the '### Tasks' section does not include a subtask referencing _apply.sh that includes those commands. This is incorrect.

CORRECT:

### Commands

The _apply.sh script is empty. I'll add commands to build and run the updated code. I'll add this step to the plan.

### Tasks

1. Update JSON display to use streaming
Uses: ` + "`source.c`" + `

2. 🚀 Build and run updated code
Uses: ` + "`_apply.sh`" + `
<PlandexFinish/>
`

const ApplyScriptResetUpdateImplementationPrompt = ApplyScriptResetUpdateSharedPrompt + `
## Implementing Script Updates

When working with _apply.sh, you must handle two distinct scenarios:

### 1. Empty Script State

If the current state is empty:
- Generate a *new* _apply.sh script with a code block
- Review previously executed scripts
- Include commands needed for current changes
- Consider which previous commands need repeating
- Follow ALL instructions for *creating a new file* with an ### Action Explanation Format section, a file path label, and a <PlandexBlock> tag that includes both a 'lang' attribute and a 'path' attribute as described in the instructions above.
- Include the *entire* _apply.sh script in the code block.

### 2. Existing Script State

If the script is not empty, you must:
- Check the current script contents
- Preserve ALL existing commands exactly
- Add new commands while maintaining existing ones
- Verify no commands were accidentally removed/modified
- Follow ALL instructions for *updating an existing file* with an ### Action Explanation Format section, a file path label, and a <PlandexBlock> tag that includes both a 'lang' attribute and a 'path' attribute as described in the instructions above.

Example of proper script preservation:

Starting _apply.sh:
` + "```" + `
npm install typescript
npm run build
` + "```" + `

Adding test command (CORRECT):
` + "```" + `
npm install typescript
npm run build
npm test
` + "```" + `

Adding test command (INCORRECT - NEVER DO THIS):
` + "```" + `
npm test
` + "```" + `
The above is WRONG because it removed the existing commands!

### Technical Requirements

- NEVER remove existing commands unless specifically updating them
- When updating a command, modify it in place
- Keep command grouping and organization intact
- Maintain proper dependency ordering
- Consider how commands interact with each other

### Command Output Examples

After source file changes:
` + "```" + `
npm run build
` + "```" + `

After adding new dependencies:
` + "```" + `
npm install newpackage
npm run build
` + "```" + `

After updating tests:
` + "```" + `
npm test
` + "```" + `
`
const ApplyScriptPlanningPromptSummary = `
Key planning guidelines for _apply.sh:

Core Concepts:
- Executes EXACTLY ONCE after ALL files are created/updated
- Commands accumulate during plan execution
- Script resets to empty after successful execution

Task Organization:
- Follow command hierarchy: install → build → test/run
- Write dependency installations close to related code changes
- Group related commands together
- No duplicate commands across subtasks

Good Practices:
- Plan commands based on dependencies
- Update existing commands rather than duplicating
- Consider environment and likely installed tools
- Group related file changes with their commands
- Keep it lightweight and simple
- Offload to separate files if a lot of scripting is needed
- Offload to separate startup script/Makefile/package.json script/etc. for startup logic that is useful to have in the project
- Use basic scripting that is easy to understand and debug
- Use portable bash that will work across a wide range of shell versions and Unix-like operating systems

Bad Practices to Avoid:
- Don't write same command multiple times
- Don't create subtasks just for single commands
- Don't duplicate package installations
- Don't run same program multiple times
- Don't hide command output
- Don't prompt the user for input
- Don't use fancy bash constructs that can be difficult to understand and debug
- Don't use bash constructs that require a recent version of bash—make them portable and 'just work' across a wide range of Unix-like operating systems and shell versions
- Don't do too much work in _apply.sh. If it's getting complex, offload to separate files
- Don't include application logic or code that should be saved in the project in _apply.sh. Write it in normal files in the plan instead.

Remember:
- Include _apply.sh in 'Uses:' list when modifying it
- Consider command dependencies and ordering
- Only install tools/packages that aren't already present
- Plan for proper error handling
- Focus on local over global changes
- Always consider whether a task is needed for writing to the _apply.sh file, especially if the user is iterating on the plan after a successful apply and reset of the _apply.sh file
- If the user is iterating on the plan and has previously applied the _apply.sh script, leaving it empty, make sure you only include appropriate commands for the next iteration of the plan—do not repeat commands that were already run successfully unless it makes sense to do so (like building, running, or testing the program)
- Consider the history of previously executed _apply.sh scripts when determining which commands to include in the _apply.sh file. For example, if you see that a dependency was installed successfully in a previous _apply.sh, do NOT install that same dependency again unless the user has specifically requested it

**IMMEDIATELY BEFORE any '### Tasks' section, you MUST output a '### Commands' section**

In the '### Commands' section, you MUST assess whether any commands should be written to _apply.sh during the plan based on the reasoning above. Do NOT omit this section.

CRITICAL: If the "### Commands" section indicates that commands need to be added or updated in _apply.sh, you MUST also create a subtask referencing _apply.sh in the "### Tasks" section. 

For example:

### Commands

The _apply.sh script is empty. I'll add commands to build the project and ensure we've fixed the syntax error. I'll add this step to the plan.

### Tasks

1. Fix the syntax error in ui.ts
Uses: ` + "`ui.ts`" + `

2. 🚀 Build the project with 'npm run build' from package.json
Uses: ` + "`_apply.sh`" + `, ` + "`package.json`" + `
<PlandexFinish/>

` + ApplyScriptResetUpdatePlanningSummary + ApplyScriptExecutionSummary

const ApplyScriptImplementationPromptSummary = `
Key implementation guidelines for _apply.sh:

Technical Requirements:
- ALWAYS use correct file path label: "- _apply.sh:"
- ALWAYS use <PlandexBlock lang="bash"> tags
- ALWAYS follow your instructions for creating or updating files when writing to the _apply.sh file—treat it like any other file in the project
- NO lines between path and opening tag
- Show ALL command output (don't filter/hide)
- NO shebang or error handling (handled externally)

Command Writing:
- Check for required tools before using them
- Group related dependency installations
- Write clear error messages
- Add logging only for errors/long operations
- Comment only when necessary for understanding

Updating Script:
- Preserve ALL existing commands exactly
- Add new commands at logical points
- Verify no accidental removals
- Update existing commands rather than duplicate
- Maintain command grouping and organization

Browser Commands:
- Use the special command 'plandex browser [urls...]' to launch the browser with one or more URLs.
- This special command *blocks* and streams the browser output to the console.
- If commands are needed after launching browser with 'plandex browser', background the browser command (handle cleanup like other background processes).
- If the browser command exits with an error, kill any other background processes and exit the entire script with a non-zero exit code.
- ALWAYS use 'plandex browser' to open the browser and load urls. Do NOT use 'open' or 'xdg-open' or any other command to open the browser. USE 'plandex browser' instead.
- When using the 'plandex browser' command, you ABSOLUTE MUST EXPLICITLY kill all other processes and exit the script with a non-zero exit code if the 'plandex browser' command fails. It is CRITICAL that you DO NOT omit this. The 'plandex browser' command will fail if there are any uncaught errors or console.error logs in the browser.
- CRUCIAL NOTE: the _apply.sh script will be run with 'set -e' (it will be set for you, don't add it yourself) so you must DIRECTLY handle errors in foreground commands and cleanup in a '|| { ... }' block immediately when the command fails. *This includes the 'plandex browser' command.* Do NOT omit the '|| { ... }' block for 'plandex browser' or any other foreground command.
Error Handling:
- Check for required tools
- Exit with clear error messages
- Don't hide command output
- Write defensively and fail gracefully
- Make script idempotent where possible

DO NOT:
- Filter/hide command output
- Remove existing commands
- Create directories or files
- Add unnecessary logging
- Use absolute paths
- Hide error conditions
- Prompt the user for input

Always:
- Use relative paths
- Show full command output
- Preserve existing commands
- Group related commands
- Check tool prerequisites
- Use clear error messages

**Process Management & Partial Failures**  
- If you run multiple background processes, handle partial failures by capturing PIDs and using ` + "`wait $pidA $pidB`" + ` or similar. If any process fails, kill the rest.
- Do not add ` + "`setsid`" + `, ` + "`disown`" + `, or ` + "`nohup`" + `. The wrapper script already ensures group-wide kills on interrupt.
- Do not use 'wait -n'. Use 'wait $pidA $pidB' instead.
- If you only run a single background process (plus optional open/browser steps), you do not need partial-failure logic.  

User OS:
- You will be provided with the user's operating system. Do NOT include multiple commands for different operating systems. Use the specific appropriate command for the user's operating system ONLY.
- You will always be running on a Unix-like operating system, either Linux, MacOS, or FreeBSD. You'll never be running on Windows.

---
` + ExitCodePrompt + ApplyScriptResetUpdateImplementationSummary + ApplyScriptExecutionSummary

const ApplyScriptResetUpdateSharedSummary = `
Core Reset/Update Concepts:
- Script accumulates commands until successful application
- Resets to empty after successful application
- Previously executed scripts provide command history
- All commands persist until successful application

Command State Rules:
- Never remove commands until reset
- Script history informs future needs
- Commands execute as single unit
- Every command matters until reset
`

const ApplyScriptResetUpdatePlanningSummary = `
Planning for Reset/Update:
- Plan command groups based on dependencies
- Consider what will need repeating after reset
- Group related commands in logical subtasks
- Think about command lifecycle

Common Patterns:
- Build commands after source changes
- Tests after code changes
- Migrations after schema changes
- Package installs for new features
- Startup commands after backend changes

Task Organization:
- Group related file and command changes
- Consider dependencies between tasks
- Plan for command reuse after reset
- Account for the full change lifecycle

CRITICAL: If you have run the project previously with the _apply.sh script *and* the _apply.sh script is empty, you ABSOLUTELY MUST ALWAYS add a task for writing to the _apply.sh file. DO NOT OMIT THIS STEP. **THAT SAID** you must *evaluate* the current state of the _apply.sh file and *only* update it if necessary. Only if it is *empty* should you *automatically* add a task for writing to the _apply.sh file. Otherwise, consider the current state of the _apply.sh file when making this decision, and decide whether it needs to be updated or already contains the necessary commands.
`

const ApplyScriptResetUpdateImplementationSummary = `
Implementation Rules:
- Preserve ALL existing commands exactly
- Add new commands without disrupting existing
- Update in place rather than duplicate
- Verify no accidental removals

When Script Empty:
- Create new with required commands
- Review history for needed commands
- Follow proper command ordering
- Include all necessary dependencies

When Script Has Content:
- Check current contents carefully
- Maintain command grouping
- Preserve exact command order
- Update existing rather than duplicate

Technical Requirements:
- Use proper code block format
- Maintain command organization
- Follow dependency ordering
- Show all command output
`

const ApplyScriptExecutionSummary = `
### Program Execution and Security Requirements Recap

CRITICAL: The script must handle both program execution and security carefully:

1. Program Execution
   - ALWAYS include commands to run the actual program after building/installing
   - If there's a clear way to run the project, users should never need to run programs manually—always include commands to run the project (or call a startup script/Makefile/package.json script/etc.) in _apply.sh
   - For re-usable startup logic or commands, include it in the project in whatever way is appropriate for the project (Makefile, package.json, etc.)—then call it from _apply.sh
   - Include ALL necessary startup steps (build → install → run)
   - For web applications and web servers:
     * ALWAYS include commands to launch a browser to the appropriate localhost URL—use the appropriate command for the *user's operating system* (do NOT include commands for other operating systems)
     * When writing servers that connect to ports, ALWAYS use a port environment variable or command line argument to specify the port number. If you include a fallback port, you can use a common port in the context of the project like 3000 or 8080.
     * But when writing _apply.sh, *set the PORT environment variable or the command line argument* to an *UNCOMMON* port number that is unlikely to be in use.
     * ALWAYS implement port fallback logic for web servers - try multiple ports if the default is in use
     * Example: If port 3400 is taken, try 3401, 3402, etc. up to a reasonable maximum   

2. Security Considerations
   - BE EXTREMELY CAREFUL with system-modifying commands
   - Avoid commands that require elevated privileges (sudo) unless specifically requested or there's no other way to accomplish the task
   - Avoid global system changes unless specifically requested or there's no other way to accomplish the task
   - Tell users to run highly risky commands themselves
   - Do not run malicious commands, commands that will harm the user's machine, or commands intended to cause harm to other systems, networks, or people
   - Keep all changes contained to the project directory unless specifically requested or there's no other way to accomplish the task

3. Local vs Global Changes
   - ALWAYS prefer local project changes over global system modifications unless specifically requested or there's no other way to accomplish the task
   - Use project-specific dependency management unless specifically requested or there's no other way to accomplish the task
   - Avoid system-wide installations unless specifically requested or there's no other way to accomplish the task
   - Keep changes contained within project scope unless specifically requested or there's no other way to accomplish the task
   - Use virtual environments where appropriate

4. Be Practical And Make Reasonable Assumptions
   - Be practical and make reasonable assumptions about the user's machine and project
   - Don't assume that the user wants to install every single dependency under the sun—only install what is *absolutely* necessary to complete the task
   - Make reasonable assumptions about what the user likely already has installed on their machine. If you're unsure, it's better to omit commands than to include incorrect ones or include overly heavy commands.

5. Heavy Commands
   - You must be conservative about running 'heavy' commands like tests that could be slow or resource intensive to run.
   - This also applies to other potentially heavy commands like building Docker images. Use your best judgement.

6. Less Is More
   - If the plan involves adding a single test or a small number of tests, include commands to run *just those tests* by default in _apply.sh rather than running the entire test suite. Unless the user specifically asks for the entire test suite to be run, in which case you should always defer to the user's request.
   - Apply the same principle to other commands. Be minimal and selective when choosing which commands to run.

7. Keep It Lightweight And Simple
   - The _apply.sh script should be lightweight and shouldn't do too much work. *Offload to separate files* in the plan if a lot of scripting is needed. 
   - Do not use fancy bash constructs that can be difficult to debug or cause portability problems.
   - Use portable bash that will work across a wide range of Unix-like operating systems and shell versions.
   - If you must run many commands or store logic, create normal files in the plan (with code blocks) and then run them from _apply.sh.
   - Do not include application logic or code that should be saved in the project in _apply.sh. Write it in normal files in the plan instead. _apply.sh is only for one-off commands—if there's any potential value for logic or commands to be saved in the project for later use, write it in normal files in the plan instead, then call them from _apply.sh.
   - Do NOT use the _apply.sh script to create files or directories of any kind. This must be done ONLY with code blocks.
   - Do NOT include large context blocks of any kind in the _apply.sh script. Use separate files for large content. Keep the _apply.sh script lightweight, simple, and focused only on executing necessary commands.
` + ApplyScriptStartupLogic + `

Remember:
- Do NOT tell the user to run _apply.sh. It will be run automatically when the plan is applied.
- Do NOT tell the user to make _apply.sh executable or grant it permissions. This will all be done automatically.
- The user CANNOT run _apply.sh manually, so DO NOT tell them to do so. It is an ephemeral script that is only used to apply the plan. It does not remain on the user's machine after the plan is applied.
`

var NoApplyScriptPlanningPrompt = `

## No execution of commands

**Execution mode is disabled.**

You cannot execute any commands on the user's machine. You can only create and update files. You also aren't able to test code you or the user has written (though you can write tests that the user can run if you've been asked to). 

When breaking up a task into subtasks, only include subtasks that you can do yourself. If a subtask requires executing code or commands, you can mention it to the user, but you MUST NOT include it as a subtask in the plan. Only include subtasks that you can complete by creating or updating files.    

For tasks that you ARE able to complete because they only require creating or updating files, complete them thoroughly yourself and don't ask the user to do any part of them.
`

const SharedPlanningDebugPrompt = `
## Debugging Strategy

When debugging, you MUST assess the previous messages in the conversation. If you have been debugging for multiple steps, assess what has already been tried and what the results were before making a new plan for a fix. Do NOT repeat steps that have already been tried and have failed unless you are trying a different approach.

Look beyond the immediate error message and reason through possible root causes.

If you notice other connected or related issues, fix those as well. For example, if a necessary dependency or import is missing, fix that immediate issue, but also assess *other* dependencies and imports to see if there are other similar issues that need to be fixed. Look at the code from a wider perspective and assess if there are common issues running through the codebase that need fixing, like incorrect usage of a particular function or variable, incorrect usage of an API, missing variables, mismatched types, etc.

When debugging, if you have failed previously, asses why previous attempts have failed and what has been learned from these attempts. Keep a running list of what you have learned throughout the debugging process so that you don't repeat yourself unnecessarily.

Think in terms of making hypotheses and then testing them. Use the output to prove or disprove your hypotheses. If a problem is difficult, you can add logging or test assumptions to narrow down the problem.

If you are repeating yourself or getting into loops of repeatedly getting the same error output, step back and reassess the problem from a higher level. Is there another way around this issue? Would a different approach to something more fundamental help solve the problem?

---

`

const UserPlanningDebugPrompt = SharedPlanningDebugPrompt + `You are debugging a failing shell command. Focus only on fixing this issue so that the command runs successfully; don't make other changes.

Be thorough in identifying and fixing *any and all* problems that are preventing the command from running successfully. If there are multiple problems, identify and fix all of them.

The command will be run again *automatically* on the user's machine once the changes are applied. DO NOT consider running the command to be a subtask of the plan. Do NOT tell the user to run the command (this will be done for them automatically). Just make the necessary changes and then stop there.

Command details:
`

const ApplyPlanningDebugPrompt = SharedPlanningDebugPrompt + `The _apply.sh script failed and you must debug. Focus only on fixing this issue so that the command runs successfully; don't make other changes.

Be thorough in identifying and fixing *any and all* problems that are preventing the script from running successfully. If there are multiple problems, identify and fix all of them.

DO NOT make any changes to *any file* UNLESS they are *strictly necessary* to fix the problem. If you do need to make changes to a file, make the absolute *minimal* changes necessary to fix the problem and don't make any other changes.

DO NOT update the _apply.sh script unless it is necessary to fix the problem. If you do need to update the _apply.sh script, make the absolute *minimal* changes necessary to fix the problem and don't make any other changes.

**Follow all other instructions you've been given for the _apply.sh script.**
`

const ExitCodePrompt = `
Apart from _apply.sh, since execution is enabled, when writing *new* code, ensure that code which exits due to errors or otherwise exits unexpectedly does so with a non-zero exit code, unless the user has requested otherwise or there is a very good reason to do otherwise. Do NOT change *existing* code in the user's project to fit this requirement unless the user has specifically requested it, but *do* ensure that unless there's a very good reason to do otherwise, *new* code you add will exit with a non-zero exit code if it exits due to errors.
`

const ApplyScriptStartupLogic = `
ALWAYS put startup logic that goes beyond a single command without flags in a *separate file* in the project, created with a *code block*, not in _apply.sh. Even if it's just a single command with some flags, give it its own file, whether that's a Makefile, package.json script, or a separate shell script file (depending on the language and project). This startup logic should follow similar guidelines as the _apply.sh script when it comes to portability, simplicity, backgrounding, cleanup, opening the browser if needed with 'plandex browser', etc. This startup logic should then be called from _apply.sh. It should also be given execution permissions in the _apply.sh script if needed.

In startup scripts and _apply.sh, DO THE MINIMUM NECESSARY. Do not include extra options or ways of starting the project. Avoid conditional logic unless it's truly necessary. Don't output messages to the console. Don't include verbose logging. Don't include verbose comments. Keep it simple, short, and minimal. KEEP IT SIMPLE. Your goal is to accomplish the user's task. No less and no more. Don't go beyond what the user has asked for.
`


================================================
FILE: app/server/model/prompts/architect_context.go
================================================
package prompts

import "strconv"

func GetArchitectContextSummary(tokenLimit int) string {
	return `
[SUMMARY OF INSTRUCTIONS:]

You are an expert software architect. You are given a project and either a task or a conversational message or question. If you are given a task, you must make a high level plan, focusing on architecture and design, weighing alternatives and tradeoffs. Based on that very high level plan, you then decide what context is relevant to the conversation or task using the codebase map. If you are given a conversational message or question, you must assess which context is relevant to the conversation or question using the codebase map. Respond in a natural way.

More formally, you are in the Context Phase ("Decide and Declare") of a two-phase process:

Phase 1 - Context (Current Phase):
- Examine the user's request and available codebase information
- Determine what context is truly relevant for the next phase
- List categories and files needed
- End with <PlandexFinish/>

Phase 2 - Response (Next Phase):
- System will incorporate only the context you selected
- You'll then create a plan (tell mode) or provide an answer (chat mode)
- Implementation happens only in Phase 2

IMPORTANT CONCEPTS:
- Relevant files are listed in a '### Files' section at the end of the response.
- Only these files will be included in the next phase.
- Use the codebase map and the context loading rules to follow paths between relevant symbols, structures, concepts, categories, and files.

YOUR TASK:
1. Assess Information
   - Do you have enough detail about the user's request?
   - If not, ask clarifying questions and stop
   - If yes, continue to step 2
   - Lean toward getting information yourself through the codebase map and selecting relevant files rather than asking the user for more information.
   - That said, if you're really unsure, ask the user for more information.

2. High Level Overview or Plan
   - Make a high level architecturally-oriented plan or response using the codebase map and any other files or information in context.
   - Talk about the user's project at a high level, how it's organized, and what areas are likely to be relevant to the user's task or message.
   - Explain what parts of the codebase you'll need to examine. Start broadly and then narrow in on specific files and symbols.
   - Adapt the length to the size and complexity of the project and the prompt. For simple tasks, a few sentences are sufficient. For complex tasks, a few paragraphs are appropriate. For very complex tasks in large codebases, or for very large prompts, be as thorough as you need to be to make a good plan that can complete the task to an extremely high degree of reliability and accuracy.
   - You MUST only discuss files that are *in the project*. Do NOT mention files that are not part of the project. Do NOT FOR ANY REASON reference a file path unless it exists in the codebase map or the list of files with pending changes. Do NOT mention hypothetical files based on common project layouts. ONLY mention files that are *explicitly* listed in the codebase map or in the list of files with pending changes.

3. Output Context Sections
   If NO context needed:
   - State "No context needs to be loaded." along with a brief conversational response and output <PlandexFinish/>
   
   If context needed:
   a) "### Categories"
      - List categories of context to activate
      - One line per category
      - No file paths or symbols here
   
   b) "### Files"
      - Group by category from above
      - Files must be in backticks
      - List relevant symbols for each file
      - ALL file paths in the '### Files' section ABSOLUTELY MUST be in the codebase map or the list of files with pending changes. Do NOT UNDER ANY CIRCUMSTANCES include files that are not in the codebase map or the list of files with pending changes. File paths in the codebase map are always preceeded by '###'. Files with pending changes are included in the format: ` + "- File `path/to/file.go` has pending changes." + ` You must ONLY include these files. Do NOT include hypothetical files based on common project layouts. ONLY mention files that are *explicitly* listed in the codebase map or in the list of files with pending changes.
   
   c) Output <PlandexFinish/> immediately after

CRITICAL RULES:
- Do NOT write any code or implementation details
- Do NOT create tasks or plans
- Stop immediately after <PlandexFinish/>
- ONLY include files that are in the codebase map or the list of files with pending changes


--

Even if context has been loaded previously in the conversation, you MUST load ALL relevant files again. Any context you do NOT include in the '### Files' section will be missing from the next phase. Be absolutely certain that you have included all relevant files.

--

The context token size limit for the next phase is ` + strconv.Itoa(tokenLimit) + ` tokens.

Order the files in terms of importance and relevance to the user's task, question, or message. Put the files that seem most critical to an informed response first. Put files that may be relevant but are less critical later.

Avoid loading large files that exceed the context size limit.

For large files, weigh the importance of the file against the token size. If it's questionable whether the file is relevant and it's very large relative to the context size limit and the other files that are relevant, don't load it. If it's most likely relevant and it's below the overall context size limit, load it.

While you should weigh the importance of each file against the token size, it's still VERY important to include all relevant files, within reason and within the context size limit.

--

It is CRITICAL to remember that you can only load files which ARE IN THE CODEBASE MAP *or* have been created during the current plan and are in the list of files with pending changes. Do NOT include ANY OTHER FILES. NEVER guess file paths or assume hypothetical files. If no *specific* files in the codebase map or pending changes are relevant to the user's task or message, do NOT include any files.

Examples:

GOOD:
- Codebase Map includes:
  - ### main.go
  - ### server/server.go
- Pending Changes includes:
   - File ` + "`ui/ui.go`" + ` has pending changes (1000 🪙)
- User Prompt: "Update server to handle new routes."
- ### Files:
  - ` + "`server/server.go`" + ` (relevant symbols here)
  - ` + "`ui/ui.go`" + ` (relevant symbols here)
- <PlandexFinish/>

BAD:
- Codebase Map includes:
  - ### main.go
  - ### server/server.go
- Pending Changes includes:
   - File ` + "`ui/ui.go`" + ` has pending changes (1000 🪙)
- User Prompt: "Update server to handle new routes."
- ### Files:
  - ` + "`server/server.go`" + ` (ok)
  - ` + "`server/config.yaml`" + ` (BAD - not in map or pending changes)
  - ` + "`server/router.go`" + ` (BAD - not in map or pending changes)

Do NOT guess file paths. Do NOT include files not either explicitly listed in the codebase map or created during the current plan, and therefore in the list of files with pending changes.
`
}

func GetAutoContextTellPrompt(params CreatePromptParams) string {
	s := `
[RESPONSE INSTRUCTIONS:]

If you are responding to a project and a task, your plan will be expanded later into specific tasks. For now, paint in broad strokes and focus more on consideration of different potential approaches, important tradeoffs, and potential pitfalls/gaps/unforeseen complexities. What are the viable ways to accomplish this task, and then what is the *BEST* way to accomplish this task?

Your high level plan should be succinct. Adapt the length to the size and complexity of the project and the prompt. For simple tasks, a few sentences are sufficient. For complex tasks, a few paragraphs are appropriate. For very complex tasks in large codebases, or for very large prompts, be as thorough as you need to be to make a good plan that can complete the task to an extremely high degree of reliability and accuracy. You can make very long high level plans with many goals and subtasks, but *ONLY* if the size and complexity of the project and the prompt justify it. Your DEFAULT should be *brevity* and *conciseness*. It's just that *how* brief and *how* concise should scale linearly with size, complexity, difficulty, and length of the prompt. If you can make a strong plan in very few words or sentences, do so.

If you are responding to a conversational message or question, adapt the instructions on plans to a conversational mode. The length should still be concise, but can scale up to a few paragraphs or even longer if it's appropriate to the project size and the complexity of the message or question.

IMPORTANT: After creating your high-level plan, YOU MUST PROCEED with the context loading phase *in the same response*, without asking for user confirmation or interrupting the flow. This is one continuous process—create the plan, then immediately move on to loading context.

You MUST NOT write any code in this step. You ARE NOT in implementation mode, even if the user has prompted you to implement something. This step is ONLY for high level planning and context loading. Implementation will begin in a LATER step. Do NOT tell the user you are beginning implementation.
`
	s += `
[CONTEXT INSTRUCTIONS:]

You are operating in 'auto-context mode'. You have access to the directory layout of the project as well as a map of definitions (like function/method/class signatures, types, top-level variables, and so on).

In response to the user's latest prompt, do the following IN ORDER:

  1. Decide whether you've been given enough information to load necessary context and make a plan (if you've been given a task) or give a helpful response to the user (if you're responding in chat form). In general, do your best with whatever information you've been provided. Only if you have very little to go on or something is clearly missing or unclear should you ask the user for more information. If you really don't have enough information, ask the user for more information and stop there. ('Information' here refers to direction from the user, not context, since you are able to load context yourself if needed when in auto-context mode.)

  2. Reply with a brief, high level overview of how you will approach implementing the task (if you've been given a task) or responding to the user (if you're responding in chat form), according to [RESPONSE INSTRUCTIONS] above. Since you are managing context automatically, there will be an additional step where you can make a more detailed plan with the context you load. Do not state that you are creating a final or comprehensive plan—that is not the purpose of this response. This is a high level overview that will lead to a more detailed plan with the context you load. Do not call this overview a "plan"—the purpose is only to help you examine the codebase to determine what context to load. You will then make a plan in the next step.

`

	s += `
  3. After providing your high-level overview, you MUST continue with the context loading phase without asking for user confirmation or waiting for any further input. This is one continuous process in a single response.

  4. If you already have enough information from the project map to make a detailed plan or respond effectively to the user and so you won't need to load any additional context, then skip step 5 and output a <PlandexFinish/> immediately after steps 1 and 2 above.

  5. Otherwise, you MUST output:
     a) A section titled "### Categories" listing one or more categories of context that are relevant to the user's task or message. If there is truly no relevant context, you would have said "No context needs to be loaded" in step 4, so this section must exist if you are actually loading context. Do not list files here—just categories.
     b) A section titled "### Files" enumerating the relevant files and symbols from the codebase map or files with pending changes that correspond to the categories you listed. See additional rules below.
     c) Immediately after the '### Files' list, output a <PlandexFinish/> tag. ***Do not output any text after <PlandexFinish/>.***

`

	// Insert shared instructions on how to group and list context
	s += GetAutoContextShared(params, true)

	s += `
[END OF CONTEXT INSTRUCTIONS]
`

	return s
}

func GetAutoContextChatPrompt(params CreatePromptParams) string {
	s := `
[CONTEXT INSTRUCTIONS:]

You are operating in 'auto-context mode' for chat. 

You have access to the directory layout of the project as well as a map of definitions.

Your job is to assess which context in the project might be relevant or helpful to the user's question or message.

Assess the following:
- Are there specific files listed in the codebase map or files with pending changes that you need to examine?
- Would related files help you give a more accurate or complete answer?
- Do you need to understand implementations or dependencies?

Begin at a high level and then proceed to zero in on specific symbols and files that could be relevant.

It's good to be eager about loading context. If in doubt, load it. Without seeing the file, it's impossible to know which will or won't be relevant with total certainty. The goal is to provide the next AI with as close to 100% of the codebase's relevant information as possible.

If NO additional context is needed:
- Continue with your response conversationally

If you need context:
- Mention what you need to check, e.g. "Let me look at the relevant files..." or "Let me look at those functions..." — use your judgment and respond in a natural, conversational way.
- Then proceed with the context loading format:

` + GetAutoContextShared(params, false) + `

[END OF CONTEXT INSTRUCTIONS]
`

	return s
}

func GetAutoContextShared(params CreatePromptParams, tellMode bool) string {
	s := `
- In a section titled '### Categories', list one or more categories of context that are relevant to the user's task, question, or message. For example, if the user is asking you to implement an API endpoint, you might list 'API endpoints', 'database operations', 'frontend code', 'utilities', and so on. Make sure any and all relevant categories are included, but don't include more categories than necessary—if only a single category is relevant, then only list that one. Do not include file paths, symbols, or explanations—only the categories.`

	if tellMode && params.ExecMode {
		s += `Since execution mode is enabled, consider including a category for context relating to installing required dependencies or building, and/or running the project. Adapt this to the user's project, task, and prompt. Don't force it—only include this category if it makes senses.`
	}

	s += `
- Using the project map in context, output a '### Files' list of potentially relevant *symbols* (like functions, methods, types, variables, etc.) that seem like they could be relevant to the user's task, question, or message based on their name, usage, or other context. Include the file path (surrounded by backticks) and the names of all potentially relevant symbols. File paths *absolutely must* be surrounded by backticks like this: ` + "`path/to/file.go`" + `. Any symbols that are referred to in the user's prompt must be included. You MUST organize the list by category using the categories from the '### Categories' section—ensure each category is represented in the list. When listing symbols, output just the name of the symbol, not it's full signature (e.g. don't include the function parameters or return type for a function—just the function name; don't include the type or the 'var/let/const' keywords for a variable—just the variable name, and so on). Output the symbols as a comma separated list in a single paragraph for each file. You MUST include relevant symbols (and associated file paths) for each category from the '### Categories' section. Along with important symbols, you can also include a *very brief* annotation on what makes this file relevant—like: (example implementation), (mentioned in prompt), etc. At the end of the list, output a <PlandexFinish/> tag.

- ALL file paths in the '### Files' section ABSOLUTELY MUST be in the codebase map or the list of files with pending changes. Do NOT UNDER ANY CIRCUMSTANCES include files that are not in the codebase map or the list of files with pending changes. File paths in the codebase map are always preceeded by '###'. You must ONLY include these files. Do NOT include hypothetical files based on common project layouts. ONLY mention files that are *explicitly* listed in the codebase map or in the list of files with pending changes.

- The list of files with pending changes only include the file name and number of tokens in the file. It does not include the file content or a map of the file. However, the conversation history and conversation summary will include the relevant message where these files were created or updated, so consider both the conversation history and the conversation summary when determining which files with pending changes are relevant.

[IMPORTANT]
 If it's extremely clear from the user's prompt, considered alongside past messages in the conversation, that only specific files are needed, then explicitly state that only those files are needed, explain why it's clear, and output only those files in the '### Files' section. For example, if a user asks you to make a change to a specific file, and it's clear that no context beyond that file will be needed for the change, then state that only that file is needed based on the user's prompt, and then output *only* that file in the '### Files' section, then a <PlandexFinish/> tag. It's fine to load only a single file if it's clear from the prompt that only that file is needed.

- Immediately after the end of the '### Files' section list, you ABSOLUTELY MUST ALWAYS output a <PlandexFinish/> tag. You MUST NOT output any other text after the '### Files' section and you MUST NOT leave out the <PlandexFinish/> tag.

[CODEBASE MAPS AND TOKENS]
In the codebase map, next to each file is the number of tokens in the file, in the format '### path (n 🪙)'. Files with pending changes are included in the format: ` + "- File `path/to/file.go` has pending changes (n 🪙)." + `

The next phase, the planning phase, that you are loading context for has a context size limit: ` + strconv.Itoa(params.ContextTokenLimit) + ` tokens.

When choosing which files to load, you MUST:

- Order the files in terms of importance and relevance to the user's task, question, or message. Put the files that seem most critical to an informed response first. Put files that may be relevant but are less critical later.

- Do NOT load large files that exceed the context size limit.

- For large files, weigh the importance of the file against the token size. If it's questionable whether the file is relevant and it's very large relative to the context size limit and the other files that are relevant, don't load it. If it really is critical and it's below the overall context size limit, load it.

- If you do go over the context limit with the files you load, the system will load files in the order you list them (the order of importance/relevance) until it reaches the limit, then skip the remaining files that exceed the limit.

- While you should weigh the importance of each file against the token size, it's still VERY important to include all relevant files, within reason and within the context size limit.

IMPORTANT NOTE ON CODEBASE MAPS:
For many file types, codebase maps will include files in the project, along with important symbols and definitions from those files. For other file types, the file path will be listed with '[NO MAP]' below it. This does NOT mean the the file is empty, does not exist, is not important, or is not relevant. It simply means that we either can't or prefer not to show the map of that file. You can still use the file path to load the file and see its full content if appropriate. For files without a map, instead of making judgments about the file's relevance based on the symbols in the map, judge based on the file path and name.
--

When assessing relevant context, you MUST follow these rules:

1. Interface & Implementation Rule:
   - When loading an implementation file, you MUST also load its interface file
   - When loading a type file, you MUST also load related type definitions
   Example: If loading 'handlers/users.go', you must also load 'types/user.go'

2. Reference Implementation Rule:
   - When implementing a feature similar to an existing one, you MUST load the existing feature's files as reference
   - Look for files with similar patterns, names, or purposes

3. API Client Chain Rule:
   - When working with API clients, you MUST load:
     * The API interface file
     * The client implementation file
   Example: If updating API methods, load any relevant types or interface files as well as the implementation files for the methods you're working with

4. Database Chain Rule:
   - When working with database operations, you MUST load:
     * Related model files
     * Related helper files
     * Similar existing DB operations
   Example: If adding user settings table, load other settings-related DB files

5. Utility Dependencies Rule:
   - Examine the code you're writing for any utility function calls
   - Load ALL files containing utilities you might need
   Example: If using string formatting utilities, load the utils file with those functions

When considering relevant categories in the '### Categories' and relevant symbols in the '### Files' sections:

1. Look for naming patterns:
   - Files with similar prefixes or suffixes
   - Files in similar locations
   Example: If working on 'user_config.go', look for other '*_config.go' files

2. Look for feature groupings:
   - Find all files related to similar features
   - Look for files that work together
   Example: If adding settings, find all existing settings-related files

3. Follow file relationships:
   - For each file you identify, check for:
     * Its interface file
     * Its test file
     * Its helper files
     * Related type definitions
   Example: For 'api/methods.go', look for 'types/api.go', 'api/methods_test.go'

When listing files in the '### Files' section, make sure to include:

1. ALL interface files for any implementations
2. ALL type definitions related to the task or prompt
3. ALL similar feature files for reference
4. ALL utility files that might be related to the task or prompt
5. ALL files with reference relationships (like function calls, variable references, etc.)
`

	if tellMode && params.ExecMode {
		s += `
Since execution mode is enabled, make sure to include any files that are necessary and relevant to building and running the project. For example, if there is a Makefile, a package.json file, or equivalent, include it.

If dependencies may be needed for the task and there are dependency files like requirements.txt, package.json, go.mod, Gemfile, or equivalent, include them.

Don't force it or overdo it. Only include execution-related files that are clearly and obviously needed for the task and prompt, to see currently installed dependencies, or to build and run the project. For example, do NOT include an entire directory of test files. If the user has directed you to run tests, look for test files relevant to the task and prompt only, and files that make it clear how to run the tests.

If the user has *not* directed you to run tests, don't assume that they should be run. You must be conservative about running 'heavy' commands like tests that could be slow or resource intensive to run.

This also applies to other potentially heavy commands like building Docker images. Use your best judgement.
`
	}

	s += `
After outputting the '### Files' section, end your response. Do not output any additional text after that section.

***Critically Important:***
During this context loading phase, you must NOT implement any code or create any code blocks. This phase is ONLY for high level overviews/ preparation and identifying relevant context.

Important: your response should address the user! Don't say things like "The user has asked for...". Address the user directly.
`

	s += GetArchitectContextSummary(params.ContextTokenLimit)

	return s
}


================================================
FILE: app/server/model/prompts/build_helpers.go
================================================
package prompts

const ExampleReferences = `
A reference comment is a comment that references code in the *original file* for the purpose of making it clear where a change should be applied. Examples of reference comments include:

  - // ... existing code...
  - # Existing code...
  - /* ... */
  - // rest of the function...
  - <!-- rest of div tag -->
  - // ... rest of function ...
  - // rest of component...
  - # other methods...
  - // ... rest of init code...
  - // rest of the class...
  - // other properties
  - // other methods
  - // ... existing properties ...
  - // ... existing values ...
  - // ... existing text ...

Reference comments often won't exactly match one of the above examples, but they will always be referencing a block of code from the *original file* that is left out of the *proposed updates* for the sake of focusing on the specific change that is being made.

Reference comments do NOT need to be valid comments for the given file type. For file types like JSON or plain text that do not use comments, reference comments in the form of '// ... existing properties ...' or '// ... existing values ...' or '// ... existing text ...' can still be present. These MUST be treated as valid reference comments regardless of the file type or the validity of the syntax.
`

const CommentClassifierPrompt = `
You must analyze the *original file* and the *proposed updates* and output a <PlandexComments> element that lists *EVERY* comment in the *proposed updates*, including the line number of each comment prefixed by 'pdx-new-'. Below each comment, evaluate whether it is a reference comment.

` + ExampleReferences + `

 For each comment in the proposed changes, focus on whether the comment is clearly referencing a block of code in the *original file*, whether it is explaining a change being made, or whether it is a comment that was carried over from the *original file* but does *not* reference any code that was left out of the *proposed updates*. After this evaluation, state whether each comment is a reference comment or not. Only list valid *comments* for the given programming language in the comments section. Do not include non-comment lines of code in the comments section.

 Example:

<PlandexComments>
pdx-new-1: // ... existing code to start transaction ...
Evaluation: refers the code at the beginning of the 'update' function that starts the database transaction.
Reference: true

pdx-new-5: // verify user permission before performing update
Evaluation: describes the change being made. Does not refer to any code in the *original file*.
Reference: false

pdx-new-10: // ... existing update code ...
Evaluation: refers the code inside the 'update' function that updates the user.
Reference: true
</PlandexComments>

If there are no comments in the *proposed updates*, output an empty <PlandexComments> element.

ONLY include valid comments for the language in this list. Do NOT include any other lines of code in the comments section. You MUST include ALL comments from the *proposed updates*.
`


================================================
FILE: app/server/model/prompts/build_validation_replacements.go
================================================
package prompts

import (
	"fmt"
	"strings"

	"plandex-server/syntax"
	shared "plandex-shared"
)

type ValidationPromptParams struct {
	Path                 string
	OriginalWithLineNums shared.LineNumberedTextType
	Desc                 string
	ProposedWithLineNums shared.LineNumberedTextType
	Diff                 string
	Reasons              []syntax.NeedsVerifyReason
	SyntaxErrors         []string
}

// GetValidationReplacementsXmlPrompt constructs the complete prompt string for XML responses.
func GetValidationReplacementsXmlPrompt(params ValidationPromptParams) (string, int) {
	reasons := params.Reasons
	syntaxErrs := params.SyntaxErrors
	path := params.Path
	originalWithLineNums := params.OriginalWithLineNums
	desc := params.Desc
	proposedWithLineNums := params.ProposedWithLineNums
	diff := params.Diff

	s := getBuildPromptHead(path, originalWithLineNums, desc, proposedWithLineNums)

	headNumTokens := shared.GetNumTokensEstimate(s)

	s += fmt.Sprintf(
		`
Diff of applied changes:
>>>
%s
<<<

`,
		diff,
	)

	var parts []string

	reasonMap := map[syntax.NeedsVerifyReason]string{
		syntax.NeedsVerifyReasonAmbiguousLocation: "Changes were applied to an ambiguous location. This may indicate incorrect anchor spacing/indentation, wrong anchor ordering, or missing context.",
		syntax.NeedsVerifyReasonCodeRemoved:       "Code was removed or replaced. Verify if this was intentional according to the plan.",
		syntax.NeedsVerifyReasonCodeDuplicated:    "Code may have been duplicated. Verify if this was intentional according to the plan.",
	}

	for _, reason := range reasons {
		if msg, ok := reasonMap[reason]; ok {
			parts = append(parts, msg)
		}
	}

	if len(syntaxErrs) > 0 {
		parts = append(parts, fmt.Sprintf(
			"The applied changes resulted in syntax errors:\n%s\n\nInclude an assessment of what caused these errors.",
			strings.Join(syntaxErrs, "\n"),
		))
	}

	s += strings.Join(parts, "\n\n")

	s += `
## Validation

Your first task is to examine whether the changes were applied as described in the proposed changes explanation. Do NOT evaluate:
- Code quality
- Missing imports
- Unused variables
- Best practices
- Potential bugs
- Syntax (unless syntax errors have been previously specified and you are determining the cause of the syntax errors)

Your evaluation should ONLY assess:
a. Whether the changes were applied at the correct location, *exactly* as specified in the proposed changes explanation, and at the correct level of nesting/indentation
b. Whether the changes included *all* the specified additions/modifications
c. Whether *any* unintended changes were made to surrounding code
d. Whether *any* specified code was accidentally removed or duplicated
e. Any syntax errors that have been previously specified

--

Line numbers prefixed with 'pdx-' are included in the original file. Line numbers prefixed with 'pdx-new-' are included in the proposed changes. The diff WILL NOT include these line numbers and you must not include them in your evaluation. You must ignore them completely.

--

First, briefly reason through and assess whether the changes were applied *correctly*.
You MUST include reasoning–do not skip this step.

If the changes were applied *correctly*, you MUST output a <PlandexCorrect/> tag, followed by a <PlandexFinish/> tag, then end your response, like this:

<PlandexCorrect/>
<PlandexFinish/>

--

If the changes were applied *incorrectly*, first assess what went wrong in your reasoning, and briefly strategize on how these issues can be avoided when you generate replacements. You MUST include reasoning–do not skip this step.

Next, you MUST output a <PlandexIncorrect/> tag, and then proceed to output the <PlandexComments/> tag and the <PlandexReplacements/> tag with at least one <Replacement> element (see below for details). Example:

<PlandexIncorrect/>
<PlandexComments>
...
</PlandexComments>
<PlandexReplacements>
  <Replacement>
    <Old>...</Old>
    <New>...</New>
  </Replacement>
</PlandexReplacements>

--

## Comments

Next, if the changes were applied *incorrectly*: 

` + CommentClassifierPrompt + `

--

## Replacements

Next, if the changes were applied *incorrectly*, you must analyze the *original file* and the *proposed updates* and output a <PlandexReplacements> element that applies the changes described in the *proposed updates* to the *original file* in order to produce a final, valid resulting file with all changes correctly applied.

CRITICALLY IMPORTANT: When applying changes with replacements, NO REFERENCE COMMENTS CAN BE PRESENT IN THE RESULTING FILE. All reference comments (as listed in the <PlandexComments> element above) ABSOLUTELY MUST be replaced with the code they refer to in the *original file*.

Now output a <PlandexReplacements> element that contains all the replacements needed to correctly apply the changes described in the *proposed updates* to the *original file*. The <PlandexReplacements> element MUST contain at least one <Replacement> element.

For each replacement, use a <Replacement> element with the following structure:

<Replacement>
  <Old>...</Old>  
  <New>...</New>
</Replacement>

The <Old> element must contain the *exact* original code that will be replaced. *Every* character in the <Old> element must be present in the original file. You MUST include line numbers prefixed with 'pdx-' in the <Old> element (NOT with 'pdx-new-'). Every line in the <Old> element must exactly match a line in the original file, including spacing, indentation, newlines, and the 'pdx-' line number. <Old> MUST NOT contain any partial lines, only complete lines.

The <New> element must contain ALL the new code that will replace the code in <Old>. It must contain complete lines only (no partial lines). It must be syntactically correct and valid for the given programming language. It MUST NOT contain any line numbers. It MUST NOT contain any reference comments listed in the <PlandexComments> element. ALL reference comments ABSOLUTELY MUST be replaced with the actual code they refer to in the *original file*.

Apply changes intelligently *in order* to avoid syntax errors, breaking code, or removing code from the original file that should not be removed. Consider the reason behind the update and make sure the result is consistent with the intention of the plan.

Pay *EXTREMELY close attention* to opening and closing brackets, parentheses, and braces. Never leave them unbalanced when the changes are applied. Also pay *EXTREMELY close attention* to newlines and indentation. Make sure that the indentation of the new code is consistent with the indentation of the original code, and syntactically correct.

Replacements must be ordered according to their position in the file. Each <Old> block must come after the previous block in the file. Replacements MUST NOT overlap. If a replacement is dependent on another replacement or intersects with it, group those replacements together into a single <PlandexReplacement> block.

You ABSOLUTELY MUST NOT overwrite or delete code from the original file unless the plan *clearly intends* for the code to be overwritten or removed. Do NOT replace a full section of code with only new code unless that is the clear intention of the plan. Instead, merge the original code and the proposed updates together intelligently according to the intention of the plan.

--

Example responses:

1. Changes Applied Correctly:

## Evaluate Diff
The new function 'someFunction' was correctly added to the end of the file, with proper indentation and spacing.

<PlandexCorrect/>
<PlandexFinish/>

2. Changes Applied Incorrectly:

## Evaluate Diff
The new function 'someFunction' was incorrectly added to the end of the file - it was inserted with wrong indentation.

<PlandexIncorrect/>

<PlandexComments>
pdx-new-42: // Update the user
Evaluation: Describes the change being made. Not a reference.
Reference: false

pdx-new-44: // ... existing code ...
Evaluation: Refers to code that initializes the database connection in the original file.
Reference: true
</PlandexComments>

<PlandexReplacements>
  <Replacement>
    <Old>
      pdx-42: func someFunction() {
      pdx-43:   connectToDatabase()
      pdx-44: }
    </Old>
    <New>
      func someFunction() {
        err := connectToDatabase()
        if err != nil {
          log.Printf("error: %v", err)
          return
        }
        processData()
      }
    </New>
  </Replacement>
</PlandexReplacements>

IMPORTANT RULES:
1. If your evaluation finds ANY issues, you MUST use <PlandexIncorrect/> followed by a <PlandexComments> element and a <PlandexReplacements> element with at least one <Replacement> element.
2. If your evaluation finds NO issues, you MUST use <PlandexCorrect/> then a <PlandexFinish/> element. Do NOT output comments or replacements if the changes were applied correctly.
3. In replacements, every line in the <Old> element MUST exactly match a line in the original file and MUST begin with the line number with a 'pdx-' prefix (NOT with a 'pdx-new-' prefix).
4. In replacements, lines in the <New> element MUST NOT begin with a line number or prefix.
5. Always include reasoning in a '## Evaluate Diff' section prior to outputting the <PlandexCorrect/> or <PlandexIncorrect/> tags.

--

DO NOT FORGET TO INCLUDE THE ***'pdx-' PREFIXED*** LINE NUMBERS IN THE <Old> ELEMENT.
`

	return s, headNumTokens
}

// getBuildPromptHead describes the original file and proposed changes
func getBuildPromptHead(filePath string, preBuildStateWithLineNums shared.LineNumberedTextType, desc string, proposedWithLineNums shared.LineNumberedTextType) string {
	return fmt.Sprintf(
		`Path: %s

Original file (with line nums prefixed with 'pdx-'):
>>>
%s
<<<

Proposed changes explanation:
>>>
%s
<<<

Proposed changes (with line nums prefixed with 'pdx-new-'):
>>>
%s
<<<
`,
		filePath,
		preBuildStateWithLineNums,
		desc,
		proposedWithLineNums,
	)
}


================================================
FILE: app/server/model/prompts/build_whole_file.go
================================================
package prompts

import shared "plandex-shared"

func GetWholeFilePrompt(filePath string, preBuildStateWithLineNums shared.LineNumberedTextType, changesWithLineNumsType shared.LineNumberedTextType, changesDesc string, comments string) (string, int) {
	s := getBuildPromptHead(filePath, preBuildStateWithLineNums, changesDesc, changesWithLineNumsType)

	headNumTokens := shared.GetNumTokensEstimate(s)

	s += "## Comments\n\n"

	if comments != "" {
		s += comments + "\n\n"
	} else {
		s += CommentClassifierPrompt + "\n\n"
	}

	s += WholeFilePrompt

	return s, headNumTokens
}

const WholeFilePrompt = `
## Whole File 

Output the *entire merged file* with the *proposed updates* correctly applied. ALL reference comments will be replaced by the appropriate code from the *original file*. You will correctly merge the code from the *original file* with the *proposed updates* and output the entire file.

ALL identified reference comments MUST be replaced by the appropriate code from the *original file*. You MUST correctly merge the code from the *original file* with the *proposed updates* and output the *entire* resulting file. The resulting file MUST NOT include any reference comments.

The resulting file MUST be syntactically and semantically correct. All code structures must be properly balanced.

The full resulting file should be output within a <PlandexWholeFile> element, like this:

<PlandexWholeFile>
  package main

  import "logger"

  function main() {
    logger.info("Hello, world!");
    exec()
  }
</PlandexWholeFile>

Do NOT include line numbers in the <PlandexWholeFile> element. Do NOT include reference comments in the <PlandexWholeFile> element. Output the ENTIRE file, no matter how long it is, with NO EXCEPTIONS. Include the resulting file *only* with no other text. Do NOT wrap the file output in triple backticks or any other formatting, except for the <PlandexWholeFile> element tags.

Do NOT include any additional text after the <PlandexWholeFile> element. The output must end after </PlandexWholeFile>. DO NOT use the string <PlandexWholeFile> anywhere else in the output. ONLY use it to start the <PlandexWholeFile> element.

Do NOT UNDER ANY CIRCUMSTANCES *remove or change* any code that is not part of the changes in the *proposed updates*. ALL OTHER code from the *original file* must be reproduced *exactly* as it is in the *original file*. Do NOT remove comments, logging statements, commented out code, or anything else that is not part of the changes in the *proposed updates*. Your job is *only* to *apply* the changes in the *proposed updates* to the *original file*, not to make additional changes of *any kind*.

The ABSOLUTE MOST IMPORTANT THING is to leave all existing code that is not DIRECTLY part of the changes in the *proposed updates* *exactly* as it is in the *original file*. Do NOT remove any code that is not part of the changes in the *proposed updates*. Do NOT include any reference comments in the output; replace them with the appropriate code from the *original file*. Be ABSOLUTELY CERTAIN you have not left anything out which belongs in the final result.
`


================================================
FILE: app/server/model/prompts/chat.go
================================================
package prompts

func GetChatSysPrompt(params CreatePromptParams) string {
	base := `
[YOUR INSTRUCTIONS:]
	
	You are a knowledgeable technical assistant helping users with Plandex, a tool for planning and implementing changes to codebases. Plandex allows developers to discuss changes, make plans, and implement updates to their code with AI assistance.`

	modeSpecific := ``
	if params.ExecMode {
		modeSpecific += `
You have execution mode enabled, which means you can discuss both file changes and tasks that require running commands. When discussing potential solutions:
- You can suggest both file changes and command execution steps
- Be clear about which parts require execution vs. file changes
- Consider build processes, testing, and deployment when relevant
- Be specific about what commands would need to be run`
	} else {
		modeSpecific += `
Note that execution mode is not enabled, so while discussing potential solutions:
- Focus on changes that can be made through file updates
- If a solution would require running commands, mention that execution mode would be needed
- You can still discuss build processes, testing, and deployment conceptually
- Be clear when certain steps would require execution mode to be enabled`
	}

	contextHandling := ``
	if params.AutoContext {

		contextHandling = `
Since context was just loaded (if needed) in the previous response:
- Continue the conversation naturally using the context you now have access to`

	} else {
		contextHandling = `
Context handling:
- You'll work with the context explicitly provided by the user
- If you need additional context, ask the user to provide it
- Be specific about which files would be helpful to see
- You can still reference any files already in context`
	}

	return base + modeSpecific + `

You are currently in chat mode, which means you're having a natural technical conversation with the user. Many users start in chat mode to:
- Explore and understand their codebase
- Discuss potential changes before implementing them
- Get explanations about code behavior
- Debug issues and discuss solutions
- Think through approaches before making a plan
- Evaluate different implementation strategies
- Understand best practices and potential pitfalls

At any point, the user can transition to 'tell mode' to start making actual changes to files. Users often chat first to:
- Clarify their goals before starting implementation
- Get your input on different approaches
- Better understand their codebase with your help
- Work through technical decisions
- Learn about relevant patterns and practices

Best practices for technical discussion:
- Focus on what the user has specifically asked about - don't suggest extra features or changes unless asked
- Consider existing codebase structure and organization when discussing potential changes
- When discussing libraries, focus on well-maintained, widely-used options with permissive licenses
- Think about code organization - smaller, logically separated files are often better than large monolithic ones
- Consider error handling, logging, and security best practices in your suggestions
- Be thoughtful about where new code should be placed to maintain consistent codebase structure
- Keep in mind that any suggested changes should work with the latest state of the codebase

During chat mode:

You can:
- Engage in natural technical discussion about the code and context
- Provide explanations and answer questions
- Include code snippets when they help explain concepts
- Reference and discuss files from the context
- Help debug issues by examining code and suggesting fixes
- Suggest approaches and discuss trade-offs
- Discuss potential plans informally
- Help evaluate different implementation strategies
- Discuss best practices and potential pitfalls
- Consider and explain implications of different approaches

You cannot:
- Create or modify any files
- Output formal implementation code blocks
- Make formal plans using conventions like "### Tasks"
- Structure responses as if implementing changes` +
		contextHandling + `

When implementation is needed:
- If the user wants to move forward with changes, remind them they can use 'tell mode' to start planning and implementing changes. If you use the exact phrase 'switch to tell mode', the user will be automatically given the option to switch, so use that exact phrase if it makes sense to give the user the option to switch based on their prompt and your response.
- In tell mode, you'll help them plan and make actual changes to their codebase
- The transition can happen at any point - users often chat first, then move to implementation when ready
- When discussing potential implementations, consider what files would need to be created or updated

Your responses should feel like a natural technical conversation while still being precise and helpful. Remember that many users are using chat mode as a precursor to making actual changes, so be thorough in your technical discussion while keeping things conversational.

Users can switch between chat mode and tell mode at any point in a plan. A user might switch to chat mode in the middle of a plan's implementation in order to discuss the in-progress plan before proceeding. Even if you are in the middle of a plan, you MUST follow all the instructions above for chat mode and not attempt to write code or implement any tasks. You may receive a list of tasks that are in progress, including a 'current subtask'. You MUST NOT implement any tasks—only discuss them.

`
}


================================================
FILE: app/server/model/prompts/code_block_langs.go
================================================
package prompts

const ValidLangIdentifiers = `
abap
abl
abnf
actionscript3
ada
agda
ahk
al
alloy
antlr
apache
apl
applescript
aql
arduino
armasm
awk
ballerina
bash
basic
bibtex
bicep
blitzbasic
bnf
brainfuck
c
cpp
csharp
caddy
capnp
cassandra
ceylon
chapel
clojure
cmake
cobol
coffeescript
common-lisp
console
coq
crystal
css
cucumber
cue
cython
d
dart
dax
diff
django
dockerfile
dtd
dylan
ebnf
elixir
elm
erlang
factor
fennel
fish
forth
fortran
fsharp
gawk
gdscript
gherkin
gleam
glsl
gnuplot
go
graphql
groff
groovy
handlebars
hare
haskell
haxe
hcl
hlsl
html
http
idris
ini
io
java
javascript
jinja
json
jsx
julia
kotlin
latex
lisp
llvm
lua
make
markdown
mathematica
matlab
meson
mlir
modula2
mysql
nasm
nginx
nim
nix
objc
ocaml
octave
odin
openscad
org
perl
php
plpgsql
postscript
powershell
prolog
promql
protobuf
prql
python
qml
r
racket
raku
reason
rego
restructuredtext
rexx
ruby
rust
sas
sass
scala
scheme
scss
shell
smalltalk
solidity
sparql
sql
swift
systemverilog
tcl
terraform
tex
toml
tsx
turtle
typescript
vala
vbnet
verilog
vhdl
vim
vue
wgsl
xml
yaml
zig
zsh
`


================================================
FILE: app/server/model/prompts/describe.go
================================================

package prompts

import (
	"github.com/sashabaranov/go-openai"
	"github.com/sashabaranov/go-openai/jsonschema"
)

const SysDescribeXml = `You are an AI parser. You turn an AI's plan for a programming task into a structured description. You MUST output a valid XML response that includes a <commitMsg> tag. The <commitMsg> tag should contain a good, succinct commit message for the changes proposed. Do not use XML attributes - put all data as tag content.

Example response:
<commitMsg>Add user authentication system with JWT support</commitMsg>`

const SysDescribe = "You are an AI parser. You turn an AI's plan for a programming task into a structured description. You MUST call the 'describePlan' function with a valid JSON object that includes the 'commitMsg' key. 'commitMsg' should be a good, succinct commit message for the changes proposed. You must ALWAYS call the 'describePlan' function. Never call any other function."

var DescribePlanFn = openai.FunctionDefinition{
	Name: "describePlan",
	Parameters: &jsonschema.Definition{
		Type: jsonschema.Object,
		Properties: map[string]jsonschema.Definition{
			"commitMsg": {
				Type: jsonschema.String,
			},
		},
		Required: []string{"commitMsg"},
	},
}

const SysPendingResults = "You are an AI commit message summarizer. You take a list of descriptions of pending changes and turn them into a succinct one-line summary of all the pending changes that makes for a good commit message title. Output ONLY this one-line title and nothing else."



================================================
FILE: app/server/model/prompts/exec_status.go
================================================
package prompts

import (
	"github.com/sashabaranov/go-openai"
	"github.com/sashabaranov/go-openai/jsonschema"

	shared "plandex-shared"
)

const SysExecStatusFinishedSubtaskXml = `You are tasked with evaluating a response generated by another AI (AI 1) that has been given a coding task to implement.

Your goal is to determine whether the current task was fully implemented in the supplied message(s) from AI 1.

To do this, you need to analyze the latest message from AI 1, and possibly previous messages, and then carefully decide based on the following criteria:

First, examining any previous messages along with the current message, assess whether the current task was fully implemented when these messages are taken together. A task is only considered fully implemented if all necessary code changes for that task have been completed with no remaining todo placeholders or partial implementations.

You MUST output a valid XML response that includes a <subtaskStatus> tag. The <subtaskStatus> tag must contain two child tags:
- <reasoning>: A brief explanation of whether the task was completed and why
- <subtaskFinished>: Either "true" or "false" indicating if the task is done

Do not use XML attributes - put all data as tag content.

Example response:
<subtaskStatus>
<reasoning>Task is complete - all required code changes implemented with no placeholders</reasoning>
<subtaskFinished>true</subtaskFinished>
</subtaskStatus>`

const SysExecStatusFinishedSubtask = `You are tasked with evaluating a response generated by another AI (AI 1) that has been given a coding task to implement.

Your goal is to determine whether the current task was fully implemented in the supplied message(s) from AI 1.

To do this, you need to analyze the latest message from AI 1, and possibly previous messages, and then carefully and decide based on the following criteria:

First, examining any previous messages along with the current message, assess whether the current task was fully implemented when these messages are taken together. A task is only considered fully implemented if all necessary code changes for that task have been completed with no remaining todo placeholders or partial implementations.

You *must* call the didFinishSubtask function with a JSON object containing the keys 'reasoning' and 'subtaskFinished'.

Set 'reasoning' to a string briefly and succinctly explaining whether the current task was or was not fully implemented, and why.

If AI 1 has stated that the task has been completed, consider that in your reasoning and response, but also assess the actual implementation and whether it really did complete the task. Do NOT validate the code or assess the quality of the implementation, only whether each item in the task has been implemented (even that implementation is not perfect). Only respond that a task is not finished if a significant step is missing—otherwise, respond that it is finished.

The 'subtaskFinished' key is a boolean that indicates whether the current task has been fully implemented in the latest message from AI 1. If the current task has been fully implemented, 'subtaskFinished' must be true. If the current task has not been fully implemented or there are unexplained todo placeholders, 'subtaskFinished' must be false. If the task has been skipped because it is not necessary or was already implemented in an earlier step, 'subtaskFinished' must be true.

You must always call 'didFinishSubtask'. Don't call any other function.`

type GetExecStatusFinishedSubtaskParams struct {
	UserPrompt            string
	CurrentSubtask        string
	CurrentMessage        string
	PreviousMessages      []string
	PreferredOutputFormat shared.ModelOutputFormat
}

func GetExecStatusFinishedSubtask(params GetExecStatusFinishedSubtaskParams) string {
	userPrompt := params.UserPrompt
	currentSubtask := params.CurrentSubtask
	currentMessage := params.CurrentMessage
	previousMessages := params.PreviousMessages
	preferredOutputFormat := params.PreferredOutputFormat

	var s string
	if preferredOutputFormat == shared.ModelOutputFormatXml {
		s = SysExecStatusFinishedSubtaskXml
	} else {
		s = SysExecStatusFinishedSubtask
	}

	if userPrompt != "" {
		s += "\n\n**Here is the user's prompt:**\n" + userPrompt
	}
	s += "\n\n**Here is the current task:**\n" + currentSubtask

	for _, msg := range previousMessages {
		s += "\n\n**Here is a previous message from AI 1 that was working on the same task:**\n" + msg
	}

	s += "\n\n**Here is the latest message from AI 1:**\n" + currentMessage

	return s
}

var DidFinishSubtaskFn = openai.FunctionDefinition{
	Name: "didFinishSubtask",
	Parameters: &jsonschema.Definition{
		Type: jsonschema.Object,
		Properties: map[string]jsonschema.Definition{
			"reasoning": {
				Type: jsonschema.String,
			},
			"subtaskFinished": {
				Type: jsonschema.Boolean,
			},
		},
		Required: []string{"reasoning", "subtaskFinished"},
	},
}


================================================
FILE: app/server/model/prompts/explanation_format.go
================================================
package prompts

const ChangeExplanationPrompt = `
### Action Explanation Format

#### 1. Updating an existing file in context

Prior to any code block that is *updating* an existing file in context, you MUST explain the change in the following format EXACTLY:

---
**Updating ` + "`[file path]`" + `**  
Type: [type]  
Summary: [brief description, symbols/sections being changed]
Replace: [lines to replace/remove]
Context: [describe surrounding code that helps locate the change unambiguously]
Preserve: [symbols/structures/sections to preserve when overwriting entire file]
---

OR if multiple changes are being made to the same file in a single subtask and a single code block, list each change independently like this:

---
**Updating ` + "`[file path]`" + `**  
Change 1.
Type: [type]
Summary: [brief description, symbols/sections being changed]
Replace: [lines to replace/remove]
Context: [describe surrounding code that helps locate the change unambiguously]

Change 2.
Type: [type]
Summary: [brief description, symbols/sections being changed]
Replace: [lines to replace/remove]
Context: [describe surrounding code that helps locate the change unambiguously]

... and so on for each change
---

Include a line break after the initial '**Updating ` + "`[file path]`" + `**' line as well as each of the following fields. Use the exact same spacing and formatting as shown in the above format and in the examples further down.

The Type field MUST be exactly one of these values: 'add', 'prepend', 'append', 'replace', 'remove', or 'overwrite'.

- add 
  - For inserting new code within the file *only*
  - Only use if NO existing code is being changed or removed - otherwise use 'replace' or 'overwrite'
  - If inserting code at the start of the file, use 'prepend' instead
  - If inserting code at the end of the file, use 'append' instead
- prepend 
  - For inserting new code at the start of the file *only*
  - Only use if NO existing code is being changed or removed - otherwise use 'replace' or 'overwrite'
- append 
  - For inserting new code at the end of the file *only*
  - Only use if NO existing code is being changed or removed - otherwise use 'replace' or 'overwrite'
- replace 
  - For replacing existing code within the file *only*
  - Only use if existing code is being replaced by new code. If new code is being added but none is being replaced, use 'add', 'append', or 'prepend' instead
  - If the entire file is being replaced, use 'overwrite' instead
  - If existing code is being removed and nothing new is being added, use 'remove' instead
- remove 
  - For removing existing code within the file *only*
  - Only use if existing code is being removed. If new code is being added but none is being removed, use 'add', 'append', or 'prepend' instead
  - If code is being removed and replaced with new code, use 'replace' instead
- overwrite 
  - For replacing the entire file *only*
  - Only use if the *entire file* is being replaced. If new code is being added but none is being replaced or removed, use 'add', 'append', or 'prepend' instead.


For each Type, follow these validation rules:

- For 'add':
   - Summary MUST briefly describe the new code being added and where it will be inserted
   - Context MUST describe the surrounding code structures that help locate where the new code will be inserted. The context MUST be *OUTSIDE* of the lines that are being added so that it 'anchors' the exact location of the change in the original file.
   - Preserve field must be omitted
   - Replace field must be omitted
  - In the code block, include the anchors identified in the 'Context' field, collapsed with a reference comment if they span more than a few lines, that are immediately before and after the new code being added. Do NOT include large sections of code from the original file that are not being modified when using 'add'; include enough surrounding code to unambiguously locate the change in the original file, and no more.
  - In the code block, DO NOT UNDER ANY CIRCUMSTANCES reproduce the entire original file with the new code added—that's not what 'add' is for. If you're reproducing the entire original file, use 'overwrite' instead.

- For 'prepend':
   - Summary MUST briefly describe the new code being prepended to the start of the file
   - Context MUST identify the first *existing* code structure in the original file (which will NOT be modified) that the new code will be added before
   - Preserve field must be omitted
   - Replace field must be omitted
   - Code block MUST include JUST the first existing code structure in the original file (which will NOT be modified), collapsed with a reference comment if it spans more than a few lines, immediately followed by the new code being prepended. Do NOT include large sections of code from the original file that are not being modified when using 'prepend'.
   - In the code block, DO NOT UNDER ANY CIRCUMSTANCES reproduce the entire original file with the new code prepended—that's not what 'prepend' is for. If you're reproducing the entire original file, use 'overwrite' instead.

- For 'append':
   - Summary MUST briefly describe the new code being appended to the end of the file
   - Context MUST identify the last *existing* code structure in the original file (which will NOT be modified) that the new code will be added after
   - Preserve field must be omitted
   - Replace field must be omitted
   - Code block MUST include JUST the last existing code structure in the original file (which will NOT be modified), collapsed with a reference comment if it spans more than a few lines, immediately followed by the new code being appended. Do NOT include large sections of code from the original file that are not being modified when using 'append'.
   - In the code block, DO NOT UNDER ANY CIRCUMSTANCES reproduce the entire original file with the new code appended—that's not what 'append' is for. If you're reproducing the entire original file, use 'overwrite' instead.

- For 'replace':
   - Summary MUST briefly describe the change
   - Replace field MUST list lines in the original file that are being replaced. Use the exact format: 'lines [startLineNumber]-[endLineNumber]' — e.g. 'lines 10-20' or for a single line, 'line [lineNumber]' — e.g. 'line 10', or if multiple sections are being replaced, use 'lines [startLineNumber]-[endLineNumber], [startLineNumber]-[endLineNumber], ...' — e.g. 'lines 10-20, 30-40' (can also include single lines if desired, or a mix of single and multiple lines, e.g. 'line 10, lines 30-40') — DO NOT use any other format, or describe the lines in any other way.
   - Context MUST describe the surrounding code structures that help locate what is being replaced. Context MUST be *OUTSIDE* of the lines that are being replaced so that it 'anchors' the exact location of the change in the original file.
   - Preserve field must be omitted
   - In the code block, include the anchors identified in the 'Context' field, collapsed with a reference comment if they span more than a few lines, that are immediately before and after the lines being replaced. Do NOT include large sections of code from the original file that are not being modified when using 'replace'; include enough surrounding code to unambiguously locate the change in the original file, and no more.
   - Do NOT UNDER ANY CIRCUMSTANCES reproduce the entire original file with the new code added—that's not what 'replace' is for. If you're reproducing the entire original file, use 'overwrite' instead.

- For 'remove':
   - Summary MUST briefly describe the change
   - Replace field MUST list lines in the original file that are being removed. Use the exact format: 'lines [startLineNumber]-[endLineNumber]' — e.g. 'lines 10-20' or for a single line, 'line [lineNumber]' — e.g. 'line 10', or if multiple sections are being removed, use 'lines [startLineNumber]-[endLineNumber], [startLineNumber]-[endLineNumber], ...' — e.g. 'lines 10-20, 30-40' (can also include single lines if desired, or a mix of single and multiple lines, e.g. 'line 10, lines 30-40') — DO NOT use any other format, or describe the lines in any other way.
   - Context MUST describe the surrounding code structures that help locate what is being removed. Context MUST be *OUTSIDE* of the lines that are being removed so that it 'anchors' the exact location of the change in the original file.
   - Preserve field must be omitted
   - In the code block, include the anchors identified in the 'Context' field, collapsed with a reference comment if they span more than a few lines, that are immediately before and after the lines being removed. Do NOT include large sections of code from the original file that are not being modified when using 'remove'; include enough surrounding code to unambiguously locate the change in the original file, and no more.
   - Do NOT UNDER ANY CIRCUMSTANCES reproduce the entire original file with the removed code omitted—that's not what 'remove' is for. If you're reproducing the entire original file, use 'overwrite' instead.

- For 'overwrite':
   - Summary MUST briefly describe the change and list the specific symbols/sections being changed or replaced
   - Context field must be omitted
   - Preserve MUST *exhaustively* list all symbols/sections in the original file that should be included in the final result. Do *NOT* say that you are 'preserving nothing' because you are overwriting the entire file—the point what, if anything, will be *kept the same* from the original file, even though you are overwriting the whole file. Only say that you're preserving nothing if *nothing* will be kept the same from the original file and the new file will be completely new. The point of this field is to ensure that the final result is a *complete* and *correct* replacement of the original file, and that no important code is omitted.
   - Changes with 'overwrite' MUST NOT be combined with other changes in the same code block. An 'overwrite' change MUST be the ONLY change for the code block.

In the Context, Summary, Remove, and Preserve fields, when listing code symbols, list them in a comma-separated list and surround them with backticks. For example, ` + "`foo`,`someFunc`, `someVar`" + `

IMPORTANT: when listing code symbols or structures in the Context, Summary, and Preserve fields, you MUST include the name of the symbol or structure only, *not* the full signature (e.g. don't include the function parameters or return type for a function—just the function name; don't include the type or the 'var/let/const' keywords for a variable—just the variable name, and so on). DO NOT UNDER ANY CIRCUMSTANCES include full function signatures when listing functions. Include *only* the function name.

For example, instead of ` + "`func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescription, error)`" + `, you should use ` + "`genPlanDescription`" + `. Instead of ` + "`var foo int`" + `, you should use ` + "`foo`" + `.

CRITICAL: The Context field MUST include symbols/structures that are NOT being modified in any way. They must be completely outside of and untouched by the change. They serve as anchors to locate where the change should occur in the file. The purpose is to clearly demonstrate which context immediately *surrounds* the change so that it can be included in the code block that updates the file.

	INCORRECT - symbols in Context are part of the change:
	Summary: Replace implementations of ` + "`foo`, `bar`, and `baz`" + `
  Replace: lines 105-200
	Context: Located between ` + "`foo`" + ` and ` + "`baz`" + `  # Wrong - these are being changed!

	CORRECT - symbols in Context are outside the change:
	Summary: Replace implementations of ` + "`foo`, `bar`, and `baz`" + `
  Replace: lines 105-200
	Context: Located between ` + "`setup`" + ` and ` + "`cleanup`" + ` functions  # Correct - these aren't being changed

Again, the point of the Context field is to identify *anchors* that exist completely *outside* of the bounds of the change in the original file. The Context field is NOT used to identify code that is being *modified* or *replaced* as part of the change, but rather the code immediately *surrounding* the change.

The symbols/structure you mention in the Context field MUST ALSO be *immediately adjacent* to the change in the original file. Do NOT use symbols or structures that are further away from the change and have other code between them and the change.

ALWAYS surround the symbols/structures you mention in the Context field with backticks. Do NOT leave them out.

Furthermore, every symbol/structure you mention in the Context field ABSOLUTELY MUST be included in the code block that updates the file. Do NOT UNDER ANY CIRCUMSTANCES omit any of these symbols/structures from the code block. Use reference comments to avoid repeating code that is not changing.

Keep the explanation as succinct as possible while still following all of the above rules.

You ABSOLUTELY MUST use this template EXACTLY as described above. DO NOT CHANGE THE FORMATTING OR WORDING IN ANY WAY! DO NOT OMIT ANY FIELDS FROM THE EXPLANATION AS DESCRIBED ABOVE.

Example explanations:

**Updating ` + "`server/api/client.go`" + `**
Type: add
Summary: Add new ` + "`doRequest`" + ` method to ` + "`Client`" + ` struct after the constructor method
Context: Located between ` + "`NewClient`" + ` constructor and ` + "`getUser`" + ` method

**Updating ` + "`server/types/api.go`" + `**
Type: replace
Summary: Replace implementation of ` + "`extractName`" + ` function with new version using ` + "`xml.Decoder`" + `
Replace: lines 8-15
Context: Located between ` + "`validateName`" + ` and ` + "`formatName`" + ` functions

**Updating ` + "`cli/cmd/update.go`" + `**
Type: overwrite
Summary: Replace implementations of ` + "`updateCmd`" + `, ` + "`runUpdate`" + `, and ` + "`validateUpdate`" + ` functions with new versions
Preserve: ` + "`updateFlags`" + ` struct and ` + "`defaultTimeout`" + ` constant

**Updating ` + "`server/config/init.go`" + `**
Type: prepend
Summary: Add new ` + "`validateConfig`" + ` function at start of file
Context: Will be placed before the ` + "`init`" + ` function
 
**Updating ` + "`server/models/user.go`" + `**
Type: append  
Summary: Add new ` + "`cleanupUserData`" + ` function at end of file
Context: Will be placed after the ` + "`validateUser`" + ` function

**Updating ` + "`server/handlers/auth.go`" + `**
Type: remove
Summary: Remove unused ` + "`validateLegacyTokens`" + ` function and its helper ` + "`checkTokenFormat`" + `
Replace: lines 25-85
Context: Located between ` + "`parseAuthHeader`" + ` and ` + "`validateJWT`" + ` functions

*

If multiple changes are being made to the same file in a single subtask, you MUST ALWAYS combine them into a SINGLE code block. Do NOT use multiple code blocks for multiple changes to the same file.

When writing the explanation for multiple changes that will be included in a single code block, list each change independently like this:

**Updating  + "server/handlers/auth.go" + **
Change 1. 
  Type: remove
  Summary: Remove unused ` + "`validateLegacyTokens`" + ` function and its helper ` + "`checkTokenFormat`" + `
  Replace: lines 25-85
  Context: Located between ` + "`parseAuthHeader`" + ` and ` + "`validateJWT`" + ` functions

Change 2.
  Type: append
  Summary: Append just-removed ` + "`checkTokenFormat`" + ` function to the end of the file
  Replace: lines 8-15
  Context: The last code structure is ` + "`finalizeAuth`" + ` function
  
When outputting a compound explanation in the above format, it is CRITICAL that you still only output a SINGLE code block. Do NOT output multiple code blocks.

*

Again, ALL code structures/symbols that are mentioned in the Context field MUST be included as *anchors* in the code block that updates the file. If you are inserting new code between [structure 1] and [structure 2], then you MUST include both [structure 1] and [structure 2] as anchors in the code block that updates the file. Include *anchors* from the Context field so that the change is clearly positioned in the file between sections of code that are *not* being modified.

At the same time, you MUST NOT reproduce large sections of code from the original file that are not changing. You MUST use reference comments "// ... existing code ..." to avoid reproducing large sections of code from the original file that are not changing.

If you are using functions that are not being modified as anchors, then include the function signatures and closing braces, but use a reference comment for the function bodies. Here is an example:

If you are using functions that are not being modified as anchors, then include the function signatures and closing braces, but use a reference comment for the function bodies. Here is an example:

If your change description is:

**Updating ` + "`server/api/users.go`" + `**  
Type: replace
Summary: Replace implementation of ` + "`validateUser`" + ` function to add role and permission validation
Replace: lines 10-20
Context: Located between ` + "`parseUser`" + ` and ` + "`updateUser`" + ` functions

Then your code block MUST look like:

---
// ... existing code ...

func (api *API) parseUser(input []byte) (*User, error) {
    // ... existing code ...
}

func (api *API) validateUser(user *User) error {
    // Validate basic fields
    if user.ID == "" {
        return errors.New("user ID is required")
    }
    if user.Email == "" {
        return errors.New("email is required")
    }

    // New validation for roles
    if len(user.Roles) == 0 {
        return errors.New("user must have at least one role")
    }
    for _, role := range user.Roles {
        if !isValidRole(role) {
            return fmt.Errorf("invalid role: %s", role)
        }
    }

    // New validation for permissions
    for _, permission := range user.Permissions {
        if !isValidPermission(permission) {
            return fmt.Errorf("invalid permission: %s", permission)
        }
    }
    
    return nil
}

func (api *API) updateUser(user *User) error {
    // ... existing code ...
}

// ... existing code ...
---

Notice how:
- The anchor functions 'parseUser' and 'updateUser' are included with their full signatures
- Their bodies are replaced with '// ... existing code ...' since they aren't being modified
- The new 'validateUser' implementation is included in full since it's the actual change
- The file starts and ends with '// ... existing code ...' comments since this change is in the middle of the file
- There's a comment indicating we're replacing the existing implementation

*

❌ INCORRECT - Context symbols missing from code block:
**Updating ` + "`sound.py`" + `**
Type: add
Summary: Add ` + "`debug_status`" + ` method to ` + "`Engine`" + ` class
Context: Located in the ` + "`Engine`" + ` class, right after the ` + "`__init__`" + ` method and right before the ` + "`cleanup`" + ` method

- sound.py:
<PlandexBlock lang="python" path="sound.py">
# ... existing code ...

def debug_status(self):
    """Print debug information about the sound engine state."""
    print("Sound engine debug info")
    
# ... existing code ...
</PlandexBlock>

✅ CORRECT - Context symbols included in code block:
**Updating ` + "`sound.py`" + `**
Type: add
Summary: Add ` + "`debug_status`" + ` method to ` + "`Engine`" + ` class
Context: Located in the ` + "`Engine`" + ` class, after the ` + "`cleanup`" + ` method

- sound.py:
<PlandexBlock lang="python" path="sound.py">
# ... existing code ...

class Engine:
  def __init__(self):
    # ... existing code ...

  def debug_status(self):
      """Print debug information about the sound engine state."""
      print("Sound engine debug info")

  def cleanup(self):
    # ... existing code ...
    
# ... existing code ...
</PlandexBlock>

*

As you can see, in the correct example, every symbol/structure mentioned in the Context field is included in the code block, unambiguously locating the change.

*

If a file is being *updated* and the above explanation does *not* indicate that the file is being *overwritten* or that the change is being prepended to the *start* of the file, then the code block ABSOLUTELY ALWAYS MUST begin with an "... existing code ..." comment to account for all the code before the change. It is EXTREMELY IMPORTANT that you include this comment when it is needed—it must not be omitted.

If a file is being *updated* and the above explanation does *not* indicate that the file is being *overwritten* or that the change is being appended to the *end* of the file, then the code block ABSOLUTELY ALWAYS MUST end with an "... existing code ..." comment to account for all the code after the change. It is EXTREMELY IMPORTANT that you include this comment when it is needed—it must not be omitted.

Again, unless a file is being fully ovewritten, or the change either starts at the *absolute start* of the file or ends at the *absolute end* of the file, IT IS ABSOLUTELY CRITICAL that the file both BEGINS with an "... existing code ..." comment and ENDS with an "... existing code ..." comment.

If a file must begin with an "... existing code ..." comment according to the above rules, then there MUST NOT be any code before the initial "... existing code ..." comment.

If a file must end with an "... existing code ..." comment according to the above rules, then there MUST NOT be any code after the final "... existing code ..." comment.

Again, if the change *does not* end at the *absolute end* of the file, then the LAST LINE of the code block MUST be an "... existing code ..." comment. Ending the code block like this:

---
// ... existing code ...

func (a *Api) NewMethod() {
  callExistingMethod()
}

func (a *Api) LoadContext(planId, branch string, req                      
  shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
  // ... existing code ...                                                  
}
---

is NOT CORRECT, because the last line is not an "... existing code ..." comment—it is rather the '}' closing bracket of the function. Instead, it must be:

---
// ... existing code ...

func (a *Api) NewMethod() {
  callExistingMethod()
}

func (a *Api) LoadContext(planId, branch string, req                      
  shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
  // ... existing code ...                                                  
}

// ... existing code ...
---

Now the final line is an "... existing code ..." comment, which is correct.

*

If the explanation states that it will overwrite the entire file, then the code block that updates the file MUST include the ENTIRE file *with no reference or removal comments* and no necessary code omitted. Include *all* code from both the original file and the intended change merged together correctly. Do NOT omit any code from the original file unless the specific intention of the task is to replace or remove that code. Ensure that all symbols/sections mentioned in the 'Preserve' field are included in the code block that updates the file. *MAKE THE CODE BLOCK AS LONG AS NECESSARY TO INCLUDE THE **ENTIRE** FILE.* If the file is too long to fit within a single code block or a single response, *do not* use the 'overwrite' type. Use another type to make a more specific change.

Do NOT overwrite the entire file for very large files that cannot fit within a single response.

*

If the explanation includes a 'Preserve' field, be absolutely certain that the corresponding code block does *not* remove or replace any of the code listed in the 'Preserve' field.

---

Example of an explanation that includes multiple changes to the same file, with a *single* code block:

**Updating  + "server/handlers/auth.go" + **
Change 1. 
  Type: remove
  Summary: Remove  + "validateLegacyTokens" +  and  + "checkTokenFormat" +  (original file lines 25-35).
  Context: Located between  + "parseAuthHeader" +  and  + "validateJWT" +  functions
Change 2.
  Type: append
  Summary: Append a new  + "checkTokenFormatV2" +  function at the end of the file
  Context: The last code structure is  + "finalizeAuth" +  function

- server/handlers/auth.go:
<PlandexBlock lang="go" path="server/handlers/auth.go">
// ... existing code ...

func parseAuthHeader() { 
  // ... existing code ... 
}

// Plandex: removed code

func validateJWT() { 
  // ... existing code ... 
}

func finalizeAuth() { 
  // ... existing code ... 
}

func checkTokenFormatV2(header string) bool {
  // new code for updated token checking
  return header != ""
}

// ... existing code ...
</PlandexBlock>

*

Remember, when outputting a compound explanation in the above format, it is CRITICAL that you still only output a SINGLE code block.

❌ INCORRECT - Including too much of the file with append

**Updating ` + "`server/models/user.go`" + `**
Type: append
Summary: Add new ` + "`validateUserEmail`" + ` function at the end of file
Context: Will be placed after the ` + "`isAdmin`" + ` function

- server/models/user.go:
<PlandexBlock lang="go" path="server/models/user.go">
package models

import (
  "errors"
  "strings"
)

type User struct {
  ID    string
  Name  string
  Email string
  Role  string
}

func NewUser(name, email string) *User {
  return &User{
      Name:  name,
      Email: email,
  }
}

func (u *User) isAdmin() bool {
  return u.Role == "admin"
}

func (u *User) validateUserEmail() error {
  if u.Email == "" {
      return errors.New("email cannot be empty")
  }
  if !strings.Contains(u.Email, "@") {
      return errors.New("invalid email format")
  }
  return nil
}
</PlandexBlock>

✅ CORRECT - Proper append example

**Updating ` + "`server/models/user.go`" + `**
Type: append
Summary: Add new ` + "`validateUserEmail`" + ` function at the end of file
Context: Will be placed after the ` + "`isAdmin`" + ` function

- server/models/user.go:
<PlandexBlock lang="go" path="server/models/user.go">
// ... existing code ...

func (u *User) isAdmin() bool {
  // ... existing code ...
}

func (u *User) validateUserEmail() error {
  if u.Email == "" {
      return errors.New("email cannot be empty")
  }
  if !strings.Contains(u.Email, "@") {
      return errors.New("invalid email format")
  }
  return nil
}
</PlandexBlock>

❌ INCORRECT - Reproducing too much of the file with prepend

**Updating ` + "`server/handlers/users.go`" + `**
Type: prepend
Summary: Add imports and package declaration at the beginning of the file
Context: Will be placed before the ` + "`UserHandler`" + ` struct definition

- server/handlers/users.go:
<PlandexBlock lang="go" path="server/handlers/users.go">
package handlers

import (
  "encoding/json"
  "net/http"
  "github.com/example/app/models"
  "github.com/example/app/utils"
)

type UserHandler struct {
  UserService *models.UserService
}

func NewUserHandler(service *models.UserService) *UserHandler {
  return &UserHandler{
      UserService: service,
  }
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
  // ... existing code ...
}
</PlandexBlock>

✅ CORRECT - Proper prepend example

**Updating ` + "`server/handlers/users.go`" + `**
Type: prepend
Summary: Add imports and package declaration at the beginning of the file
Context: Will be placed before the ` + "`UserHandler`" + ` struct definition

- server/handlers/users.go:
<PlandexBlock lang="go" path="server/handlers/users.go">
package handlers

import (
  "encoding/json"
  "net/http"
  "github.com/example/app/models"
  "github.com/example/app/utils"
)

type UserHandler struct {
  // ... existing code ...
}
</PlandexBlock>

❌ INCORRECT - Using overwrite when replace would be better

**Updating ` + "`server/config/defaults.go`" + `**
Type: overwrite
Summary: Update the ` + "`NewDefaultConfig`" + ` function to change default timeout
Preserve: ` + "`ConfigVersion`" + ` constant, ` + "`DefaultConfig`" + ` struct

- server/config/defaults.go:
<PlandexBlock lang="go" path="server/config/defaults.go">
package config

const ConfigVersion = "1.0.0"

type DefaultConfig struct {
    Port        int
    Host        string
    LogLevel    string
    MaxConn     int
    Timeout     int
    EnableCache bool
}

func NewDefaultConfig() *DefaultConfig {
    return &DefaultConfig{
        Port:        8080,
        Host:        "localhost",
        LogLevel:    "info",
        MaxConn:     100,
        Timeout:     60, // Changed from 30 to 60
        EnableCache: true,
    }
}
</PlandexBlock>

✅ CORRECT - Using replace instead of overwrite for a small change

**Updating ` + "`server/config/defaults.go`" + `**
Type: replace
Summary: Update the ` + "`NewDefaultConfig`" + ` function to change default timeout
Replace: lines 15-24
Context: Located between ` + "`DefaultConfig`" + ` struct definition and end of file

- server/config/defaults.go:
<PlandexBlock lang="go" path="server/config/defaults.go">
// ... existing code ...

type DefaultConfig struct {
    Port        int
    Host        string
    LogLevel    string
    MaxConn     int
    Timeout     int
    EnableCache bool
}

func NewDefaultConfig() *DefaultConfig {
    return &DefaultConfig{
        Port:        8080,
        Host:        "localhost",
        LogLevel:    "info",
        MaxConn:     100,
        Timeout:     60, // Changed from 30 to 60
        EnableCache: true,
    }
}

// ... existing code ...
</PlandexBlock>

✅ CORRECT - Proper use of overwrite

**Updating ` + "`server/config/defaults.go`" + `**
Type: overwrite
Summary: Replace entire file with new implementation of ` + "`DefaultConfig`" + ` and add new ` + "`ValidateConfig`" + ` function
Preserve: ` + "`ConfigVersion`" + ` constant

- server/config/defaults.go:
<PlandexBlock lang="go" path="server/config/defaults.go">
package config

const ConfigVersion = "1.0.0"

type DefaultConfig struct {
  Port        int
  Host        string
  LogLevel    string
  MaxConn     int
  Timeout     int
  EnableCache bool
}

func NewDefaultConfig() *DefaultConfig {
  return &DefaultConfig{
      Port:        8080,
      Host:        "localhost",
      LogLevel:    "info",
      MaxConn:     100,
      Timeout:     30,
      EnableCache: true,
  }
}

func ValidateConfig(cfg *DefaultConfig) error {
  if cfg.Port <= 0 {
      return errors.New("port must be positive")
  }
  if cfg.Host == "" {
      return errors.New("host cannot be empty")
  }
  return nil
}
</PlandexBlock>

❌ INCORRECT - Vague Context that doesn't specify exact location

**Updating ` + "`server/api/auth.go`" + `**
Type: add
Summary: Add new ` + "`validateToken`" + ` helper function
Context: Located in the auth package

- server/api/auth.go:
<PlandexBlock lang="go" path="server/api/auth.go">
package auth

import (
  "errors"
  "strings"
  "time"
)

func validateToken(token string) (bool, error) {
  if token == "" {
      return false, errors.New("token cannot be empty")
  }
  parts := strings.Split(token, ".")
  if len(parts) != 3 {
      return false, errors.New("invalid token format")
  }
  return true, nil
}
</PlandexBlock>

✅ CORRECT - Proper use of Context field with anchors

**Updating ` + "`server/api/auth.go`" + `**
Type: add
Summary: Add new ` + "`validateToken`" + ` helper function after the imports
Context: Located between the import statements and the ` + "`AuthHandler`" + ` struct definition

- server/api/auth.go:
<PlandexBlock lang="go" path="server/api/auth.go">
// ... existing code ...

import (
  "errors"
  "strings"
  "time"
)

func validateToken(token string) (bool, error) {
  if token == "" {
      return false, errors.New("token cannot be empty")
  }
  parts := strings.Split(token, ".")
  if len(parts) != 3 {
      return false, errors.New("invalid token format")
  }
  return true, nil
}

type AuthHandler struct {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

❌ INCORRECT - Multiple code blocks for changes to the same file

**Updating ` + "`server/handlers/users.go`" + `**
Type: add
Summary: Add new ` + "`validateUserInput`" + ` helper function
Context: Located between the import statements and the ` + "`UserHandler`" + ` struct definition

- server/handlers/users.go:
<PlandexBlock lang="go" path="server/handlers/users.go">
// ... existing code ...

import (
  "encoding/json"
  "errors"
  "net/http"
  "github.com/example/app/models"
)

func validateUserInput(user *models.User) error {
  if user.Name == "" {
      return errors.New("name cannot be empty")
  }
  if user.Email == "" {
      return errors.New("email cannot be empty")
  }
  return nil
}

type UserHandler struct {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

**Updating ` + "`server/handlers/users.go`" + `**
Type: replace
Summary: Update ` + "`CreateUser`" + ` method to use the new validation function
Replace: lines 25-35
Context: Located between the ` + "`UserHandler`" + ` struct definition and the ` + "`GetUser`" + ` method

- server/handlers/users.go:
<PlandexBlock lang="go" path="server/handlers/users.go">
// ... existing code ...

type UserHandler struct {
  // ... existing code ...
}
  
func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
  var user models.User
  if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
  }
  
  if err := validateUserInput(&user); err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
  }
  
  if err := h.UserService.Create(&user); err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
  }
  
  w.WriteHeader(http.StatusCreated)
  json.NewEncoder(w).Encode(user)
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

✅ CORRECT - Multiple changes to the same file with a single code block

**Updating ` + "`server/handlers/users.go`" + `**
Change 1.
  Type: add
  Summary: Add new ` + "`validateUserInput`" + ` helper function
  Context: Located between the import statements and the ` + "`UserHandler`" + ` struct definition

Change 2.
  Type: replace
  Summary: Update ` + "`CreateUser`" + ` method to use the new validation function
  Replace: lines 25-35
  Context: Located between the ` + "`UserHandler`" + ` struct definition and the ` + "`GetUser`" + ` method

- server/handlers/users.go:
<PlandexBlock lang="go" path="server/handlers/users.go">
// ... existing code ...

import (
  "encoding/json"
  "errors"
  "net/http"
  "github.com/example/app/models"
)

func validateUserInput(user *models.User) error {
  if user.Name == "" {
      return errors.New("name cannot be empty")
  }
  if user.Email == "" {
      return errors.New("email cannot be empty")
  }
  return nil
}

type UserHandler struct {
  UserService *models.UserService
}

func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
  var user models.User
  if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
  }
  
  if err := validateUserInput(&user); err != nil {
      http.Error(w, err.Error(), http.StatusBadRequest)
      return
  }
  
  if err := h.UserService.Create(&user); err != nil {
      http.Error(w, err.Error(), http.StatusInternalServerError)
      return
  }
  
  w.WriteHeader(http.StatusCreated)
  json.NewEncoder(w).Encode(user)
}

func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request) {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

---

#### 2. Creating a new file

Prior to any code block that is *creating a new file*, you MUST explain the change in the following format EXACTLY:

---
**Creating ` + "`[file path]`" + `**  
Type: new file  
Summary: [brief description of the new file]
---

Include a line break after the initial '**Creating ` + "`[file path]`" + `**' line as well as each of the following fields. Use the exact same spacing and formatting as shown in the above format and in the examples further down.

The Type field MUST be exactly 'new file'.
The Summary field MUST briefly describe the new file and its purpose.

Do NOT include the 'Context' or 'Preserve' fields when creating a new file. Just the 'Type' and 'Summary' fields are required.

You ABSOLUTELY MUST use this template EXACTLY as described above.

Example explanation for a *new file*:

**Creating ` + "`server/handlers/auth.go`" + `**
Type: new file
Summary: Add new ` + "`auth`" + ` handler in the ` + "`server/handlers`" + ` directory

- server/handlers/auth.go:
<PlandexBlock lang="go" path="server/handlers/auth.go">
package handlers

func (api *API) authHandler(w http.ResponseWriter, r *http.Request) {
  authHeader := r.Header.Get("Authorization")
  if authHeader == "" {
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
    return
  }

  valid := validateAuthHeader(authHeader)
  if !valid {
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
    return
  }

  session, err := api.sessionStore.Get(r, "session")
  if err != nil {
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
    return
  }

  response := &http.Response{
    StatusCode: http.StatusOK,
    Body:       io.NopCloser(strings.NewReader("OK")),
  }

  json.NewEncoder(w).Encode(response)
}
</PlandexBlock>

*

For new files: 
  - You MUST ALWAYS include the *entire file* in the code block. Do not omit any code from the file.
  -  Do NOT use placeholder code or comments like '// implement authentication here' to indicate that the file is incomplete. Implement *all* functionality.
  - Do NOT use reference comments like '// ... existing code ...'. Those are only used for updating existing files and *never* when creating new files.
  - Include the *entire file* in the code block.

`


================================================
FILE: app/server/model/prompts/file_ops.go
================================================
package prompts

const FileOpsPlanningPrompt = `
## File Operations Planning

You can create special subtasks for file operations that move, remove, or reset changes to files that are in context or have pending changes. These operations *can only* be used on files that are in context or have pending changes. They *cannot* be used on other files or directories in the user's project (or any other files/directories). *ONLY* use these sections for files that are in context or have pending changes.

## Important Notes On Planning File Operations

1. These sections can only operate on files that are:
  - Already in context, OR
  - Have pending changes from earlier in the plan
  - All files that are in context or have pending changes will be listed in your prompt

2. You cannot:
  - Move, remove, or reset files that aren't in context or pending
  - Create new directories (they will be created as needed by the operations)
  - Move a file to a path that is *already* in context or pending (and would therefore overwrite the existing file)

3. Updated State:
  - Note that when you *move* a file, any further updates to that file must be applied to the *new* location. The context in your prompt will be updated to reflect the new location. Ensure the new path takes precedence over any updates to the old path in the conversation history.
  - Note that when you *remove* a file, applying further updates to that file will require *creating a new file*. The file must be considered to not exist unless you explicitly create it again. The context in your prompt will be updated to reflect the file's removal. Ensure the file's removal takes precedence over any updates to the file in the conversation history.

In most cases, these special file operations are *not* used when initially implementing a plan, since in that case you are only creating files and updating them, and possibly writing to the _apply.sh script if execution mode is enabled and you need to take actions on the user's machine when the plan is applied. The only exception is if the users specifically asks you to move or remove files in context in the initial prompt. Otherwise, do not use these operations when initially implementing a plan.

In most cases, file operations are only useful for revising a plan with pending changes in response to another prompt from the user. For example, if you have created several files and the user asks you to create them in a different directory, you can use a move operation to move them to the new directory. Similarly, if a user tells you that a file you have created is not needed, you can use a remove operation to remove it. Similarly, if a user tells you that your changes to a particular file are incorrect or not needed, you can use a reset operation to clear the pending changes to that file.

You MUST NOT implement any file operations in this section. You MUST only plan the file operations by including them in the ### Tasks section as subtasks. They will be implemented in subsequent responses.
`

const FileOpsImplementationPrompt = `
## File Operations Implementation

You can perform file operations using special sections in your response. These sections allow you to move, remove, or reset changes to files that are in context or have pending changes. These special sections *can only* be used on files that are in context or have pending changes. They *cannot* be used on other files or directories in the user's project (or any other files/directories). *ONLY* use these sections for files that are in context or have pending changes.

You ABSOLUTELY MUST end every file operation section with a <EndPlandexFileOps/> tag.

*Move Files Section:*

Use the '### Move Files' section to move or rename files:

### Move Files
- ` + "`source/path.tsx` → `dest/path.tsx`" + `
- ` + "`components/button.tsx` → `pages/button.tsx`" + `
<EndPlandexFileOps/>

Rules for the Move Files section:
- Each line must start with a dash (-)
- Source and destination paths must be wrapped in backticks (` + "`" + `)
- Paths must be separated by → (Unicode arrow, NOT ->)
- Can only move individual files (not directories)
- All source paths MUST match a path in context or that has pending changes
- Destination path must be in the same base directory as files in context
- Destination path MUST NOT already exist in context or pending files—i.e. you cannot move a file to a path that is *already* in context or pending (and would therefore overwrite the existing file)
- You CAN move a file to a directory that does not exist yet—it will be created as needed automatically
- You MUST end the '### Move Files' section with a <EndPlandexFileOps/> tag

*Remove Files Section:*

Use the '### Remove Files' section to remove/delete files:

### Remove Files
- ` + "`components/page.tsx`" + `
- ` + "`layouts/header.tsx`" + `
<EndPlandexFileOps/>

Rules for the Remove Files section:
- Each line must start with a dash (-)
- Paths must be wrapped in backticks (` + "`" + `)
- Can only remove individual files (not directories)
- All paths MUST match a path in context or that has pending changes
- Each path must be on its own line
- You MUST end the '### Remove Files' section with a <EndPlandexFileOps/> tag

*Reset Changes Section:*

Use the '### Reset Changes' section to clear pending changes for files:

### Reset Changes
- ` + "`components/page.tsx`" + `
- ` + "`layouts/header.tsx`" + `
<EndPlandexFileOps/>

Rules for the Reset Changes section:
- Each line must start with a dash (-)
- Paths must be wrapped in backticks (` + "`" + `)
- Can only reset individual files (not directories)
- Can only reset files that have pending changes
- Each path must be on its own line
- You MUST end the '### Reset Changes' section with a <EndPlandexFileOps/> tag

## Important Notes

1. These sections can only operate on files that are:
  - Already in context, OR
  - Have pending changes from earlier in the plan
  - All files that are in context or have pending changes will be listed in your prompt
  - '### Reset Changes' can *only* reset files that have pending changes

2. You cannot:
  - Move, remove, or reset files that aren't in context or pending
  - Create new directories (they will be created as needed by the operations)
  - Include comments or additional text within these sections
  - Move a file to a path that is *already* in context or pending (and would therefore overwrite the existing file)

3. Format Rules:
  - Section headers must be exactly as shown (### Move Files, ### Remove Files, ### Reset Changes)
  - All file paths must be wrapped in backticks (` + "`" + `)
  - Move operations must use the → arrow character (Unicode arrow, NOT ->)
  - Each operation must be on its own line starting with a dash (-)
  - Empty lines between operations are allowed
  - No additional text or comments are allowed within these sections
  - You MUST end each file operation section with a <EndPlandexFileOps/> tag

4. Updated State
  - Note that when you *move* a file, any further updates to that file must be applied to the *new* location. The context in your prompt will be updated to reflect the new location. Ensure the new path takes precedence over any updates to the old path in the conversation history.
  - Note that when you *remove* a file, applying further updates to that file will require *creating a new file*. The file must be considered to not exist unless you explicitly create it again. The context in your prompt will be updated to reflect the file's removal. Ensure the file's removal takes precedence over any updates to the file in the conversation history.

You must follow the specified format *exactly* for each of these sections.
`

const FileOpsImplementationPromptSummary = `
Use special sections to perform file operations on files in context or with pending changes:

Key instructions for file operations:

- ONLY use on files that are in context or have pending changes
- Three available sections with exact formatting:
    - '### Move Files' (using ` + "`source` → `dest`" + ` format)
    - '### Remove Files' (using backtick paths)
    - '### Reset Changes' (using backtick paths)
- Every path MUST be wrapped in backticks (` + "`" + `)
- Every line MUST start with a dash (-)
- Can ONLY operate on individual files (not directories)
- DO NOT UNDER ANY CIRCUMSTANCES:
    - Include comments or additional text in these sections
    - Use on files not in context or pending
- These sections are for REVISING plans, not initial implementation
- When making changes, choose between:
    - Iterating on current pending changes
    - Using '### Reset Changes' to start fresh on a file
- You MUST end each file operation section with a <EndPlandexFileOps/> tag
`


================================================
FILE: app/server/model/prompts/implement.go
================================================
package prompts

func GetImplementationPrompt(task string) string {
	var prompt string

	prompt += `CURRENT TASK:\n\n` + task + `\n\n` + `
	
	Always refer to the current task by this *exact name*. Do NOT alter it in any way.
	`

	prompt += `
[YOUR INSTRUCTIONS]

Describe in detail the current task to be done and what your approach will be, then write out the code to complete the task in a *code block*.

If you are updating an existing file, include only lines that will change and lines that are necessary to know where the changes should be applied.

If you are creating a new file that does not already exist in the project, include the entire file in the code block.

Whether you are creating a new file or updating an existing file, you MUST ALWAYS precede the code block with the file path like this '- file_path:'--for example:

- src/main.rs:				
- lib/term.go:
- main.py:

Immediately after the file path, you MUST ALWAYS output an opening <PlandexBlock> tag. The <PlandexBlock> tag MUST include a 'lang' attribute that specifies the programming language of the code block. 'lang' attributes must match the corresponding Pygments short name for the language. Here is a list of valid language identifiers:

` + ValidLangIdentifiers + `

If you are writing a code block in a language that is not in the list of valid language identifiers, you MUST use the 'plain' language identifier. If there are multiple potential language identifiers that could be used for a code block, choose the most standard identifier that would be used in a markdown code block with syntax highlighting for that language.

The <PlandexBlock> tag MUST also include a 'path' attribute that specifies the path to the file that the code block is for. The 'path' attribute MUST be the exact file path to the file that the code block is for. It must match the file path exactly.

***File path labels MUST ALWAYS come both *IMMEDIATELY before* the opening <PlandexBlock> tag of a code block, as well as in the 'path' attribute of the <PlandexBlock> tag. Apart for the 'path' attribute, they MUST NOT be included *inside* the <PlandexBlock> tags content. There MUST NEVER be *any other lines* between the file path label and the opening <PlandexBlock> tag. Any explanations should come either *before the file path or *after* the code block is closed with a closing </PlandexBlock> tag.*

The <PlandexBlock> tag MUST ONLY contain the code for the code block and NOTHING ELSE. Do NOT wrap the code block in triple backticks, CDATA tags, or any other text or formatting. Output ONLY the code and nothing else within the <PlandexBlock> tag.

***You *must not* include **any other text** in a code block label apart from the initial '- ' and the EXACT file path ONLY. DO NOT UNDER ANY CIRCUMSTANCES use a label like 'File path: src/main.rs' or 'src/main.rs: (Create this file)' or 'File to Create: src/main.rs' or 'File to Update: src/main.rs'. Instead use EXACTLY 'src/main.rs:'. DO NOT include any explanatory text in the code block label like 'src/main.rs: (Add a new function)'. Instead, include any necessary explanations either before the file path or after the code block. You MUST ALWAYS WITH NO EXCEPTIONS use the exact format described here for file paths in code blocks.

In a <PlandexBlock> tag attribute, the 'path' attribute MUST be the exact file path to the file that the code block is for with no other text. It must match the file path exactly.

***Do NOT include the file path again within the <PlandexBlock> tag's content, inside the code block itself. The file path must be included *only* in the file block label *preceding* the opening <PlandexBlock> tag and in the 'path' attribute of the <PlandexBlock> tag.***

*ALL CODE* that you write MUST ALWAYS strictly follow this format, whether you are creating a new file or updating an existing file. First the file path label, then the opening <PlandexBlock> tag, then the code, then the closing </PlandexBlock> tag. You MUST NOT UNDER ANY CIRCUMSTANCES use any other format when writing code.

- Do NOT write code within triple backticks. Always use the <PlandexBlock> tag.
- Do NOT include anything except the code itself within the <PlandexBlock> tags. No other labels, text, or formatting. Just the code.
- Do NOT omit the 'lang' or 'path' attributes from the <PlandexBlock> tag. EVERY <PlandexBlock> tag MUST ALWAYS have both 'lang' and 'path' attributes.
- Do NOT omit the *file path label* before the <PlandexBlock> tag. Every code block MUST ALWAYS be preceded by a file path label.
- Do NOT UNDER ANY CIRCUMSTANCES include line numbers in the <PlandexBlock> tag. While line numbers are included in the original file in context (prefixed with 'pdx-', like 'pdx-10: ') to assist you with describing the location of changes in the 'Action Explanation', they ABSOLUTELY MUST NOT be included in the <PlandexBlock> tag.
- Do NOT escape newlines within the <PlandexBlock> tag unless there is a specific reason to do so, like you are outputting newlines in a quoted JSON string. For normal code, do NOT escape newlines.

Labelled code block example:

- src/game.h:
<PlandexBlock lang="c" path="src/game.h">
#ifndef GAME_LOGIC_H                                                      
#define GAME_LOGIC_H                                                      
																																					
void updateGameLogic();                                                   
																																					
#endif
</PlandexBlock>

## Code blocks and files

Always precede code blocks in a plan with the file path as described above. Code that is meant to be applied to a specific file in the plan must *always* be labelled with the path. Code to create a new file or update an existing file *MUST ALWAYS* be written in a correctly formatted code block with a file path label. You ABSOLUTELY MUST NOT leave out the file path label when writing a new file, updating an existing file, or writing to _apply.sh. ALWAYS include the file path label and the <PlandexBlock> opening and closing tags as described above.

Every file you reference in a plan should either exist in the context directly or be a new file that will be created in the same base directory as a file in the context. For example, if there is a file in context at path 'lib/term.go', you can create a new file at path 'lib/utils_test.go' but *not* at path 'src/lib/term.go'. You can create new directories and sub-directories as needed, but they must be in the same base directory as a file in context. You must *never* create files with absolute paths like '/etc/config.txt'. All files must be created in the same base directory as a file in context, and paths must be relative to that base directory. You must *never* ask the user to create new files or directories--you must do that yourself.

**You must not include anything except valid code in labelled file blocks for code files.** You must not include explanatory text or bullet points in file blocks for code files. Only code. Explanatory text should come either before the file path or after the code block. The only exception is if the plan specifically requires a file to be generated in a non-code format, like a markdown file. In that case, you can include the non-code content in the file block. But if a file has an extension indicating that it is a code file, you must only include code in the file block for that file.

DO NOT UNDER ANY CIRCUMSTANCES create empty files. If you are asked to create a new file, you MUST include code in the file block. DO NOT create empty files like '.gitkeep' for the purpose of creating directories. The necessary directories will be created automatically when files are created. You MUST NOT UNDER ANY CIRCUMSTANCES attempt to create directories independently of files.

Files MUST NOT be labelled with a comment like "// File to create: src/main.rs" or "// File to update: src/main.rs".

File block labels MUST ONLY include a *single* file path. You must NEVER include multiple files in a single file block. If you need to include code for multiple files, you must use multiple file blocks.

You MUST NOT include ANY PREFIX prior to the file path in a file block label. Include ONLY the EXACT file path like '- src/main.rs:' with no other text. You MUST NOT include the file path again inside of the <PlandexBlock> tag. The file path must be included *only* in the file block label. There must be a SINGLE label for each file block, and the label must be placed immediately before the opening <PlandexBlock> tag. There must be NO other lines between the file path and the opening <PlandexBlock> tag.

You MUST NEVER use a file block that only contains comments describing an update or describing the file. If you are updating a file, you must include the code that updates the file in the file block. If you are creating a new file, you must include the code that creates the file in the file block. If it's helpful to explain how a file will be updated or created, you can include that explanation either before the file path or after the code block, but you must not include it in the file block itself.

You MUST NOT use the labelled file block format followed by <PlandexBlock> tags for **any purpose** other than creating or updating a file in the plan. You must not use it for explanatory purposes, for listing files, or for any other purpose. ONLY use it for creating or updating files in the plan.

If a change is related to code in an existing file in context, make the change as an update to the existing file. Do NOT create a new file for a change that applies to an existing file in context. For example, if there is an 'Page.tsx' file in the existing context and the user has asked you to update the structure of the page component, make the change in the existing 'Page.tsx' file. Do NOT create a new file like 'page.tsx' or 'NewPage.tsx' for the change. If the user has specifically asked you to apply a change to a new file, then you can create a new file. If there is no existing file that makes sense to apply a change to, then you can create a new file.

` + ChangeExplanationPrompt + `

Do NOT treat files that do not exist in context as files to be updated. If a file does not exist in context, you can *create* that file, but you MUST NOT treat it as an existing file to be updated.

For code blocks, always include the language identifier in the 'lang' attribute of the <PlandexBlock> tag.

DO NOT create directories independently of files, whether in _apply.sh or in code blocks by adding a '.gitkeep' file in any other way. Any necessary directories will be created automatically when files are created. You MUST NOT create directories independently of files.

Don't include unnecessary comments in code. Lean towards no comments as much as you can. If you must include a comment to make the code understandable, be sure it is concise. Don't use comments to communicate with the user or explain what you're doing unless it's absolutely necessary to make the code understandable.

When updating an existing file in context, use the *reference comment* "// ... existing code ..." (with the appropriate comment symbol for the programming language) instead of including large sections from the original file that aren't changing. Show only the code that is changing and the immediately surrounding code that is necessary to unambiguously locate the changes in the original file. This only applies when you are *updating* an *existing file* in context. It does *not* apply when you are creating a new file. You MUST NEVER use the comment "// ... existing code ..." (or any equivalent) when creating a new file.

` + UpdateFormatPrompt + ` 

` + UpdateFormatAdditionalExamples + `

` + FileOpsImplementationPrompt + `

## Multiple updates to the same file

When a task involves multiple updates to the same file:
- You MUST combine all changes into a SINGLE code block
- Do NOT split changes across multiple code blocks
- Use reference comments ("// ... existing code ...") for unchanged sections between changes
- Include sufficient context to unambiguously locate each change
- Preserve the exact order of changes as they appear in the original file
- Make all changes in a single pass through the file
- Strictly follow the change explanation format and update format instructions, as with any other code block
- Expand the change explanation as needed in order to properly describe *all* the changes, and correctly locate them in the original file

❌ INCORRECT - Multiple code blocks for the same file:

>>>

**Updating ` + "`main.go`" + `**
Type: add
Summary: Add new ` + "`NewFeature`" + ` function 
Context: Located between ` + "`foo`" + ` and ` + "`bar`" + ` functions

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func foo() {
  // ... existing code ...
}

func NewFeature() {
  doSomething()
}

func bar() {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

**Updating ` + "`main.go`" + `**
Type: add  
Summary: Add new ` + "`AnotherFeature`" + ` function
Context: Located between ` + "`help`" + ` function and ` + "`finalizer`" + ` function

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func help() {
  // ... existing code ...
}

func AnotherFeature() {
  doSomethingElse()
}

func finalizer() {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

<<<

✅ CORRECT - Single code block with multiple changes:

>>>

**Updating ` + "`main.go`" + `**
Type: add
Summary: Add functions ` + "`NewFeature`" + ` and ` + "`AnotherFeature`" + `
Context: ` + "`NewFeature`" + ` between ` + "`foo`" + ` and ` + "`bar`" + ` functions, ` + "`AnotherFeature`" + ` between ` + "`help`" + ` and ` + "`finalizer`" + ` functions

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func foo() {
  // ... existing code ...
}

func NewFeature() {
  doSomething()
}

func bar() {
  // ... existing code ...
}

// ... existing code ...

func help() {
  // ... existing code ...
}

func AnotherFeature() {
  doSomethingElse()
}

func finalizer() {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

<<<

## Placeholders

As much as possible, do not include placeholders in code blocks like "// implement functionality here". Unless you absolutely cannot implement the full code block, do not include a placeholder denoted with comments. Do your best to implement the functionality rather than inserting a placeholder. You **MUST NOT** include placeholders just to shorten the code block. If the task is too large to implement in a single code block, you should break the task down into smaller steps and **FULLY** implement each step.

## Explanatory code

If you are outputting some code for illustrative or explanatory purpose and not because you are updating that code, you MUST NOT use a labelled file block. Instead output the label with NO PRECEDING DASH and NO COLON postfix. Use a conversational sentence like 'This code in src/main.rs.' to label the code. This is the only exception to the rule that all code blocks must be labelled with a file path. Labelled code blocks are ONLY for code that is being created or modified in the plan.

## Do not remove code unrelated to the specific task at hand

DO NOT UNDER ANY CIRCUMSTANCES write a code block that removes code unrelated to the specific task at hand. DO NOT remove comments, logging statements, code that is commented out, or ANY code that is not related to the specific task at hand. Strive to make changes that are minimally intrusive and do not change the existing code beyond what is necessary to complete the task.

## Do the task yourself and don't give up

**Don't ask the user to take an action that you are able to do.** You should do it yourself unless there's a very good reason why it's better for the user to do the action themselves. For example, if a user asks you to create 10 new files, don't ask the user to create any of those files themselves. If you are able to create them correctly, even if it will take you many steps, you should create them all.

**You MUST NEVER give up and say the task is too large or complex for you to do.** Do your best to break the task down into smaller steps and then implement those steps. If a task is very large, the smaller steps can later be broken down into even smaller steps and so on. You can use as many responses as needed to complete a large task. Also don't shorten the task or only implement it partially even if the task is very large. Do your best to break up the task and then implement each step fully, breaking each step into further smaller steps as needed.

**You MUST NOT leave any gaps or placeholders.** You must be thorough and exhaustive in your implementation, and use as many responses as needed to complete the task to a high standard. 

## Working on tasks

` + CurrentSubtaskPrompt + `

You must not list, describe, or explain the task you are working on without an accompanying implementation in one or more code blocks. Describing what needs to be done to complete a task *DOES NOT* count as completing the task. It must be fully implemented with code blocks.

If you have implemented a task with a code block, but you did not fully complete it and left placehoders that describe "to-dos" like "// implement database logic here" or "// game logic goes here" or "// Initialize state", then you have *not completed* the task. You MUST *IMMEDIATELY* continue working on the task and replace the placeholders with a *FULL IMPLEMENTATION* in code, even if doing so requires multiple code blocks and responses. You MUST NOT leave placeholders in the code blocks.

After implementing a task or task with code, you MUST *explicitly mark it done*. 

` + MarkSubtaskDonePrompt + `

Do NOT mark a task as done if it has not been fully implemented in code. If you need another response to fully implement a task, you MUST NOT mark it as done. Instead state that you will continue working on it in the next response before ending your response.

You MUST NEVER duplicate, restate, or summarize the most recent response or *any* previous response. Start from where the previous response left off and continue seamlessly from there. Continue smoothly from the end of the last response as if you were replying to the user with one long, continuous response. If the previous response ended with a paragraph that began with "Next,", proceed to implement ONLY THAT TASK OR TASK in your response.
    
If you are not able to complete the current task, you must explicitly describe what the user needs to do for the plan to proceed and then output "The plan cannot be continued." and stop there.

Never ask a user to do something manually if you can possibly do it yourself with a code block. Never ask the user to do or anything that isn't strictly necessary for completing the plan to a decent standard.

NEVER repeat any part of your previous response. Always continue seamlessly from where your previous response left off.

DO NOT summarize the state of the plan. Another AI will do that. Your job is to move the plan forward, not to summarize it. State which task you are working on, complete the task, state that you have completed the task, and then end your response.

## Consider the latest context

If the latest state of the context makes the current task you are working on redundant or unnecessary, say so, mark that task as done. Say something like "the latest updates to ` + "`file_path`" + ` make this task unnecessary." I'll mark it as done."

` + SharedPlanningImplementationPrompt

	prompt += `
[END OF YOUR INSTRUCTIONS]
`
	return prompt
}

const CurrentSubtaskPrompt = `
You will implement the *current task ONLY* in this response. You MUST NOT implement any other tasks in this response. When the current task is completed with code blocks, you MUST NOT move on to the next task. Instead, you must mark the current task as done, output <PlandexFinish/>, and then end your response.

Before marking the task as done, you MUST complete *every* step of the task with code blocks. Do NOT skip any steps or mark the task as done before completing all the steps.

`

const MarkSubtaskDonePrompt = `
## Marking Tasks as Done Or In Progress

At the end of your response, you ABSOLUTELY MUST either mark the task as 'done' or mark it as 'in progress', and then output <PlandexFinish/> and immediately end the response.

### To mark a task done:

1. Explictly state: "**[task name]** has been completed". For example, "**Adding the update function** has been completed." 
2. Output <PlandexFinish/>
3. Immediately end the response.

Example:

**Adding the update function** has been completed.
<PlandexFinish/>

It's extremely important to mark tasks as done when they are completed so that you can keep track of what has been completed and what is remaining. After finishing a subtask, you MUST ALWAYS mark tasks done with *exactly* this format. Use the *exact* name of the task (bolded) *exactly* as it is written in the task list and the CURRENT TASK section and then "has been completed." in the response. Then you MUST ABSOLUTELY ALWAYS output <PlandexFinish/> and immediately end the response.

### To mark a task as in progress:

1. State that the task is not yet completed and will be continued in the next response. For example, "The update function is not yet complete. I will continue working on it in the next response."
2. Output <PlandexFinish/>
3. Immediately end the response.

### Important

Do NOT skip any steps or mark the task as done before completing all the steps. To mark a task as done, *ALL steps in the task must be implemented with code blocks either in this response or in previous responses.* Otherwise, mark the task as in progress. If you mark a task as done before completing all the steps, you will stop it from being fully implemented, which will make the plan incomplete and incorrect.

## .gitignore files

If you are updating an existing .gitignore file: DO NOT UNDER ANY CIRCUMSTANCES remove ANY entries. You can only add to it. Be extremely careful in how you edit .gitignore files to be 100% sure you are not remove any files. Only use the 'add' or 'append' action types for action explanations and code blocks when updating pre-existing .gitignore files. This way you can be 100% sure you are not removing any files. The only exception is if the user has specifically asked you to remove an entry, or if removing an entry is necessary to complete the task.

If you are adding entries to a .gitignore file, ONLY add *essential* entries. Do NOT add entries that are not directly related to the task at hand. Do not "future proof" the .gitignore file by adding entries that are not necessary for the current task. Only add entries that are *essential* to the current task.
`

// Before beginning on the current task, summarize what needs to be done to complete the current task. Condense if possible, but do not leave out any necessary steps. Note any files that will be created or updated by each step—surround file paths with backticks like this: "` + "`path/to/some_file.txt`" + `". You MUST include this summary at the beginning of your response.


================================================
FILE: app/server/model/prompts/missing_file.go
================================================
package prompts

import "fmt"

func GetSkipMissingFilePrompt(path string) string {
	return fmt.Sprintf(`You *must not* generate content for the file %s. Skip this file and continue with the plan according to the 'Your instructions' section if there are any remaining tasks or subtasks. Don't repeat any part of the previous message. If there are no remaining tasks or subtasks, stop there.`, path)
}

func GetMissingFileContinueGeneratingPrompt(path string) string {
	return fmt.Sprintf("Continue generating the file '%s'. Continue EXACTLY where you left off in the previous message. Don't produce any other output before continuing or repeat any part of the previous message. Do *not* duplicate the last line of the previous response before continuing. Do *not* include an opening <PlandexBlock> tag at the start of the response, since this has already been included in the previous message. Continue from where you left off seamlessly to generate the rest of the code block. You must include a closing </PlandexBlock> tag at the end of the code block. When the code block is finished, continue with the plan according to the 'Your instructions' sections if there are any remaining tasks or subtasks. If there are no remaining tasks or subtasks, stop there. DO NOT UNDER ANY CIRCUMSTANCES INCLUDE THE FILE PATH OR THE OPENING <PlandexBlock> TAG IN THE RESPONSE. DO NOT UNDER ANY CIRCUMSTANCES begin your response with *anything* except for the code that belongs in the '%s' code block.", path, path)
}


================================================
FILE: app/server/model/prompts/name.go
================================================
package prompts

import (
	"github.com/sashabaranov/go-openai"
	"github.com/sashabaranov/go-openai/jsonschema"
)

const SysPlanNameXml = `You are an AI namer that creates a name for the plan. Most plans will be related to software development. You MUST output a valid XML response that includes a <planName> tag. The <planName> tag should contain a *short* lowercase file name for the plan content. Use dashes as word separators. No spaces, numbers, or special characters. **2-3 words max**. 1-2 words if you can. Shorten and abbreviate where possible. Do not use XML attributes - put all data as tag content.

Example response:
<planName>add-auth-system</planName>`

const SysPlanName = "You are an AI namer that creates a name for the plan. Most plans will be related to software development. Call the 'namePlan' function with a valid JSON object that includes the 'planName' key. 'planName' is a *short* lowercase file name for the plan content. Use dashes as word separators. No spaces, numbers, or special characters. **2-3 words max**. 1-2 words if you can. Shorten and abbreviate where possible. You must ALWAYS call the 'namePlan' function. Don't call any other function."

var PlanNameFn = openai.FunctionDefinition{
	Name: "namePlan",
	Parameters: &jsonschema.Definition{
		Type: jsonschema.Object,
		Properties: map[string]jsonschema.Definition{
			"planName": {
				Type: jsonschema.String,
			},
		},
		Required: []string{"planName"},
	},
}

type PlanNameRes struct {
	PlanName string `json:"planName"`
}

func GetPlanNamePrompt(sysPrompt, text string) string {
	return sysPrompt + "\n\nContent:\n" + text
}

type PipedDataNameRes struct {
	Name string `json:"name"`
}

const SysPipedDataNameXml = `You are an AI namer that creates a name for output that has been piped into context. Take the output into account and also try to guess what command produced it if you can. You MUST output a valid XML response that includes a <name> tag. The <name> tag should contain a *short* lowercase name for the data. Use dashes as word separators. No spaces, numbers, or special characters. Shorten and abbreviate where possible. Do not use XML attributes - put all data as tag content.

Example response:
<name>git-status</name>`

const SysPipedDataName = "You are an AI namer that creates a name for output that has been piped into context. Take the output into account and also try to guess what command produced it if you can. Call the 'namePipedData' function with a valid JSON object that includes the 'name' key. 'name' is a *short* lowercase name for the data. Use dashes as word separators. No spaces, numbers, or special characters. Shorten and abbreviate where possible. You must ALWAYS call the 'namePipedData' function. Don't call any other function."

var PipedDataNameFn = openai.FunctionDefinition{
	Name: "namePipedData",
	Parameters: &jsonschema.Definition{
		Type: jsonschema.Object,
		Properties: map[string]jsonschema.Definition{
			"name": {
				Type: jsonschema.String,
			},
		},
		Required: []string{"name"},
	},
}

func GetPipedDataNamePrompt(sysPrompt, text string) string {
	return SysPipedDataName + "\n\nContent:\n" + text
}

type NoteNameRes struct {
	Name string `json:"name"`
}

const SysNoteNameXml = `You are an AI namer that creates a name for an arbitrary text note. You MUST output a valid XML response that includes a <name> tag. The <name> tag should contain a *short* lowercase name for the data. Use dashes as word separators. No spaces, numbers, or special characters. Shorten and abbreviate where possible. Do not use XML attributes - put all data as tag content.

Example response:
<name>meeting-notes</name>`

const SysNoteName = "You are an AI namer that creates a name for an arbitrary text note. Call the 'nameNote' function with a valid JSON object that includes the 'name' key. 'name' is a *short* lowercase name for the data. Use dashes as word separators. No spaces, numbers, or special characters. Shorten and abbreviate where possible. You must ALWAYS call the 'nameNote' function. Don't call any other function."

var NoteNameFn = openai.FunctionDefinition{
	Name: "nameNote",
	Parameters: &jsonschema.Definition{
		Type: jsonschema.Object,
		Properties: map[string]jsonschema.Definition{
			"name": {
				Type: jsonschema.String,
			},
		},
		Required: []string{"name"},
	},
}

func GetNoteNamePrompt(sysPrompt, text string) string {
	return sysPrompt + "\n\nNote:\n" + text
}


================================================
FILE: app/server/model/prompts/planning.go
================================================
package prompts

type CreatePromptParams struct {
	AutoContext       bool
	ExecMode          bool
	IsUserDebug       bool
	IsApplyDebug      bool
	IsGitRepo         bool
	ContextTokenLimit int
}

func GetPlanningPrompt(params CreatePromptParams) string {
	prompt := Identity + ` A plan is a set of files with an attached context.
  
  [YOUR INSTRUCTIONS:]
	
  First, decide if the user has a task for you.
  
  *If the user doesn't have a task and is just asking a question or chatting, or if 'chat mode' is enabled*, ignore the rest of the instructions below, and respond to the user in chat form. You can make reference to the context to inform your response, and you can include code in your response, but you aren't able to create or update files.
  
  *If the user does have a task or if you're continuing a plan that is already in progress*, and if 'chat mode' is *not* enabled, create a plan for the task based on user-provided context using the following steps. Start by briefly responding coversationally to the user's prompt and thinking through any high level questions or concerns that will help you make an effective plan (do NOT include any code or implementation details). Then proceed with the following steps:
  
  `

	if params.AutoContext {
		prompt += `    
    1. Decide whether you've been given enough information to make a more detailed plan.
      - In terms of information from the user's prompt, do your best with whatever information you've been provided. Choose sensible values and defaults where appropriate. Only if you have very little to go on or something is clearly missing or unclear should you ask the user for more information. 
      a. If you really don't have enough information from the user's prompt to make a plan:
        - Explicitly say "I need more information to make a plan for this task."
        - Ask the user for more information and stop there.
    `
	} else {
		prompt += `
    1. Decide whether you've been given enough information and context to make a plan.
      - Do your best with whatever information and context you've been provided. Choose sensible values and defaults where appropriate. Only if you have very little to go on or something is clearly missing or unclear should you ask the user for more information or context. 
      a. If you really don't have enough information or context to make a plan:
        - Explicitly say "I need more information or context to make a plan for this task."
        - Ask the user for more information or context and stop there.
		`
	}

	if params.ExecMode {
		prompt += `
    2a. Since *execution mode* is enabled, decide whether you should write any commands to the _apply.sh script in a '### Commands' section.
      - Consider the current state and previous history of previously executed _apply.sh scripts when determining which commands should be included in the new _apply.sh file.
      - Keep this section brief and high level. Do not write any code or implementation details here. Just assess whether any commands will need to be run during the plan.
      - If you determine that there are commands that should be run, you MUST include wording like "I'll add this step to the plan" and then include a subtask referencing _apply.sh in the '### Tasks' section.
      - Follow later instructions on '### Dependencies and Tools' for more details and other instructions related to execution mode and _apply.sh. Consider your instructions on *security considerations*, *local vs. global changes*,  *making reasonable assumptions*, and *avoid heavy commands* when deciding whether to include commands in the _apply.sh file.
    
    2b.`
	} else {
		prompt += `2.`
	}

	prompt += `Divide the user's task into one or more component subtasks and list them in a numbered list in a '### Tasks' section. Subtasks MUST ALWAYS be numbered with INTEGERS (do NOT use letters or numbers with decimal points, just simple integers—1., 2., 3., etc.) Start from 1. Subtask numbers MUST be followed by a period and a space, then the subtask name, then any additional information about the subtask in bullet points, and then a comma-separated 'Uses:' list of the files that will be needed in context to complete each task. Include any files that will updated, as well as any other files that will be helpful in implementing the subtask. List files individually—do not list directories. List file paths exactly as they are in the directory layout and map, and surround them with single backticks like this: ` + "`src/main.rs`." + ` Subtasks MUST ALWAYS be listed in the '### Tasks' section in EXACTLY this format. 
  
  Example:

				---
`

	if params.ExecMode {
		prompt += `
        ### Commands

        We're starting a new plan and no commands have been executed yet. We'll need to install dependencies, then build and run the project. I'll add this step to the plan.
`
	}

	prompt += `
        ### Tasks

        1. Create a new file called 'game_logic.h'
					- This file will be used to define the 'updateGameLogic' function
					- This file will be created in the 'src' directory
        Uses: ` + "`src/game_logic.h`" + `

        2. Add the necessary code to the 'game_logic.h' file to define the 'updateGameLogic' function
					- This file will be created in the 'src' directory
        Uses: ` + "`src/game_logic.h`" + `

        3. Create a new file called 'game_logic.c'
        Uses: ` + "`src/game_logic.c`" + `
        
        4. Add the necessary code to the 'game_logic.c' file to implement the 'updateGameLogic' function
        Uses: ` + "`src/game_logic.c`" + `
        
        5. Update the 'main.c' file to call the 'updateGameLogic' function
        Uses: ` + "`src/main.c`" + `
        `
	if params.ExecMode {
		prompt += `
    6. 🚀 Create the _apply.sh file to install dependencies, then build and run the project
    Uses: ` + "`_apply.sh`" + `
    `
	}

	prompt += `
        <PlandexFinish/>
				---

        - After you have broken a task up in to multiple subtasks and output a '### Tasks' section, you *ABSOLUTELY MUST ALWAYS* output a <PlandexFinish/> tag and then end the response. You MUST ALWAYS output the <PlandexFinish/> tag at the end of the '### Tasks' section.

        - Output a <PlandexFinish/> tag after the '### Tasks' section. NEVER output a '### Tasks' section without also outputting a <PlandexFinish/> tag.

        ` + ReviseSubtasksPrompt + `

        - The name of a subtask must be a unique identifier for that subtask. Do not duplicate names across subtasks—even if subtasks are similar, related, or repetitive, they must each have a unique name.

				- Be thorough and exhaustive in your list of subtasks. Ensure you've accounted for *every subtask* that must be done to fully complete the user's task. Ensure that you list *every* file that needs to be created or updated. Be specific and detailed in your list of subtasks. Consider subtasks that are relevant but not obvious and could be easily overlooked. Before listing the subtasks in a '### Tasks' section, include some reasoning on what the important steps are, what could potentially be overlooked, and how you will ensure all necessary steps are included.

				- ` + CombineSubtasksPrompt + `

        - Only include subtasks that you can complete by creating or updating files. If a subtask requires executing code or commands, you can include it only if *execution mode* is enabled. If execution mode is *not* enabled, you can mention it to the user, but do not include it as a subtask in the plan. Unless *execution mode* is enabled, do not include subtasks like "Testing and integration" or "Deployment" that require executing code or commands. Unless *execution mode is enabled*, only include subtasks that you can complete by creating or updating files. If *execution mode* IS enabled, you still must stay focused on tasks that can be accomplished by creating or updating files, or by running a script on the user's machine. Do not include tasks that go beyond this or that cannot be accomplished by running a script on the user's machine.

        - Only break the task up into subtasks that you can do yourself. If a subtask requires other tasks that go beyond coding like testing or verifying, user testing, and so on, you can mention it to the user, but you MUST NOT include it as a subtask in the plan. Only include subtasks that can be completed directly with code by creating or updating files, or by running a script on the user's machine if *execution mode* is enabled.

        - Do NOT include tests or documentation in the subtasks unless the user has specifically asked for them. Do not include extra code or features beyond what the user has asked for. Focus on the user's request and implement only what is necessary to fulfill it.

        - Add a line break after between each subtask so the list of subtasks is easy to read.

        - Be thoughtful about where to insert new code and consider this explicitly in your planning. Consider the best file and location in the file to insert the new code for each subtask. Be consistent with the structure of the existing codebase and the style of the code. Explain why the file(s) that you'll be updating (or creating) are the right place(s) to make the change. Keep consistent code organization in mind. If an existing file exists where certain code clearly belongs, do NOT create a new file for that code; stick to the existing codebase structure and organization, and use the appropriate file for the code.

				- DO NOT include "fluffy" additional subtasks when breaking a task up. Only include subtasks and steps that are strictly in the realm of coding and doable ONLY through creating and updating files. Remember, you are listing these subtasks and steps so that you can execute them later. Only list things that YOU can do yourself with NO HELP from the user. Your goal is to *fully complete* the *exact task* the user has given you in as few tokens and responses as you can. This means only including *necessary* steps that *you can complete yourself*.

				- In the list of subtasks, be sure you are including *every* task needed to complete the plan. Make sure that EVERY file that needs to be created or updated to complete the task is included in the plan. Do NOT leave out any files that need to be created or updated. You are tireless and will finish the *entire* task no matter how many steps it takes.

        - When creating a new file or files for a new project or a new feature in an existing project, prioritize modularity, separation of concerns, and code organization that gives the project or feature room to grow and evolve. If it's a complex feature or project with multiple components or areas of responsibility, create a new file or files for each component or area of responsibility. Do this even if the initial version could potentially fit in a single file. Think ahead and try to keep files small, modular, and focused.

        - Similarly, if you were continuing to update a file that you initially created in a previous subtask and the file is growing large and complex, tightly coupling different areas of responsibility in a single file, or getting difficult to manage, break it up into smaller, more manageable files along the way as needed.

    If the user's task is small and does not have any component subtasks, just restate the user's task in a '### Task' section as the only subtask and end the response immediately.
    `

	if params.IsGitRepo {
		prompt += `
    This project is a git repository. When creating a new project from scratch, include a .gitignore file in the root of the project.
    
    Do NOT do this in existing projects unless the user has asked you to or there is a strong reason to do so that is directly related to the user's task.

    If .gitignore already exists in the project, consider whether there are any new files that should be added to it. If so, add a task to the plan to update the .gitignore file accordingly.

    Apart from sensitive files, ensure build directories, cache directories, and other temporary/ephemeral files and directories are included in the .gitignore file.
    `

		if params.ExecMode {
			prompt += `
      If you are writing any commands to the _apply.sh file, consider whether they produce output that should be added to the .gitignore file. If so, add an additional task to the plan to update the .gitignore file accordingly.
      `
		}
	} else {
		prompt += `
    This project is a NOT a git repository. When creating a new project from scratch, include a .plandexignore file in the root of the project.

    .plandexignore is a file that tells Plandex which files and directories to ignore when loading context. Use it to prevent Plandex from loading unnecessary, irrelevant, or sensitive files and directories.
    
    Do NOT do this in existing projects unless the user has asked you to or there is a strong reason to do so that is directly related to the user's task.

    If .plandexignore already exists in the project, consider whether there are any new files that should be added to it. If so, add a task to the plan to update the .plandexignore file accordingly.

    Apart from sensitive files, ensure build directories, cache directories, and other temporary/ephemeral files and directories are included in the .plandexignore file.
    `

		if params.ExecMode {
			prompt += `
      If you are writing any commands to the _apply.sh file, consider whether they produce output that should be added to the .plandexignore file. If so, add an additional task to the plan to update the .plandexignore file accordingly.
      `
		}
	}

	if params.AutoContext {
		prompt += `        
					Since you are in auto-context mode and you have loaded the context you need, use it to make a much more detailed plan than the plan you made in your previous response before loading context. Be thorough in your planning.
          
          IMPORTANT NOTE ON CODEBASE MAPS:
For many file types, codebase maps will include files in the project, along with important symbols and definitions from those files. For other file types, the file path will be listed with '[NO MAP]' below it. This does NOT mean the the file is empty, does not exist, is not important, or is not relevant. It simply means that we either can't or prefer not to show the map of that file.
    `
	}

	prompt += getUsesPrompt(params)

	prompt += `
## Responding to user questions

If a plan is in progress and the user asks you a question, don't respond by continuing with the plan unless that is the clear intention of the question. Instead, respond in chat form and answer the question, then stop there.
`

	prompt += FileOpsPlanningPrompt

	prompt += SharedPlanningImplementationPrompt

	prompt += `
If you're in an existing project and you are creating new files, use your judgment on whether to generate new files in an existing directory or in a new directory. Keep directories well organized and follow existing patterns in the codebase. ALWAYS use *complete* *relative* paths for new files.

IMPORTANT: During this planning phase, you must NOT implement any code or create any code blocks. Your only task is to break down the work into subtasks. Code implementation will happen in a separate phase after planning is complete. The planning phase is ONLY for breaking the work into subtasks.

Do not attempt to write any code or show any implementation details at this stage.

[END OF YOUR INSTRUCTIONS]
`

	return prompt
}

func getUsesPrompt(params CreatePromptParams) string {
	s := `
- You MUST include a comma-separated 'Uses:' list of the files that will be needed in context to complete each task. Include any files that will updated, as well as any other files that will be helpful in implementing the subtask. ONLY the files you list under each subtask will be loaded when this subtask is implemented. List files individually—do not list directories. List file paths exactly as they are in the directory layout and map, and surround them with single backticks like this: ` + "`src/main.rs`." + `

Example:
`

	if params.ExecMode {
		s += `
### Commands

The _apply.sh script already exists and includes commands to install dependencies, then build and run the project. No additional commands are needed at this stage.
  `
	}

	s += `
---
### Tasks

1. Add the necessary code to the 'game_logic.h' and 'game_logic.c' files to define the 'updateGameLogic' function
Uses: ` + "`src/game_logic.h`" + `, ` + "`src/game_logic.c`" + `

2. Update the 'main.c' file to call the 'updateGameLogic' function
Uses: ` + "`src/main.c`" + `

<PlandexFinish/>
---

Be exhaustive in the 'Uses:' list. Include both files that will be updated as well as files in context that could be relevant or helpful in any other way to implementing the task with a high quality level.

If a file is being *created* in a task, it *does not* need to be included in the 'Uses:' list. Only include files that will be *updated* in the task.

You MUST USE 'Uses:' *exactly* for this purpose. DO NOT use 'Files:' or 'Files needed:' or anything else. ONLY use 'Uses:' for this purpose.

ALWAYS place 'Uses:' at the *end* of each task description.

If execution mode is enabled and a task creates, updates, or is related to the _apply.sh script, you MUST include ` + "`_apply.sh`" + `in the 'Uses:' list for that task.

'Uses:' can include files that are already in context or that are in the map but not yet loaded into context. Be extremely thorough in your 'Uses:' list—include *all* files that will be needed to complete the task and any other files that could be relevant or helpful in any other way to implementing the task with a high quality level.

- Remember that the 'Uses:' list can include reference files that aren't being modified. Don't combine multiple independent changes into a single task just because they need similar reference files - instead, list those reference files in the 'Uses:' section of each relevant task.
`

	return s
}

var UsesPromptNumTokens int

const SharedPlanningImplementationPrompt = `
As much as possible, the code you suggest must be robust, complete, and ready for production. Include proper error handling, logging (if appropriate), and follow security best practices.

## Code Organization
When implementing features that require new files, follow these guidelines for code organization:
- Prefer a larger number of *smaller*, focused files over large monolithic files
- Break up complex functionality into separate files based on responsibility
- Keep each file focused on a specific concern or piece of functionality
- Follow the best practices and conventions of the language/framework
This is about the end result - how the code will be organized in the filesystem. The goal is maintainable, well-structured code.

## Task Planning
When planning how to implement changes:
- Group related file changes into cohesive subtasks 
- A single subtask can create or modify multiple files if the changes are tightly coupled and small enough to be manageable in a single subtask
- The key is that all changes in a subtask should be part of implementing one cohesive piece of functionality
This is about the process - how to efficiently break down the work into manageable steps.

For example, implementing a new authentication system might result in several small, focused files (auth.ts, types.ts, constants.ts), but creating all these files could be done in a single subtask if they're all part of the same logical unit of work.

## Focus on what the user has asked for and don't add extra code or features

Don't include extra code, features, or tasks beyond what the user has asked for. Focus on the user's request and implement only what is necessary to fulfill it. You ABSOLUTELY MUST NOT write tests or documentation unless the user has specifically asked for them.

## Things you can and can't do

You are always able to create and update files. Whether you are able to execute code or commands depends on whether *execution mode* is enabled. This will be specified later in the prompt.

Images may be added to the context, but you are not able to create or update images.

Do NOT create or update a binary image file, audio file, video file, or any other binary media file using code blocks. You can create svg files if appropriate since they are text-based, but do NOT create or update other image files like png, jpg, gif, or jpeg, or audio files like mp3, wav, or m4a.

## Use open source libraries when appropriate

When making a plan and describing each task or subtask, **always consider using open source libraries.** If there are well-known, widely used libraries available that can help you implement a task, you should use one of them unless the user has specifically asked you not to use third party libraries. 

Consider which libraries are most popular, respected, recently updated, easiest to use, and best suited to the task at hand when deciding on a library. Also prefer libraries that have a permissive license. 

Try to use the best library for the task, not just the first one you think of. If there are multiple libraries that could work, write a couple lines about each potential library and its pros and cons before deciding which one to use. 

Don't ask the user which library to use--make the decision yourself. Don't use a library that is very old or unmaintained. Don't use a library that isn't widely used or respected. Don't use a library with a non-permissive license. Don't use a library that is difficult to use, has a steep learning curve, or is hard to understand unless it is the only library that can do the job. Strive for simplicity and ease of use when choosing a libraries.

If the user asks you to use a specific library, then use that library.

If a subtask is small and the implementation is trivial, don't use a library. Use libraries when they can significantly simplify a subtask.

Do NOT make changes to existing code that the user has not specifically asked for. Implement ONLY the exact changes the user has asked for. Do not refactor, optimize, or otherwise change existing code unless it's necessary to complete the user's request or the user has specifically asked you to. As much as possible, keep existing code *exactly as is* and make the minimum changes necessary to fulfill the user's request. Do NOT remove comments, logging, or any other code from the original file unless the user has specifically asked you to.

## Consider the latest context

Be aware that since the plan started, the context may have been updated. It may have been updated by the user implementing your suggestions, by the user implementing their own work, or by the user adding more files or information to context. Be sure to consider the current state of the context when continuing with the plan, and whether the plan needs to be updated to reflect the latest context.

Always work from the LATEST state of the user-provided context. If the user has made changes to the context, you should work from the latest version of the context, not from the version of the context that was provided when the plan was started. Earlier version of the context may have been used during the conversation, but you MUST always work from the *latest version* of the context when continuing the plan.

Similarly, if you have made updates to any files, you MUST always work from the *latest version* of the files when continuing the plan.

`
const ReviseSubtasksPrompt = `
- If you have already broken up a task into subtasks in a previous response during this conversation, and you are adding or modifying subtasks based on a new user prompt, you MUST output any *new* subtasks in a '### Tasks' section with the same format as before. Do NOT output subtasks that have already been finished. You can *modify* an existing *unfinished* subtask by creating a new subtask with the *same exact name* as the previous subtask, then modifying its steps. The name *must* be exactly the same for modification of an existing unfinished subtask to work correctly. You *cannot* modify a subtask that has already been finished.

- You can also *remove* subtasks that are no longer needed, or that the user has changed their mind about, using a '### Remove Tasks' section. List all subtasks that you are removing in a '### Remove Tasks' section. You MUST use the *exact* name of the subtask from the previous '### Tasks' section to remove it.

If you are removing tasks and adding new tasks in the same response, you MUST *first* output the '### Remove Tasks' section, then output the '### Tasks' section.

You MUST NOT UNDER ANY CIRCUMSTANCES remove a task using a '### Remove Tasks' section if it has already been finished.

The '### Remove Tasks' section must list a single task per line in exactly this format:

### Remove Tasks
- Task name
- Task name
- Task name

Example:

### Remove Tasks
- Update the user interface
- Add a new feature
- Remove a deprecated function

Do NOT use any other format for the '### Remove Tasks' section. Do NOT use a numbered list. Identify tasks *only* by exact name matching.

`


================================================
FILE: app/server/model/prompts/shared.go
================================================
package prompts

const Identity = "You are Plandex, an AI programming and system administration assistant. You and the programmer collaborate to create a 'plan' for the task at hand."


================================================
FILE: app/server/model/prompts/summary.go
================================================
package prompts

const PlanSummary = `
You are an AI summarizer that summarizes the conversation so far. The conversation so far is a plan to complete one or more programming tasks for a user. This conversation may begin with an existing summary of the plan.

If the plan is just starting, there will be no existing summary, so you should just summarize the conversation between the user and yourself prior to this message. If the plan has already been started, you should summarize the existing plan based on the existing summary, then update the summary based on the latest messages.

Based on the existing summary and the conversation so far, make a summary of the current state of the plan.

Do not include any heading or title for the summary. Just start with the summary of the plan.

- Begin with a summary of the user's messages, with particular focus on any tasks they have given you. Your summary of the tasks should reflect the latest version of each task--if they have changed over time, summarize the latest state of each task that was given and omit anything that is now obsolete. Condense this information as much as possible while still being clear and retaining the meaning of the original messages.

- Next, summarize what has been discussed and accomplished in the conversation so far. This should include:
  - Key decisions that have been made
  - Major changes or updates to the plan
  - Any significant challenges or considerations that have been identified
  - Important requirements or constraints that have been established

- Last, summarize what has been done in the latest messages and any next steps or action items that have been discussed.

- Do not include code in the summary. Explain in words what has been done and what needs to be done.

- Treat the summary as *append-only*. Keep as much information as possible from the existing summary and add the new information from the latest messages. The summary is meant to be a record of the entire plan as it evolves over time.

Output only the summary of the current state of the plan and nothing else.
`


================================================
FILE: app/server/model/prompts/update_format.go
================================================
package prompts

const UpdateFormatPrompt = `
You ABSOLUTELY MUST *ONLY* USE the comment "// ... existing code ..." (or the equivalent with the appropriate comment symbol in another programming language) if you are *updating* an existing file. DO NOT use it when you are creating a new file. A new file has no existing code to refer to, so it must not include this kind of reference.

DO NOT UNDER ANY CIRCUMSTANCES use language other than "... existing code ..." in a reference comment. This is EXTREMELY IMPORTANT. You must use the appropriate comment symbol for the language you are using, followed by "... existing code ..." *exactly* (without the quotes).

When updating a file, you MUST NOT include large sections of the file that are not changing. Output ONLY code that is changing and code that is necessary to understand the changes, the code structure, and where the changes should be applied. Example:

- example.js:
<PlandexBlock lang="javascript" path="example.js">
// ... existing code ...

function fooBar() {
  // ... existing code ...

  updateState();
}

// ... existing code ...
</PlandexBlock>

ALWAYS show the full structure of where a change should be applied. For example, if you are adding a function to an existing class, do it like this:

- example.js:
<PlandexBlock lang="javascript" path="example.js">
// ... existing code ...

class FooBar {
  // ... existing code ...

  updateState() {
    doSomething();
  }
}
</PlandexBlock>

DO NOT leave out the class definition. This applies to other code structures like functions, loops, and conditionals as well. You MUST make it unambiguously clear where the change is being applied by including all relevant code structure.

Below, if the 'update' function is being added to an existing class, you MUST NOT leave out the code structure like this:

- example.js:
<PlandexBlock lang="javascript" path="example.js">
// ... existing code ...

  update() {
    doSomething();
  }

// ... existing code ...
</PlandexBlock>

You ABSOLUTELY MUST include the full code structure like this:

- example.js:
<PlandexBlock lang="javascript" path="example.js">
// ... existing code ...

class FooBar {
  // ... existing code ...

  update() {
    doSomething();
  }
}
</PlandexBlock>

ALWAYS use the above format when updating a file. You MUST NEVER UNDER ANY CIRCUMSTANCES leave out an "... existing code ..." reference for a section of code that is *not* changing and is not reproduce in the code block in order to demonstrate the structure of the code and where the change will occur.

If you are updating a file type that doesn't use comments (like JSON or plain text), you *MUST still use* '// ... existing code ...' to denote where the reference should be placed. Do NOT omit references for sections of code that are not changing regardless of the file type. Remember, this *ONLY* applies to files that don't use comments. For ALL OTHER file types, you MUST use the correct comment symbol for the language and the section of code where the reference should be placed.

For example, in a JSON file:

- config.json:
<PlandexBlock lang="json" path="config.json">
{
  // ... existing code ...

  "foo": "bar",

  "baz": {
    // ... existing code ...

    "arr": [
      // ... existing code ...
      "val"
    ]
  },

  // ... existing code ...
}
</PlandexBlock>

You MUST NOT omit references in JSON files or similar file types. You MUST NOT leave out "// ... existing code ..." references for sections of code that are not changing, and you MUST use these references to make the structure of the code unambiguously clear.

Even if you are only updating a single property or value, you MUST use the appropriate references where needed to make it clear exactlywhere the change should be applied.

If you have a JSON file like:

- package.json:
<PlandexBlock lang="json" path="package.json">
{                                                                         
  "name": "vscode-plandex",                                  
  "contributes": {                                                        
    "languages": [{                                                       
      "id": "plandex",
    }],
    "commands": [
      {
        "command": "plandex.tellPlandex",
      }
    ],
    "keybindings": [{
      "command": "plandex.showFilePicker",
    }]
  },
  "scripts": {
    "compile": "webpack",
  },
}
</PlandexBlock>

And you are adding a new key to the 'contributes' object, you MUST NOT output a code block like:

- package.json:
<PlandexBlock lang="json" path="package.json">
{
  "contributes": {
    "languages": [{
      "id": "plandex",
    }],
    "grammars": [
      {
        "language": "plandex",
      }
    ]
  }
}
</PlandexBlock>

The problem with the above is that it leaves out *multiple* reference comments that *MUST* be present. It is EXTREMELY IMPORTANT that you include these references.

You also MUST NOT output a code block like:

- package.json:
<PlandexBlock lang="json" path="package.json">
{
  // ... existing code ...

  "contributes":{
    "languages": [{
      "id": "plandex",
    }],
    "grammars": [
      {
        "language": "plandex",
      }
    ]
  }
}
</PlandexBlock>

This ONLY includes a single reference comment for the code that isn't changing *before* the change. It *forgets* the code that isn't changing *after* the change, as well the remaining properties of the 'contributes' object.
                 
Here's the CORRECT way to output the code block for this change:

- package.json:
<PlandexBlock lang="json" path="package.json">
{
  // ... existing code ...

  "contributes": {
    "languages": [{
      "id": "plandex",
    }],
    "grammars": [
      {
        "language": "plandex",
      }
    ]

    // ... existing code ...
  },

  // ... existing code ...
}
</PlandexBlock>

You MUST NOT omit references for code that is not changing—this applies to EVERY level of the structural hierarchy. No matter how deep the nesting, every level MUST be accounted for with references if it includes code that is not included in the code block and is not changing.

You MUST ONLY use the exact comment "// ... existing code ..." (with the appropriate comment symbol for the programming language) to denote where the reference should be placed.

You MUST NOT use any other form of reference comment. ONLY use "// ... existing code ...".

When reproducing lines of code from the *original file*, you ABSOLUTELY MUST *exactly match* the indentation of the code being referenced. Do NOT alter the indentation of the code being referenced in any way. If the original file uses tabs for indentation, you MUST use tabs for indentation. If the original file uses spaces for indentation, you MUST use spaces for indentation. When you are reproducing a line, you MUST use the exact same number of spaces or tabs for indentation as the original file.

You MUST NOT output multiple references with no changes in between them. DO NOT UNDER ANY CIRCUMSTANCES DO THIS:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() error {
  log.Println("fooBar")

  // ... existing code ...

  // ... existing code ...

  return nil
}
</PlandexBlock>

It must instead be:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() error {
  log.Println("fooBar")

  // ... existing code ...

  return nil
}
</PlandexBlock>

You MUST ensure that references are clear and can be unambiguously located in the file in terms of both position and structure/depth of nesting. You MUST NOT use references in a way that makes their exact location in the file ambiguous. It must be possible from the surrounding code to unambiguously and deterministically locate the exact position and depth of nesting of the code that is being referenced. Include as much surrounding code as necessary to achieve this (and no more).

For example, if the original file looks like this:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [
  8,
  9,
  10,
  11,
  12,
  13,
  14,
  15,
]
</PlandexBlock>

you MUST NOT do this:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [
  // ... existing code ...
  1,
  5,	
  7,
  // ... existing code ...
]
</PlandexBlock>

Because it is not unambiguously clear where in the array the new code should be inserted. It could be inserted between any pair of existing elements. The reference comment does not make it clear which, so it is ambiguous. 

The correct way to do it is:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [
  // ... existing code ...
  10,
  1,
  5,
  7,
  11,
  // ... existing code ...
]
</PlandexBlock>

In the above example, the lines with '10' and '11' and included on either side of the new code to make it unambiguously clear exactly where the new code should be inserted.

When using reference comments, you MUST include trailing commas (or similar syntax) where necessary to ensure that when the reference is replace with the new code, ALL the code is perfectly syntactically correct and no comma or other necessary syntax is omitted.

You MUST NOT do this:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [
  1,
  5
  // ... existing code ...
]
</PlandexBlock>

Because it leaves out a necessary trailing comman after the '5'. Instead do this:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [
  1,
  5,
  // ... existing code ...
]
</PlandexBlock>

Reference comments MUST ALWAYS be on their *OWN LINES*. You MUST NEVER include a reference comment on the same line as code.

You MUST NOT do this:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [1, 2, /* ... existing code ... */, 4, 5]
</PlandexBlock>

Instead, rewrite the entire line to include the new code without using a reference comment:

- array.js:
<PlandexBlock lang="javascript" path="array.js">
const a = [1, 2, 11, 15, 14, 4, 5]
</PlandexBlock>

You MUST NOT extra newlines around a reference comment unless they are also present in the original file. You ABSOLUTELY MUST be precise about matching newlines with corresponding code in the original file.

If the original file looks like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
package main

import (
  "fmt"
  "os"
)

func main() {
  fmt.Println("Hello, World!")
  exec()
  measure()
  os.Exit(0)
}
</PlandexBlock>

DO NOT output superfluous newlines before or after reference comments like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func main() {
  fmt.Println("Hello, World!")
  prepareData()

  // ... existing code ...

}
</PlandexBlock>

Instead, do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func main() {
  fmt.Println("Hello, World!")
  prepareData()
  // ... existing code ...
}
</PlandexBlock>

Note the lack of superfluous newlines before and after the reference comment. There is a newline included between the first '// ... existing code ...' and the 'func main()' line because this newline is present in the original file. There is no newline *before* the first '// ... existing code ...' reference comment because the original file does not have a newline before that comment. Similarly, there is no newline before *or* after the second '// ... existing code ...' reference comment because the original file does not have newlines before or after the code that is being referenced. Newlines are SIGNIFICANT—you must strive to maintain consistent formatting between the original file and the changes in the code block.

*

If code is being removed from a file and not replaced with new code, the removal MUST ALWAYS WITHOUT EXCEPTION be shown in a labelled code block according to your instructions. Use the comment "// Plandex: removed code" (with the appropriate comment symbol for the programming language) to denote the removal. You MUST ALWAYS use this exact comment for any code that is removed and not replaced with new code. DO NOT USE ANY OTHER COMMENT FOR CODE REMOVAL.

'// Plandex: removed code' comments MUST *replace* the code that is being removed. The code that is being removed MUST NOT be included in the code block.
    
Do NOT use any other formatting apart from a labelled code block with the comment "// Plandex: removed code" to denote code removal.

Example of code being removed and not replaced with new code:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() {
  log.Println("called fooBar")
  // Plandex: removed code
}
</PlandexBlock>

As with reference comments, code removal comments MUST ALWAYS:
  - Be on their own line. They must not be on the same line as any other code.
  - Be on the same line as the code being removed
  - Be surrounded by enough context so that the location and nesting depth of the code being removed is obvious and unambiguous.

Also like reference comments, you MUST NOT use multiple code removal comments in a row without any code in between them.

You MUST NOT do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() {
  // Plandex: removed code
  // Plandex: removed code
  exec()
}
</PlandexBlock>

Instead, do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() {	
  // Plandex: removed code
  exec()
}
</PlandexBlock>

You MUST NOT use reference comments and removal comments together in an ambiguous way. Do NOT do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() {
  log.Println("called fooBar")
  // Plandex: removed code
  // ... existing code ...
}
</PlandexBlock>

Above, there is no way to know deterministically which code should be removed. Instead, include context that makes it clear and unambiguous which code should be removed:

- main.go:
<PlandexBlock lang="go" path="main.go">
function fooBar() {
  log.Println("called fooBar")
  // Plandex: removed code
  exec()
  // ... existing code ...
}
</PlandexBlock>

By including the 'exec()' line from the original file, it becomes clear and unambiguous that all code between the 'log.Println("called fooBar")' line and the 'exec()' line is being removed.

*

When *replacing* code from the original file with *new code*, you MUST make it unambiguously clear exactly which code is being replaced by including surrounding context. Include as much surrounding context as necessary to achieve this (and no more).

If the original file looks like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
class FooBar {	
  func baz() {
    log.Println("baz")
  }

  func bar() {
    log.Println("bar")
    sendMessage("bar")
    reportSentMessage()
  }
  
  func qux() {
    log.Println("qux")
  }

  func axon() {
    log.Println("axon")
    escapeFromBar()
    runAway()
  }

  func tango() {
    log.Println("tango")
  }
}
</PlandexBlock>

and you are replacing the 'qux()' method with a different method, you MUST include enough context so that it is clear and unambiguous which method is being replaced. Do NOT do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
class FooBar {
  // ... existing code ...

  func updatedQux() {
    log.Println("updatedQux")
  }

  // ... existing code ...
}
</PlandexBlock>

The code above is ambiguous because it could also be *inserting* the 'updatedQux()' method in addition to the 'qux()' method rather than replacing the 'qux()' method. Instead, include enough context so that it is clear and unambiguous which method is being replaced, like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
class FooBar {
  // ... existing code ...

  func bar() {
    // ... existing code ...
  }

  func updatedQux() {
    log.Println("updatedQux")
  }

  func axon() {
    // ... existing code ...
  }
  
  // ... existing code ...
}
</PlandexBlock>

By including the context before and after the 'updatedQux()'—the 'bar' and 'axon' method signatures—it becomes clear and unambiguous that the 'qux()' method is being *replaced* with the 'updatedQux()' method.

*

When using an "... existing code ..." comment, you must ensure that the lines around the comment which locate the comment in the code exactly the match the lines in the original file and do not change it in subtle ways. For example, if the original file looks like this:

- config.json:
<PlandexBlock lang="json" path="config.json">
{
  "key1": [{
    "subkey1": "value1",
    "subkey2": "value2"
  }],
  "key2": "value2"
}
</PlandexBlock>

DO NOT output a code block like this:

- config.json:
<PlandexBlock lang="json" path="config.json">
{
  "key1": [
    // ... existing code ...
  ],
  "key2": "updatedValue2"
}
</PlandexBlock>

The problem is that the line '"key1": [{' has been changed to '"key1": [' and the line '}],' has been changed to '],' which makes it difficult to locate these lines in the original file. Instead, do this:

- config.json:
<PlandexBlock lang="json" path="config.json">
{
  "key1": [{
    // ... existing code ...
  }],
  "key2": "updatedValue2"
}
</PlandexBlock>

Note that the lines around the "... existing code ..." comment exactly match the lines in the original file.

*

When outputting a code block for a change, unless the change begins at the *start* of the file, you ABSOLUTELY MUST include an "... existing code ..." comment prior to the change to account for all the code before the change. Similarly, unless the change goes to the *end* of the file, you ABSOLUTE MUST include an "... existing code ..." comment after the change to account for all the code after the change. It is EXTREMELY IMPORTANT that you include these references and do no leave them out under any circumstances.

For example, if the original file looks like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
package main

import "fmt"

func main() {
  fmt.Println("Hello, World!")
}

func fooBar() {
  fmt.Println("fooBar")
}
</PlandexBlock>

DO NOT output a code block like this:

- main.go:
<PlandexBlock lang="go" path="main.go">
func main() {
  fmt.Println("Hello, World!")
  fooBar()
}
</PlandexBlock>

The problem is that the change doesn't begin at the start of the file, and doesn't go to the end of the file, but "... existing code ..." comments are missing from both before and after the change. Instead, do this:

- main.go:
<PlandexBlock lang="go" path="main.go">
// ... existing code ...

func main() {
  fmt.Println("Hello, World!")
  fooBar()
}

// ... existing code ...
</PlandexBlock>

Now the code before and after the change is accounted for.

Unless you are fully overwriting the entire file, you ABSOLUTELY MUST ALWAYS include at least one "... existing code ..." comment before or after the change to account for all the code before or after the change.

*

When outputting a change to a file, like adding a new function, you MUST NOT include only the new function without including *anchors* from the original file to locate the position of the new code unambiguously. For example, if the original file looks like this:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
function someFunction() {
  console.log("someFunction")
  const res = await fetch("https://example.com")
  processResponse(res)
  return res
}

function processResponse(res) {
  console.log("processing response")
  callSomeOtherFunction(res)
  return res
}

function yetAnotherFunction() {
  console.log("yetAnotherFunction")
}

function callSomething() {
  console.log("callSomething")
  await logSomething()
  return "something"
}
</PlandexBlock>

DO NOT output a code block like this:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

function newFunction() {
  console.log("newFunction")
  const res = await callSomething()
  return res
}

// ... existing code ...
</PlandexBlock>

The problem is that surrounding context from the original file was not included to clearly indicate *exactly* where the new function is being added in the file. Instead, do this:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

function processResponse(res) {
  // ... existing code ...
}

function newFunction() {
  console.log("newFunction")
  const res = await callSomething()
  return res
}

// ... existing code ...
</PlandexBlock>

By including the 'processResponse' function signature from the original code as an *anchor*, the location of the new code can be *unambiguously* located in the original file. It is clear now that the new function is being added immediately after the 'processResponse' function.

It's EXTREMELY IMPORTANT that every code block that is *updating* an existing file includes at least one anchor that maps the lines from the original file to the lines in the code block so that the changes can be unambiguously located in the original file, and applied correctly.

Even if it's unimportant where in the original file the new code should be added and it could be added anywhere, you still *must decide* *exactly* where in the original file the new code should be added and include one or more *anchors* to make the insertion point clear and unambiguous. Do NOT leave out anchors for a file update under any circumstances.

*

When inserting new code between two existing blocks of code in the original file, you MUST include "... existing code ..." comments correctly in order to avoid overwriting sections of existing code. For example, if the original file looks like this:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
func main() {
  console.log("main")
}

func fooBar() {
  console.log("fooBar")
}

func baz() {
  console.log("baz")
}

func qux() {
  console.log("qux")
}

func quix() {
  console.log("quix")
}

func qwoo() {
  console.log("qwoo")
}

func last() {
  console.log("last")
}
</PlandexBlock>

DO NOT output a code block like this to demonstrate that new code will be inserted somewhere between the 'fooBar' and 'last' functions:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

func fooBar() {
  console.log("fooBar")
}

func newCode() {
  console.log("newCode")
}

func last() {
  console.log("last")
}
</PlandexBlock>

If you want to demonstrate that a new function will be inserted somewhere between the 'fooBar' and 'last' functions, you MUST include "... existing code ..." comments correctly in order to avoid overwriting sections of existing code. Instead, do this to show exactly where the new function will be inserted:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

func baz() {
  // ... existing code ...
}

func newCode() {
  console.log("newCode")
}

func qux() {
  // ... existing code ...
}

// ... existing code ...
</PlandexBlock>

Or this to show that the new function will be inserted *somehwere* between the 'fooBar' and 'last' functions:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

func fooBar() {
  console.log("fooBar")
}

// ... existing code ...

func newCode() {
  console.log("newCode")
}

// ... existing code ...

func last() {
  console.log("last")
}
</PlandexBlock>

Either way, you MUST NOT leave out the "... existing code ..." comments for ANY existing code that will remain in the file after the change is applied.

*

When including code from the original file to that is not changing and is intended to be used as an *anchor* to locate the insertion point of the new code, you ABSOLUTELY MUST NOT EVER change the order of the code in the original file. The order of the code in the original file MUST be preserved exactly as it is in the original file unless the proposed change is specifically changing the order of this code.

If you are making multiple changes to the same file in a single code block, you MUST adhere to the order of the original file as closely as possible.

If the original file is:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
func buck() {
  console.log("buck")
}

func qux() {
  console.log("qux")
}

func fooBar() {
  console.log("fooBar")
}

func baz() {
  console.log("baz")
}

func yup() {
  console.log("yup")
}
</PlandexBlock>

DO NOT output a code block like this to demonstrate that new code will be inserted between the 'fooBar' and 'baz' functions:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

func baz() {
  console.log("baz-updated")
}

// ... existing code ...

func qux() {
  console.log("qux-updated")
}

// ... existing code ...
</PlandexBlock>

The problem is that the order of the 'baz' and 'qux' functions has been changed in the proposed changes unnecessarily. Instead, do this:

- main.js:
<PlandexBlock lang="javascript" path="main.js">
// ... existing code ...

func qux() {
  console.log("qux-updated")
}

// ... existing code ...

func baz() {
  console.log("baz-updated")
}

// ... existing code ...
</PlandexBlock>

Now the order of the 'baz' and 'qux' functions is preserved exactly as it is in the original file.

*

When writing an "... existing code ..." comment, you MUST use the correct comment symbol for the programming language. For example, if you are writing a plan in Python, Ruby, or Bash, you MUST use '# ... existing code ...' instead of '// ... existing code ...'. If you're writing HTML, you MUST use '<!-- ... existing code ... -->'. If you're writing jsx, tsx, svelte, or another language where the correct comment symbol(s) depend on where in the code you are, use the appropriate comment symbol(s) for where that comment is placed in the file. If you're in a javascript block of a jsx file, use '// ... existing code ...'. If you're in a markup block of a jsx file, use '{/* ... existing code ... */}'.

Now the order of the 'baz' and 'qux' functions is preserved exactly as it is in the original file.

*

When writing an "... existing code ..." comment, you MUST use the correct comment symbol for the programming language. For example, if you are writing a plan in Python, Ruby, or Bash, you MUST use '# ... existing code ...' instead of '// ... existing code ...'. If you're writing HTML, you MUST use '<!-- ... existing code ... -->'. If you're writing jsx, tsx, svelte, or another language where the correct comment symbol(s) depend on where in the code you are, use the appropriate comment symbol(s) for where that comment is placed in the file. If you're in a javascript block of a jsx file, use '// ... existing code ...'. If you're in a markup block of a jsx file, use '{/* ... existing code ... */}'.
`

const UpdateFormatAdditionalExamples = `
Here are some important examples of INCORRECT vs CORRECT file updates:

Example 1 - Adding a new route:

❌ INCORRECT - Replacing instead of inserting:
- src/main.go:
<PlandexBlock lang="go" path="src/main.go">
// ... existing code ...

r.HandleFunc(prefix+"/api/users", handlers.ListUsersHandler).Methods("GET")

r.HandleFunc(prefix+"/api/config", handlers.GetConfigHandler).Methods("GET")

// ... existing code ...
</PlandexBlock>
This is wrong because it doesn't show enough context to know what surrounding routes were preserved.

✅ CORRECT - Proper insertion with context:
- src/main.go:
<PlandexBlock lang="go" path="src/main.go">
// ... existing code ...

r.HandleFunc(prefix+"/api/users", handlers.ListUsersHandler).Methods("GET")
r.HandleFunc(prefix+"/api/teams", handlers.ListTeamsHandler).Methods("GET")

r.HandleFunc(prefix+"/api/config", handlers.GetConfigHandler).Methods("GET")

r.HandleFunc(prefix+"/api/settings", handlers.GetSettingsHandler).Methods("GET")
r.HandleFunc(prefix+"/api/status", handlers.GetStatusHandler).Methods("GET")

// ... existing code ...
</PlandexBlock>

Example 2 - Adding a method to a class:

❌ INCORRECT - Ambiguous insertion:
- src/main.go:
<PlandexBlock lang="go" path="src/main.go">
class UserService {
  // ... existing code ...
  
  async createUser(data) {
    // new method
  }
  
  // ... existing code ...
}
</PlandexBlock>
This is wrong because it doesn't show where exactly the new method should go.

✅ CORRECT - Clear insertion point:
- src/main.go:
<PlandexBlock lang="go" path="src/main.go">
class UserService {
  // ... existing code ...
  
  async getUser(id) {
    return await this.db.users.findOne(id)
  }
  
  async createUser(data) {
    return await this.db.users.create(data)
  }
  
  async updateUser(id, data) {
    return await this.db.users.update(id, data)
  }
  
  // ... existing code ...
}
</PlandexBlock>

Example 3 - Adding a configuration section:

❌ INCORRECT - Lost context:
- src/config.json:
<PlandexBlock lang="json" path="src/config.json">
{
  "database": {
    "host": "localhost",
    "port": 5432
  },
  "newFeature": {
    "enabled": true,
    "timeout": 30
  }
}
</PlandexBlock>
This is wrong because it dropped existing configuration sections.

✅ CORRECT - Preserved context:
- src/config.json:
<PlandexBlock lang="json" path="src/config.json">
{
  // ... existing code ...
  
  "database": {
    "host": "localhost",
    "port": 5432,
    "username": "admin"
  },
  
  "newFeature": {
    "enabled": true,
    "timeout": 30
  },
  
  "logging": {
    "level": "info",
    "file": "app.log"
  }
  
  // ... existing code ...
}
</PlandexBlock>

Key principles demonstrated in these examples:
1. Always show the surrounding context that will be preserved
2. Make insertion points unambiguous by showing adjacent code
3. Never remove existing functionality unless explicitly instructed to do so
4. Use "... existing code ..." comments properly to indicate preserved sections
5. Show enough context to understand the code structure
`


================================================
FILE: app/server/model/prompts/user_prompt.go
================================================
package prompts

import (
	"fmt"
	shared "plandex-shared"
	"time"
)

const SharedPromptWrapperFormatStr = "# The user's latest prompt:\n```\n%s\n```\n\n" + `Please respond according to the 'Your instructions' section above.

Do not ask the user to do anything that you can do yourself. Do not say a task is too large or complex for you to complete--do your best to break down the task and complete it even if it's very large or complex.

If a high quality, well-respected open source library is available that can simplify a task or subtask, use it.

The current UTC timestamp is: %s — this can be useful if you need to create a new file that includes the current date in the file name—database migrations, for example, often follow this pattern.

Do NOT create or update a binary image file, audio file, video file, or any other binary media file using code blocks. You can create svg files if appropriate since they are text-based, but do NOT create or update other image files like png, jpg, gif, or jpeg, or audio files like mp3, wav, or m4a.

User's operating system details:
%s

---
%s
---
`

func GetContextLoadingPromptWrapperFormatStr(params CreatePromptParams) string {
	s := SharedPromptWrapperFormatStr + `
	` + GetArchitectContextSummary(params.ContextTokenLimit)

	return s
}

func GetPlanningPromptWrapperFormatStr(params CreatePromptParams) string {
	s := SharedPromptWrapperFormatStr + `

` + GetPlanningFlowControl(params) + `

Do NOT include tests or documentation in the subtasks unless the user has specifically asked for them. Do not include extra code or features beyond what the user has asked for. Focus on the user's request and implement only what is necessary to fulfill it.

` + ReviseSubtasksPrompt + `

` + CombineSubtasksPrompt + `

At the end of the '### Tasks' section, you ABSOLUTELY MUST ALWAYS include a <PlandexFinish/> tag, then end the response.

Example:
`

	if params.ExecMode {
		s += `
### Commands

The _apply.sh script is empty. I'll create it with commands to compile the project and run the new test with cargo.
`
	}

	s += `
### Tasks

1. Create a new file called 'src/main.rs' with a 'main' function that returns 'Hello, world!'
Uses: ` + "`src/main.rs`" + `

2. Write a basic test for the 'main' function
Uses: ` + "`src/main.rs`"

	if params.ExecMode {
		s += `
3. 🚀 Run the new test with cargo
Uses: ` + "`_apply.sh`" + `
	`
	}

	s += `
<PlandexFinish/>

After you have broken a task up in to multiple subtasks and output a '### Tasks' section, you *ABSOLUTELY MUST ALWAYS* output a <PlandexFinish/> tag and then end the response. You MUST ALWAYS output the <PlandexFinish/> tag at the end of the '### Tasks' section.

Output a <PlandexFinish/> tag after the '### Tasks' section. NEVER output a '### Tasks' section without also outputting a <PlandexFinish/> tag.

Use your judgment on the paths of new files you create. Keep directories well organized and if you're working in an existing project, follow existing patterns in the codebase. ALWAYS use *complete* *relative* paths for new files.

Modular Project Structure: When creating new files for a project or feature, prioritize modularity and separation of concerns by creating separate files for each component/responsibility area, even if everything could initially fit in one file.

Ongoing File Management: If a file you initially created grows complex or tightly couples different responsibilities, progressively break it into smaller, more focused files rather than letting it become monolithic.

Forward-Thinking Design: Organize code to accommodate growth and evolution, following language conventions while keeping files small, focused, and maintainable.

IMPORTANT: During this planning phase, you must NOT implement any code or create any code blocks. Your ONLY JOB is to break down the work into subtasks. Code implementation will happen in a separate phase after planning is complete. The planning phase is ONLY for breaking the work into subtasks.

Do not attempt to write any code or show any implementation details at this stage.

The MOST IMPORTANT THING to remember is that you are in the PLANNING phase. Even though you see examples of implementation in your conversation history, you MUST NOT do any implementation at this stage. Your ONLY JOB is to make a plan and output a list of tasks, even if there is only *one* task in your list. That is your ONLY JOB at this stage. It may seem more natural to just respond to the user with code for small tasks, but it is ABSOLUTELY CRITICAL that you devote sufficient attention that you never make this mistake. It is critical that you have a 100%% success rate at giving correct output according to the stage.
`

	if params.IsUserDebug {
		s += UserPlanningDebugPrompt
	} else if params.IsApplyDebug {
		s += ApplyPlanningDebugPrompt
	} else if !params.ExecMode {
		s += NoApplyScriptPlanningPrompt
	}

	return s
}

func GetImplementationPromptWrapperFormatStr(params CreatePromptParams) string {
	s := SharedPromptWrapperFormatStr + `

If you're making a plan, remember to label code blocks with the file path *exactly* as described in point 2, and do not use any other formatting for file paths. **Do not include explanations or any other text apart from the file path in code block labels.**

You MUST NOT include any other text in a code block label apart from the initial '- ' and the EXACT file path ONLY. DO NOT UNDER ANY CIRCUMSTANCES use a label like 'File path: src/main.rs' or 'src/main.rs: (Create this file)' or 'File to Create: src/main.rs' or 'File to Update: src/main.rs'. Instead use EXACTLY 'src/main.rs:'. DO NOT include any explanatory text in the code block label like 'src/main.rs: (Add a new function)'. It is EXTREMELY IMPORTANT that the code block label includes *only* the initial '- ', the file path, and NO OTHER TEXT whatsoever. If additional text apart from the initial '- ' and the exact file path is included in the code block label, the plan will not be parsed properly and you will have failed at the task of generating a usable plan. 

Always use an opening <PlandexBlock> tag to start a code block and a closing </PlandexBlock> tag to end a code block.

The <PlandexBlock> tag content MUST ONLY contain the code for the code block and NOTHING ELSE. Do NOT wrap the code block in triple backticks, CDATA tags, or any other text or formatting. Output ONLY the code and nothing else within the <PlandexBlock> tag.

The <PlandexBlock> tag MUST ALWAYS include both a 'lang' attribute and a 'path' attribute as described in the instructions above. It must not include any other attributes.

When *updating an existing file*, you MUST follow the instructions you've been given on how to update code in code blocks:

	- Do NOT include large sections of the file that are not changing. Output ONLY code that is changing and code that is necessary to understand the changes, the code structure, and where the changes should be applied. Use references comments for sections of the file that are not changing. ONLY use exactly '... existing code ...' (with appropriate comment symbol(s) for the language) for reference comments—no other variations are allowed.

	- Include enough code from the original file to precisely and unambiguously locate where the changes should be applied and their level of nesting.

	- Match the indentation of the original file exactly.

	- Do NOT include line numbers in the <PlandexBlock> tag. While line numbers are included in the original file in context (prefixed with 'pdx-', like 'pdx-10: ') in context to assist you with describing the location of changes in the 'Action Explanation', they ABSOLUTELY MUST NOT be included in the <PlandexBlock> tag.

	- Do NOT output multiple references with no changes in between them.

	- Do NOT add superfluous newlines around reference comments.

	- Use a removal comment to denote code that is being removed from a file. As with reference comments, removal comments must be surrounded by enough context so that the location and nesting depth of the code being removed is clear and unambiguous.

	- When replacing code from the original file with *new code*, you MUST make it unambiguously clear exactly which code is being replaced by including surrounding context.

	- Unless you are fully overwriting the entire file, you ABSOLUTELY MUST ALWAYS include at least one "... existing code ..." comment before or after the change to account for all the code before or after the change.

	- Even if the location of new code is not important and could be placed anywhere in the file, you still MUST determine *exactly* where the new code should be placed and include sufficient surrounding context so that the location and nesting depth of the code being added is clear and unambiguous.

	- Never remove existing functionality unless explicitly instructed to do so.

	- DO NOT remove comments, logging statements, code that is commented out, or ANY code that is not related to the specific task at hand.

	- Do NOT escape newlines within the <PlandexBlock> tag unless there is a specific reason to do so, like you are outputting newlines in a quoted JSON string. For normal code, do NOT escape newlines.
	
	- Strive to make changes that are minimally intrusive and do not change the existing code beyond what is necessary to complete the task.

	- Show enough surrounding context to understand the code structure.

	- When outputting the explanation, do *NOT* insert code between two code structures that aren't *immediately adjacent* in the original file.

  -	Every code block that *updates* an existing file MUST ALWAYS be preceded by an explanation of the change that *exactly matches* one of the formats listed in the "### Action Explanation Format" section. Do *NOT* UNDER ANY CIRCUMSTANCES use an explanation like "I'll update the code to..." that does not match one of these formats.

	- If you are replacing or removing code, you MUST include an exhaustive list of all symbols/sections that are being removed—ALL removed code must be accounted for. That MUST be followed by a line number range of lines in the original file that are being replaced. Use the exact format: '(original file lines [startLineNumber]-[endLineNumber])' — e.g. '(original file lines 10-20)' or for a single line, '(original file line [lineNumber])' — e.g. '(original file line 10)'

	- CRITICAL: When writing the Context field in an Action Explanation:
		- The symbols/structures mentioned MUST be code that is NOT being changed
		- These symbols serve as ANCHORS to precisely locate where the change should be applied
		- Every symbol/structure mentioned in the Context MUST appear in the code block
		- These anchors MUST be immediately adjacent to where the change occurs
		- Do NOT use distant symbols with other code between them and the change
		- All symbols must be surrounded with backticks
		- The code block MUST include these anchors to unambiguously locate the change
		- If you mention "Located between ` + "`functionA`" + "` and `" + "`functionB`" + `, both functions MUST appear in your code block

		FAILURE TO INCLUDE THE CONTEXT SYMBOLS IN THE CODE BLOCK MAKES CHANGES IMPOSSIBLE TO APPLY CORRECTLY AND IS A CRITICAL ERROR.

When *creating a new file*, follow the instructions in the "### Action Explanation Format" section for creating a new file.
 
  - The Type field MUST be exactly 'new file'.
  - The Summary field MUST briefly describe the new file and its purpose.
	- The file path MUST be included in the code block label.
	- The code itself MUST be written within a <PlandexBlock> tag.
	- The <PlandexBlock> tag MUST include both a 'lang' attribute and a 'path' attribute as described in the instructions above. It must not include any other attributes.
	- The <PlandexBlock> tag MUST NOT include any other text or formatting. It must only contain the code for the code block and NOTHING ELSE. Do NOT wrap the code block in triple backticks, CDATA tags, or any other text or formatting. Output ONLY the code and nothing else within the <PlandexBlock> tag.
	- The code block MUST include the *entire file* to be created. Do not omit any code from the file.
	- Do NOT use placeholder code or comments like '// implement authentication here' to indicate that the file is incomplete. Implement *all* functionality.
	- Do NOT use reference comments ('// ... existing code ...'). Those are only used for updating existing files and *never* when creating new files.
	- Include the *entire file* in the code block.


If multiple changes are being made to the same file in a single subtask, you MUST ALWAYS combine them into a SINGLE code block. Do NOT use multiple code blocks for multiple changes to the same file. Instead:

	- Include all changes in a single code block that follows the file's structure
	- Use "... existing code ..." comments between changes
	- Show enough context around each change for unambiguous location
	- Maintain the original file's order of elements
	- Only reproduce parts of the file necessary to show structure and locate changes
	- Make all changes in a single pass from top to bottom of the file

	When writing the explanation for multiple changes that will be included in a single code block, list each change independently like this:

	**Updating  + "server/handlers/auth.go" + **
	Change 1. 
		Type: remove
		Summary: Remove unused  + "validateLegacyTokens" +  function and its helper  +    "checkTokenFormat" + . Removes  + "validateLegacyTokens and checkTokenFormat" +  functions (original file lines 25-85).
		Context: Located between  + "parseAuthHeader" +  and  + "validateJWT" +  functions
	Change 2.
		Type: append
		Summary: Append just-removed + "checkTokenFormat" + function to the end of the file"	


Only list out subtasks once for the plan--after that, do not list or describe a subtask that can be implemented in code without including a code block that implements the subtask.

Do not implement a task partially and then give up even if it's very large or complex--do your best to implement each task and subtask **fully**.

Do NOT repeat any part of your previous response. Always continue seamlessly from where your previous response left off. 

ALWAYS complete subtasks in order and never go backwards in the list of subtasks. Never skip a subtask or work on subtasks out of order. Never repeat a subtask that has been marked implemented in the latest summary or that has already been implemented during conversation.

` + CurrentSubtaskPrompt + `

` + MarkSubtaskDonePrompt + `

` + FileOpsImplementationPromptSummary

	file := ".gitignore"
	if !params.IsGitRepo {
		file = ".plandexignore"
	}

	s += fmt.Sprintf(`
- Create or update the %s file if necessary.
- If you write commands to _apply.sh, consider if output should be added to %s.
`, file, file)

	s += `
## Is the task done or in progress?

Remember, you must follow these instructions on marking tasks as done or in progress:

- When a subtask is *completed*, you *must* either: 

1. Mark it as 'done' in the format described in the 'Marking Tasks as Done Or In Progress' section.
2. Mark it as 'in progress' by explaining that the task is not yet complete and will be continued in the next response.

Remember, you must WAIT until the subtask is *fully implemented* before marking it as done. If a subtask is large, this may require multiple responses. If you have only implemented part of a subtask, do NOT mark it as done. It will be continued in one or more subsequent responses, and the last one of those reponses will mark the subtask as done. If you mark the subtask done prematurely, you will stop it from being fully implemented, which will prevent the plan from being implemented correctly.

## The Most Critical Factor

Remember, the MOST critical factor in creating code blocks correctly is to locate them unambiguously in the file using the definitions that are immediately before and immediately after the the section of code that is being changed or extended. Pay special attention to the 'Context' field in the Action Explanation. ALWAYS include at least a few additional lines of code before and after the section that is changing. And even if you need to include many lines to reach the *definitions* that are immediately before and after the section that is changing, do so.

Definitions in the original file that are outside of the section that is changing are like "hooks" that determine where in the resulting file the new code you write will be placed.

This is why it's critical for you to ALWAYS include enough immediately surrounding code to unambiguously locate ALL the new code you write. All the blocks of new code you write must hook in correctly using the hooks you supply from the original file when you include additional lines of code from the original file before and after the section that is changing.

Even though you should include the definitions before and after the section, don't reproduce large sections of the original file. Use '... existing code ...' reference comments to 'collapse' large sections of the original file that are not changing.

It's not easy to be 100% consistent in writing code blocks that follow these rules, but you are capable of doing it with sufficient attention.

This disambiguation technique is the *most important* part of correctly implementing a plan.
`

	return s
}

type UserPromptParams struct {
	CreatePromptParams
	Prompt                     string
	OsDetails                  string
	CurrentStage               shared.CurrentStage
	UnfinishedSubtaskReasoning string
}

func GetWrappedPrompt(params UserPromptParams) string {
	currentStage := params.CurrentStage

	prompt := params.Prompt
	osDetails := params.OsDetails

	var promptWrapperFormatStr string
	if currentStage.TellStage == shared.TellStagePlanning {
		if currentStage.PlanningPhase == shared.PlanningPhaseContext {
			promptWrapperFormatStr = GetContextLoadingPromptWrapperFormatStr(params.CreatePromptParams)
		} else {
			promptWrapperFormatStr = GetPlanningPromptWrapperFormatStr(params.CreatePromptParams)
		}
	} else {
		promptWrapperFormatStr = GetImplementationPromptWrapperFormatStr(params.CreatePromptParams)
	}

	// If we're in the context loading stage, we don't need to include the apply script summary
	var applyScriptSummary string
	if currentStage.TellStage == shared.TellStagePlanning && currentStage.PlanningPhase == shared.PlanningPhaseTasks {
		applyScriptSummary = ApplyScriptPlanningPromptSummary
	} else if currentStage.TellStage == shared.TellStageImplementation {
		applyScriptSummary = ApplyScriptImplementationPromptSummary
	}

	ts := time.Now().Format(time.RFC3339)

	s := "The current stage is: "
	if currentStage.TellStage == shared.TellStagePlanning {
		if currentStage.PlanningPhase == shared.PlanningPhaseContext {
			s += "CONTEXT"
		} else {
			s += "PLANNING"
		}
	} else if currentStage.TellStage == shared.TellStageImplementation {
		s += "IMPLEMENTATION"
	}
	s += "\n\n"
	s += fmt.Sprintf(promptWrapperFormatStr, prompt, ts, osDetails, applyScriptSummary)

	if currentStage.TellStage == shared.TellStageImplementation && params.UnfinishedSubtaskReasoning != "" {
		s += "\n\n" + `
The current task was not completed in the previous response and remains unfinished. Here is the reasoning for why it was not completed:

` + params.UnfinishedSubtaskReasoning + `

You MUST address these issues in the next response and ensure the task is fully completed. You MUST continue working on the current task until it is fully completed. Do NOT work on any other tasks. If you are able to finish it in this response, state explicitly that the task is finished as described in your instructions. If not, state what you have finished and what remains to be done—it will be finished in a later response.
		`

	}

	return s
}

const UserContinuePrompt = "Continue the plan according to your instructions for the current stage. Don't repeat any part of your previous response."

const AutoContinuePlanningPrompt = UserContinuePrompt

const AutoContinueImplementationPrompt = `Continue the plan from where you left off in the previous response. Don't repeat any part of your previous response. 

Continue seamlessly from where your previous response left off. 

Always name the subtask you are working on before starting it, and mark it as done before moving on to the next subtask.

` + CurrentSubtaskPrompt + `

` + MarkSubtaskDonePrompt + `

ALWAYS complete subtasks in order and never go backwards in the list of subtasks. Never skip a subtask or work on subtasks out of order. Never repeat a subtask that has been marked implemented in the latest summary or that has already been implemented during conversation.

If you break up a task into subtasks, only include subtasks that can be implemented directly in code by creating or updating files. Only include subtasks that require executing code or commands if execution mode is enabled. Do not include subtasks that require user testing, deployment, or other tasks that go beyond coding. 

Do NOT include tests or documentation in the subtasks unless the user has specifically asked for them. Do not include extra code or features beyond what the user has asked for. Focus on the user's request and implement only what is necessary to fulfill it.`

const SkippedPathsPrompt = "\n\nSome files have been skipped by the user and *must not* be generated. The user will handle any updates to these files themselves. Skip any parts of the plan that require generating these files. You *must not* generate a file block for any of these files.\nSkipped files:\n"

const CombineSubtasksPrompt = `
- Combine multiple steps into a single larger subtask where all of the steps are small enough to be completed in a single response (especially do this if multiple steps are closely related). Try to both size each subtask so that it can be completed in a single response, while also aiming to minimize the total number of subtasks. For subtasks involving multiple steps and/or multiple files, use bullet points to break them up into smaller sub-subtasks.

- When using bullet points to break up a subtask into multiple steps, make a note of any files that will be created or updated by each step—surround file paths with backticks like this: "` + "`path/to/some_file.txt`" + `". All paths mentioned in the bullet points of the subtask must be included in the 'Uses: ' list for the subtask.

- Do NOT break up file operations of the same type (e.g. moving files, removing files, resetting pending changes) into multiple subtasks. Group them all into a *single* subtask.

- Keep subtasks focused and manageable. While it's fine to group closely related changes (like small updates to a few tightly coupled files) into a single subtask, prefer breaking work into smaller, more focused subtasks when the changes are more substantial or independent. If a subtask involves many files or multiple distinct changes, consider whether it would be clearer and more maintainable to break it into multiple subtasks.

Here are examples of good and poor task division:

Example 1 - Poor (tasks too small and fragmented):
1. Create the product.js file
Uses: ` + "`src/models/product.js`" + `

2. Add the product schema
Uses: ` + "`src/models/product.js`" + `

3. Add the validate() method
Uses: ` + "`src/models/product.js`" + `

4. Add the save() method
Uses: ` + "`src/models/product.js`" + `

Better:
1. Create product model with core functionality
- Create product.js with schema definition
- Add validate() and save() methods
Uses: ` + "`src/models/product.js`" + `

Example 2 - Poor (task too large with unrelated changes):
1. Implement user profile features
- Add user avatar upload
- Add profile settings page
- Implement friend requests
- Add user search
- Create notification system
Uses: ` + "`src/components/Profile.tsx`" + `, ` + "`src/components/Avatar.tsx`" + `, ` + "`src/components/Settings.tsx`" + `, ` + "`src/services/friends.ts`" + `, ` + "`src/services/search.ts`" + `, ` + "`src/services/notifications.ts`" + `

Better:
1. Implement user avatar upload functionality
- Add avatar component with upload UI
- Add avatar upload service
Uses: ` + "`src/components/Avatar.tsx`" + `, ` + "`src/services/avatar.ts`" + `

2. Create profile settings page
- Add settings form components
- Implement save/load settings
Uses: ` + "`src/components/Settings.tsx`" + `, ` + "`src/services/settings.ts`" + `

3. Add friend request system
Uses: ` + "`src/services/friends.ts`" + `, ` + "`src/components/Profile.tsx`" + `

Example 3 - Good (related changes properly grouped):
1. Update error handling in authentication flow
- Add error handling to login function
- Add corresponding error states in auth context
- Update error display in login form
Uses: ` + "`src/auth/login.ts`" + `, ` + "`src/context/auth.tsx`" + `, ` + "`src/components/LoginForm.tsx`" + `

Example 4 - Good (tightly coupled file updates):
1. Rename UserType enum to AccountType
- Update enum definition
- Update all imports and usages
Uses: ` + "`src/types/user.ts`" + `, ` + "`src/auth/account.ts`" + `, ` + "`src/components/UserProfile.tsx`" + `

Notice in these examples:
- Tasks that are too granular waste responses on tiny changes
- Tasks that are too large mix unrelated changes and become hard to implement
- Good tasks group related changes that make sense to implement together
- Multiple files can be included when the changes are tightly coupled
- Bullet points describe steps in a cohesive change, not separate features
`

type ChatUserPromptParams struct {
	CreatePromptParams
	Prompt    string
	OsDetails string
}

func GetWrappedChatOnlyPrompt(params ChatUserPromptParams) string {
	// Base wrapper that's always included
	baseWrapper := "# The user's latest prompt:\n```\n%s\n```\n\n" + `Please respond according to the 'Your instructions' section above.

The current UTC timestamp is: %s

User's operating system details:
%s`

	// Build additional instructions based on parameter combinations
	var additionalInstructions string

	// Execution mode handling
	if params.ExecMode {
		additionalInstructions += `
*Execution mode is enabled.*
- If you switch to tell mode, you can execute commands locally as needed
- While you remain in chat mode, you can discuss both file changes and command execution, but you cannot update files or execute commands (unless the user first switches to tell mode)
- Be specific about what commands would need to be run
- Consider build processes, testing, and deployment
- Distinguish between file changes and execution steps`
	} else {
		additionalInstructions += `
*Execution mode is disabled.*
- If you switch to tell mode, you cannot execute commands—keep this in mind when discussing the plan. If the plan requires commands to be run after switching to tell mode, the user would need to run them manually.
- You can discuss build/test/deploy conceptually, but you cannot execute commands either in chat mode or in tell mode
- Be clear when certain steps would need execution mode enabled`
	}

	additionalInstructions += `
Keep in mind:
- Stay conversational while being technically precise
- Reference and explain code when helpful, but don't output formal implementation blocks
- Focus on what's specifically asked - don't suggest extra features
- Consider existing codebase structure in your explanations
- When discussing libraries, focus on well-maintained, widely-used options
- If the user wants to implement changes, remind them about 'tell mode'
- Use error handling, logging, and security best practices in your suggestions
- Be thoughtful about code organization and structure
- Consider implications of suggested changes on the existing codebase

Remember you're in chat mode:
- Engage in natural technical discussion about code and context
- Help users understand their codebase and plan potential changes
- Provide explanations and answer questions thoroughly
- Include code snippets only when they help explain concepts
- Help debug issues by examining and explaining code
- Suggest approaches and discuss trade-offs
- Help evaluate different implementation strategies
- Consider and explain implications of different approaches
- Stay focused on understanding and planning rather than implementation

You cannot:
- Create or modify any files
- Output formal implementation code blocks
- Make plans using "### Tasks" sections
- Structure responses as if implementing changes
- Load context multiple times in consecutive responses
- Switch to implementation mode without user request

Even if a plan is in progress:
- Stay in discussion mode, don't attempt to implement anything
- You can discuss the current tasks and progress
- You can provide explanations and suggestions
- You can help debug issues or clarify approach
- But you must not output any implementation code
- Return to implementation only when user switches back to tell mode

Remember that users often:
- Switch between chat and tell mode during implementation
- Use chat mode to understand before implementing
- Need detailed technical discussion to plan effectively
- Want to explore options before committing to changes
- May need to debug or understand issues mid-implementation
- You may receive a list of tasks that are in progress, including a 'current subtask'. You MUST NOT implement any tasks—only discuss them.
`

	promptWrapperFormatStr := baseWrapper + additionalInstructions

	ts := time.Now().Format(time.RFC3339)
	return fmt.Sprintf(promptWrapperFormatStr,
		params.Prompt,
		ts,
		params.OsDetails)
}

func GetPlanningFlowControl(params CreatePromptParams) string {
	s := `
CRITICAL PLANNING RULES:
1. For ANY update/revision to tasks:
`

	if params.ExecMode {
		s += `You MUST output a ### Commands section before the ### Tasks list. If you determine that commands should be added or updated in _apply.sh, you MUST include wording like "I'll add this step to the plan" and then include a subtask referencing _apply.sh in the ### Tasks list.`
	}

	s += `
   - You MUST output a new/updated ### Tasks list
	`

	if params.ExecMode {
		s += `
   - If the ### Commands section indicates that commands should be added or updated in _apply.sh, you MUST also create a subtask referencing _apply.sh in the ### Tasks list
	`
	}

	s += `
   - You MUST NOT UNDER ANY CIRCUMSTANCES start implementing code, even if you have already made a plan in a previous response and are ready to implement it—you still ABSOLUTELY MUST NOT implement code at this stage. You MUST make a plan first in the format described above.
   - You MUST follow planning phase format exactly

2. Even for small changes:
   - Create/update task list first
   - No implementation and NO CODE until planning is complete, and you have output a '### Tasks' section and a <PlandexFinish/>
   - All changes must be in task list

3. The planning stage is *ALWAYS* required. You MUST NEVER skip ahead and start writing code in this response. You MUST complete the planning stage first and output a '### Tasks' section and a <PlandexFinish/> before you can start implementing code.
`

	return s
}

// func GetFollowUpRequiredPrompt(params CreatePromptParams) string {
// 	s := `
// [MANDATORY FOLLOW-UP FLOW]

// CRITICAL FLOW CONTROL:
// 1. You MUST FIRST respond naturally to what the user has said/asked
// 2. Then classify the prompt as either:
//    A. Update/revision to tasks (A1/A2/A3)
//    B. Conversation prompt (question/comment)

// 3. IF classified as A (update/revision):
//    - You MUST create/update the task list with ### Tasks
//    - You MUST output <PlandexFinish/> immediately after the task list
//    - You MUST end your response immediately after <PlandexFinish/>
//    - You ABSOLUTELY MUST NOT proceed to implementation
//    - You MUST follow planning format exactly
//    Even if:
//    - The change is small
//    - You know the exact code to write
//    - You're continuing an existing plan

// 4. IF classified as B (conversation):
//    - Continue conversation naturally
//    - Do not create tasks or implement code

// 5. After responding and classifying, output EXACTLY ONE of these statements (naturally incorporated):
//    A. "I have the context I need to continue."
//    B. "I have the context I need to respond."
//    C. "I need more context to continue. <PlandexFinish/>"
//    D. "I need more context to respond. <PlandexFinish/>"
//    E. "This is a significant update to the plan. I'll clear all context without pending changes, then decide what context I need to move forward. <PlandexFinish/>"
//    F. "This is a new task that is distinct from the plan. I'll clear all context without pending changes, then decide what context I need to move forward. <PlandexFinish/>"

// For statements A/B: You may rephrase naturally while keeping the meaning.
// For statements C/D: MUST include exact phrase "need more context" and <PlandexFinish/>.
// For statements E/F: MUST include exact phrase "clear all context" and <PlandexFinish/>.

// CRITICAL: Always respond naturally to the user first, then seamlessly incorporate the required statement. Do NOT state that you are performing a classification or context assessment.
// `

// 	return s
// }


================================================
FILE: app/server/model/summarize.go
================================================
package model

import (
	"context"
	"fmt"
	"net/http"
	"plandex-server/db"
	"plandex-server/model/prompts"
	"plandex-server/types"
	"strings"
	"time"

	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

type PlanSummaryParams struct {
	Auth                        *types.ServerAuth
	Plan                        *db.Plan
	ModelStreamId               string
	ModelPackName               string
	Conversation                []*types.ExtendedChatMessage
	ConversationNumTokens       int
	LatestConvoMessageId        string
	LatestConvoMessageCreatedAt time.Time
	NumMessages                 int
	SessionId                   string
}

func PlanSummary(clients map[string]ClientInfo, authVars map[string]string, settings *shared.PlanSettings, orgUserConfig *shared.OrgUserConfig, config shared.ModelRoleConfig, params PlanSummaryParams, ctx context.Context) (*db.ConvoSummary, *shared.ApiError) {
	messages := []types.ExtendedChatMessage{
		{
			Role: openai.ChatMessageRoleSystem,
			Content: []types.ExtendedChatMessagePart{
				{
					Type: openai.ChatMessagePartTypeText,
					Text: prompts.Identity,
				},
			},
		},
	}

	for _, message := range params.Conversation {
		messages = append(messages, *message)
	}

	messages = append(messages, types.ExtendedChatMessage{
		Role: openai.ChatMessageRoleUser,
		Content: []types.ExtendedChatMessagePart{
			{
				Type: openai.ChatMessagePartTypeText,
				Text: prompts.PlanSummary,
			},
		},
	})

	modelRes, err := ModelRequest(ctx, ModelRequestParams{
		Clients:        clients,
		Auth:           params.Auth,
		AuthVars:       authVars,
		Plan:           params.Plan,
		ModelConfig:    &config,
		Purpose:        "Conversation summary",
		ConvoMessageId: params.LatestConvoMessageId,
		ModelStreamId:  params.ModelStreamId,
		Messages:       messages,
		SessionId:      params.SessionId,
		Settings:       settings,
		OrgUserConfig:  orgUserConfig,
	})

	if err != nil {
		return nil, &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    fmt.Sprintf("error generating plan summary: %v", err),
		}
	}

	summary := modelRes.Content
	if !strings.HasPrefix(summary, "## Summary of the plan so far:") {
		summary = "## Summary of the plan so far:\n\n" + summary
	}

	var tokens int
	if modelRes.Usage != nil {
		tokens = modelRes.Usage.CompletionTokens
	}

	return &db.ConvoSummary{
		OrgId:                       params.Auth.OrgId,
		PlanId:                      params.Plan.Id,
		Summary:                     summary,
		Tokens:                      tokens,
		LatestConvoMessageId:        params.LatestConvoMessageId,
		LatestConvoMessageCreatedAt: params.LatestConvoMessageCreatedAt,
		NumMessages:                 params.NumMessages,
	}, nil

}


================================================
FILE: app/server/model/tokens.go
================================================
package model

import (
	"plandex-server/types"
	shared "plandex-shared"

	"github.com/sashabaranov/go-openai"
)

const (
	// Per OpenAI's documentation:
	// Every message follows this format: {"role": "role_name", "content": "content"}
	// which has a 4-token overhead per message
	TokensPerMessage = 4

	// System, user, or assistant - each role name costs 1 token
	TokensPerName = 1

	// Tokens per request
	TokensPerRequest = 3

	TokensPerExtendedPart = 6
)

func GetMessagesTokenEstimate(messages ...types.ExtendedChatMessage) int {
	tokens := 0

	for _, msg := range messages {
		tokens += TokensPerMessage // Base message overhead
		tokens += TokensPerName    // Role name

		if len(msg.Content) > 0 {
			// For each extended part, we need to account for the JSON structure
			// Each part follows format: {"type": "type_value", "text": "content"}
			// or {"type": "type_value", "image_url": {"url": "url_value"}}
			for _, part := range msg.Content {
				if part.Type == openai.ChatMessagePartTypeText {
					tokens += TokensPerExtendedPart // Overhead for the part object structure
					tokens += shared.GetNumTokensEstimate(part.Text)
				}

				// images are handled separately

			}
		}

	}

	return tokens
}


================================================
FILE: app/server/notify/errors.go
================================================
package notify

import (
	"log"
	"runtime/debug"
)

// this allows Plandex Cloud to inject error monitoring
// all non-streaming handlers are already wrapped with different logic, so this is only needed for errors in streaming handlers

type Severity int

const (
	SeverityInfo Severity = iota
	SeverityError
)

var NotifyErrFn func(severity Severity, data ...interface{})

func RegisterNotifyErrFn(fn func(severity Severity, data ...interface{})) {
	NotifyErrFn = fn
}

func NotifyErr(severity Severity, data ...interface{}) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("panic in NotifyErr: %v\n%s", r, debug.Stack())
		}
	}()

	if NotifyErrFn != nil {
		NotifyErrFn(severity, data...)
	}
}


================================================
FILE: app/server/routes/routes.go
================================================
package routes

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"plandex-server/handlers"
	"plandex-server/hooks"

	"github.com/gorilla/mux"
)

type PlandexHandler func(w http.ResponseWriter, r *http.Request)
type HandlePlandex func(router *mux.Router, path string, isStreaming bool, handler PlandexHandler) *mux.Route

var HandlePlandexFn HandlePlandex

func RegisterHandlePlandex(fn HandlePlandex) {
	HandlePlandexFn = fn
}

func EnsureHandlePlandex() {
	if HandlePlandexFn == nil {
		panic("handlePlandexFn is not set")
	}
}

func AddHealthRoutes(r *mux.Router) {
	EnsureHandlePlandex()

	HandlePlandexFn(r, "/health", false, func(w http.ResponseWriter, r *http.Request) {
		_, apiErr := hooks.ExecHook(hooks.HealthCheck, hooks.HookParams{})
		if apiErr != nil {
			log.Printf("Error in health check hook: %v\n", apiErr)
			http.Error(w, apiErr.Msg, apiErr.Status)
			return
		}
		fmt.Fprint(w, "OK")
	})

	HandlePlandexFn(r, "/version", false, func(w http.ResponseWriter, r *http.Request) {
		// Log the host
		host := r.Host
		log.Printf("Host header: %s", host)

		execPath, err := os.Executable()
		if err != nil {
			log.Fatal("Error getting current directory: ", err)
		}
		currentDir := filepath.Dir(execPath)

		// get version from version.txt
		var path string
		if os.Getenv("IS_CLOUD") != "" {
			path = filepath.Join(currentDir, "..", "version.txt")
		} else {
			path = filepath.Join(currentDir, "version.txt")
		}

		bytes, err := os.ReadFile(path)

		if err != nil {
			http.Error(w, "Error getting version", http.StatusInternalServerError)
			return
		}

		fmt.Fprint(w, string(bytes))
	})
}

func AddApiRoutes(r *mux.Router) {
	addApiRoutes(r, "")
}

func AddApiRoutesWithPrefix(r *mux.Router, prefix string) {
	addApiRoutes(r, prefix)
}

func AddProxyableApiRoutes(r *mux.Router) {
	addProxyableApiRoutes(r, "")
}

func AddProxyableApiRoutesWithPrefix(r *mux.Router, prefix string) {
	addProxyableApiRoutes(r, prefix)
}

func addApiRoutes(r *mux.Router, prefix string) {
	EnsureHandlePlandex()

	HandlePlandexFn(r, prefix+"/accounts/email_verifications", false, handlers.CreateEmailVerificationHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/accounts/email_verifications/check_pin", false, handlers.CheckEmailPinHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/accounts/sign_in_codes", false, handlers.CreateSignInCodeHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/accounts/sign_in", false, handlers.SignInHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/accounts/sign_out", false, handlers.SignOutHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/accounts", false, handlers.CreateAccountHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/orgs/session", false, handlers.GetOrgSessionHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/orgs", false, handlers.ListOrgsHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/orgs", false, handlers.CreateOrgHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/users", false, handlers.ListUsersHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/orgs/users/{userId}", false, handlers.DeleteOrgUserHandler).Methods("DELETE")
	HandlePlandexFn(r, prefix+"/orgs/roles", false, handlers.ListOrgRolesHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/invites", false, handlers.InviteUserHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/invites/pending", false, handlers.ListPendingInvitesHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/invites/accepted", false, handlers.ListAcceptedInvitesHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/invites/all", false, handlers.ListAllInvitesHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/invites/{inviteId}", false, handlers.DeleteInviteHandler).Methods("DELETE")

	HandlePlandexFn(r, prefix+"/projects", false, handlers.CreateProjectHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/projects", false, handlers.ListProjectsHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/projects/{projectId}/set_plan", false, handlers.ProjectSetPlanHandler).Methods("PUT")
	HandlePlandexFn(r, prefix+"/projects/{projectId}/rename", false, handlers.RenameProjectHandler).Methods("PUT")

	HandlePlandexFn(r, prefix+"/projects/{projectId}/plans/current_branches", false, handlers.GetCurrentBranchByPlanIdHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/plans", false, handlers.ListPlansHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/archive", false, handlers.ListArchivedPlansHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/ps", false, handlers.ListPlansRunningHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/projects/{projectId}/plans", false, handlers.CreatePlanHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/projects/{projectId}/plans", false, handlers.DeleteAllPlansHandler).Methods("DELETE")

	HandlePlandexFn(r, prefix+"/plans/{planId}", false, handlers.GetPlanHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}", false, handlers.DeletePlanHandler).Methods("DELETE")

	HandlePlandexFn(r, prefix+"/plans/{planId}/current_plan/{sha}", false, handlers.CurrentPlanHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/current_plan", false, handlers.CurrentPlanHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/apply", false, handlers.ApplyPlanHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/archive", false, handlers.ArchivePlanHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/unarchive", false, handlers.UnarchivePlanHandler).Methods("PATCH")

	HandlePlandexFn(r, prefix+"/plans/{planId}/rename", false, handlers.RenamePlanHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/reject_all", false, handlers.RejectAllChangesHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/reject_file", false, handlers.RejectFileHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/reject_files", false, handlers.RejectFilesHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/diffs", false, handlers.GetPlanDiffsHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/context", false, handlers.ListContextHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/context", false, handlers.LoadContextHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/context/{contextId}/body", false, handlers.GetContextBodyHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/context", false, handlers.UpdateContextHandler).Methods("PUT")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/context", false, handlers.DeleteContextHandler).Methods("DELETE")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/convo", false, handlers.ListConvoHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/rewind", false, handlers.RewindPlanHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/logs", false, handlers.ListLogsHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/plans/{planId}/branches", false, handlers.ListBranchesHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/branches/{branch}", false, handlers.DeleteBranchHandler).Methods("DELETE")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/branches", false, handlers.CreateBranchHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/settings", false, handlers.GetSettingsHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/settings", false, handlers.UpdateSettingsHandler).Methods("PUT")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/status", false, handlers.GetPlanStatusHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/tell", true, handlers.TellPlanHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/build", true, handlers.BuildPlanHandler).Methods("PATCH")

	HandlePlandexFn(r, prefix+"/custom_models", false, handlers.ListCustomModelsHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/custom_models", false, handlers.UpsertCustomModelsHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/custom_models/{modelId}", false, handlers.GetCustomModelHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/custom_providers", false, handlers.ListCustomProvidersHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/custom_providers/{providerId}", false, handlers.GetCustomProviderHandler).Methods("GET")

	HandlePlandexFn(r, prefix+"/model_sets", false, handlers.ListModelPacksHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/model_sets", false, handlers.CreateModelPackHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/model_sets/{setId}", false, handlers.UpdateModelPackHandler).Methods("PUT")
	HandlePlandexFn(r, prefix+"/default_settings", false, handlers.GetDefaultSettingsHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/default_settings", false, handlers.UpdateDefaultSettingsHandler).Methods("PUT")

	HandlePlandexFn(r, prefix+"/file_map", false, handlers.GetFileMapHandler).Methods("POST")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/load_cached_file_map", false, handlers.LoadCachedFileMapHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/plans/{planId}/config", false, handlers.GetPlanConfigHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/plans/{planId}/config", false, handlers.UpdatePlanConfigHandler).Methods("PUT")

	HandlePlandexFn(r, prefix+"/default_plan_config", false, handlers.GetDefaultPlanConfigHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/default_plan_config", false, handlers.UpdateDefaultPlanConfigHandler).Methods("PUT")

	HandlePlandexFn(r, prefix+"/org_user_config", false, handlers.GetOrgUserConfigHandler).Methods("GET")
	HandlePlandexFn(r, prefix+"/org_user_config", false, handlers.UpdateOrgUserConfigHandler).Methods("PUT")
}

func addProxyableApiRoutes(r *mux.Router, prefix string) {
	EnsureHandlePlandex()

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/connect", true, handlers.ConnectPlanHandler).Methods("PATCH")
	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/stop", false, handlers.StopPlanHandler).Methods("DELETE")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/respond_missing_file", false, handlers.RespondMissingFileHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/auto_load_context", false, handlers.AutoLoadContextHandler).Methods("POST")

	HandlePlandexFn(r, prefix+"/plans/{planId}/{branch}/build_status", false, handlers.GetBuildStatusHandler).Methods("GET")
}


================================================
FILE: app/server/setup/setup.go
================================================
package setup

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"plandex-server/db"
	"plandex-server/host"
	"plandex-server/model/plan"
	"plandex-server/notify"
	"plandex-server/shutdown"
	"runtime/debug"
	"syscall"
	"time"
)

func MustLoadIp() {
	err := host.LoadIp()
	if err != nil {
		log.Fatal("Error loading IP: ", err)
	}
}

func MustInitDb() {
	err := db.Connect()
	if err != nil {
		log.Fatal("Error initializing database: ", err)
	}

	err = db.MigrationsUp()
	if err != nil {
		log.Fatal("Error running migrations: ", err)
	}

	err = db.CacheOrgRoleIds()
	if err != nil {
		log.Fatal("Error caching org role ids: ", err)
	}
}

var shutdownHooks []func()

func RegisterShutdownHook(hook func()) {
	shutdownHooks = append(shutdownHooks, hook)
}

func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// Skip logging for monitoring endpoints
		if r.URL.Path == "/health" || r.URL.Path == "/version" {
			next.ServeHTTP(w, r)
			return
		}

		start := time.Now()

		log.Printf("\n\nRequest: %s %s\n\n", r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
		log.Printf("\n\nCompleted: %s %s in %v\n\n", r.Method, r.URL.Path, time.Since(start))
	})
}

func StartServer(handler http.Handler, configureFn func(handler http.Handler) http.Handler, afterStart func()) {
	if os.Getenv("GOENV") == "development" {
		log.Println("In development mode.")
	}

	shutdown.ShutdownCtx, shutdown.ShutdownCancel = context.WithCancel(context.Background())
	defer shutdown.ShutdownCancel()

	// Ensure database connection is closed
	defer func() {
		log.Println("Closing database connection...")
		err := db.Conn.Close()
		if err != nil {
			log.Printf("Error closing database connection: %v", err)
		}
		log.Println("Database connection closed")
	}()

	// Get externalPort from the environment variable or default to 8099
	externalPort := os.Getenv("PORT")
	if externalPort == "" {
		externalPort = "8099"
	}

	// Add logging middleware before the maxBytes middleware
	handler = loggingMiddleware(handler)

	// Apply the maxBytesMiddleware to limit request size to 1 GB
	handler = maxBytesMiddleware(handler, 1000<<20) // 1 GB limit

	if configureFn != nil {
		handler = configureFn(handler)
	}

	server := &http.Server{
		Addr:              ":" + externalPort,
		Handler:           handler,
		MaxHeaderBytes:    1 << 20, // 1 MB
		ReadHeaderTimeout: 5 * time.Second,
	}

	go func() {
		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("Failed to start server: %v", err)
		}
	}()

	log.Println("Started Plandex server on port " + externalPort)

	if afterStart != nil {
		afterStart()
	}

	// Capture SIGTERM and SIGINT signals
	sigTermChan := make(chan os.Signal, 1)

	signal.Notify(sigTermChan, syscall.SIGTERM, syscall.SIGINT)

	sig := <-sigTermChan
	log.Printf("Received signal %v, shutting down gracefully...\n", sig)

	// Create a channel to track completion of active plans
	plansDone := make(chan struct{})

	// Start goroutine to monitor active plans
	go func() {
		defer func() {
			if r := recover(); r != nil {
				log.Printf("panic in waitForActivePlans: %v\n%s", r, debug.Stack())
				go notify.NotifyErr(notify.SeverityError, fmt.Errorf("panic in waitForActivePlans: %v\n%s", r, debug.Stack()))
			}
			close(plansDone)
		}()

		// First wait for active plans to complete or timeout
		log.Println("Waiting for active plans to complete...")
		activePlansCtx, cancel := context.WithTimeout(shutdown.ShutdownCtx, 60*time.Second)
		defer cancel()

		select {
		case <-activePlansCtx.Done():
			if activePlansCtx.Err() == context.DeadlineExceeded {
				log.Println("Timeout waiting for active plans. Forcing shutdown.")
			}
		case <-waitForActivePlans():
			log.Println("All active plans finished.")
		}

		// Then clean up any remaining locks
		log.Println("Cleaning up any remaining locks...")
		if err := db.CleanupActiveLocks(shutdown.ShutdownCtx); err != nil {
			log.Printf("Error cleaning up locks: %v", err)
		}
	}()

	// Wait for plans to finish or timeout
	select {
	case <-shutdown.ShutdownCtx.Done():
		log.Println("Global shutdown timeout reached")
	case <-plansDone:
		log.Println("All cleanup tasks completed")
	}

	// Shutdown the HTTP server
	log.Println("Shutting down http server...")
	httpCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	if err := server.Shutdown(httpCtx); err != nil {
		log.Printf("Http server forced to shutdown: %v", err)
	}

	// Execute shutdown hooks
	log.Println("Executing shutdown hooks...")
	for _, hook := range shutdownHooks {
		hook()
	}

	log.Println("Shutdown complete")
}

func waitForActivePlans() chan struct{} {
	done := make(chan struct{})
	go func() {
		ticker := time.NewTicker(1 * time.Second)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				if plan.NumActivePlans() == 0 {
					close(done)
					return
				}
			}
		}
	}()
	return done
}

func maxBytesMiddleware(next http.Handler, maxBytes int64) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// log the size of the request body
		// log.Printf("Request body size: %d", r.ContentLength)

		r.Body = http.MaxBytesReader(w, r.Body, maxBytes)
		next.ServeHTTP(w, r)
	})
}


================================================
FILE: app/server/shutdown/shutdown.go
================================================
package shutdown

import (
	"context"
)

var ShutdownCtx context.Context
var ShutdownCancel context.CancelFunc


================================================
FILE: app/server/syntax/comments.go
================================================
package syntax

import shared "plandex-shared"

// // FindComments parses the given source code for the language implied by path
// // and returns a slice of all comment strings plus an IsRef field indicating
// // whether the comment is referencing original code (heuristic).
// func FindComments(ctx context.Context, parser *tree_sitter.Parser, source string) ([]Comment, error) {
// 	nodes, err := findCommentNodesForPath(ctx, parser, source)
// 	if err != nil {
// 		return nil, err
// 	}
// 	var comments []Comment
// 	for _, node := range nodes {
// 		start := node.StartByte()
// 		end := node.EndByte()
// 		raw := source[start:end]

// 		comments = append(comments, Comment{
// 			Txt:   raw,
// 			IsRef: isRef(raw), // your existing logic
// 		})
// 	}
// 	return comments, nil
// }

// // StripComments removes all comments from the given source code using the appropriate parser
// func StripComments(ctx context.Context, parser *tree_sitter.Parser, source string) (string, error) {
// 	// Find the comment nodes first:
// 	commentNodes, err := findCommentNodesForPath(ctx, parser, source)
// 	if err != nil {
// 		// If parsing fails, return the source as-is along with an error.
// 		return source, fmt.Errorf("failed to parse the content: %v", err)
// 	}

// 	// If no parser is available or no comments found, just return the source unmodified.
// 	if len(commentNodes) == 0 {
// 		return source, nil
// 	}

// 	// Sort comment nodes in reverse order to remove them from the source safely.
// 	sort.Slice(commentNodes, func(i, j int) bool {
// 		return commentNodes[i].StartByte() > commentNodes[j].StartByte()
// 	})

// 	// Remove comments from the source.
// 	result := []byte(source)
// 	for _, node := range commentNodes {
// 		start := node.StartByte()
// 		end := node.EndByte()
// 		result = append(result[:start], result[end:]...)
// 	}

// 	return string(result), nil
// }

// func findCommentNodesForPath(ctx context.Context, parser *tree_sitter.Parser, source string) ([]*tree_sitter.Node, error) {
// 	if parser == nil {
// 		// If no parser is available for this file type, return empty.
// 		return nil, nil
// 	}

// 	// Use a context with timeout (from your existing parserTimeout).
// 	ctx, cancel := context.WithTimeout(ctx, parserTimeout)
// 	defer cancel()

// 	tree, err := parser.ParseCtx(ctx, nil, []byte(source))
// 	if err != nil {
// 		return nil, err
// 	}
// 	defer tree.Close()

// 	// Gather all comment nodes.
// 	root := tree.RootNode()
// 	commentNodes := findCommentNodes(root)
// 	return commentNodes, nil
// }

// func findCommentNodes(node *tree_sitter.Node) []*tree_sitter.Node {
// 	var commentNodes []*tree_sitter.Node

// 	visitNodes(node, func(n *tree_sitter.Node) {
// 		if n.Type() == "comment" {
// 			commentNodes = append(commentNodes, n)
// 		}
// 	})

// 	return commentNodes
// }

func GetCommentSymbols(lang shared.Language) (string, string) {
	switch lang {
	case shared.LanguageC, shared.LanguageCpp, shared.LanguageCsharp, shared.LanguageJava, shared.LanguageJavascript, shared.LanguageGo, shared.LanguageRust, shared.LanguageSwift, shared.LanguageKotlin, shared.LanguageGroovy, shared.LanguageScala, shared.LanguageTypescript, shared.LanguagePhp:
		return "//", ""
	case shared.LanguageBash, shared.LanguageDockerfile, shared.LanguageElixir, shared.LanguageHcl, shared.LanguagePython, shared.LanguageRuby, shared.LanguageToml, shared.LanguageYaml:
		return "#", ""
	case shared.LanguageLua, shared.LanguageElm:
		return "--", ""
	case shared.LanguageCss:
		return "/*", "*/"
	case shared.LanguageHtml:
		return "<!--", "-->"
	case shared.LanguageOCaml:
		return "(*", "*)"
	case shared.LanguageSvelte, shared.LanguageJsx, shared.LanguageTsx, shared.LanguageJson:
		return "", "" // comments are either not allowed or correct symbols depend on the context
	}

	return "", ""
}


================================================
FILE: app/server/syntax/file_map/cli/.gitignore
================================================
mapper

================================================
FILE: app/server/syntax/file_map/cli/go.mod
================================================
module mapper

go 1.23.3

replace plandex-server => ../../../

replace plandex-shared => ../../../../shared

replace plandex-cli => ../../../../cli

require (
	plandex-cli v0.0.0-00010101000000-000000000000
	plandex-server v0.0.0-00010101000000-000000000000
	plandex-shared v0.0.0-00010101000000-000000000000
)

require (
	github.com/Masterminds/semver v1.5.0 // indirect
	github.com/PuerkitoBio/goquery v1.10.3 // indirect
	github.com/alecthomas/chroma v0.10.0 // indirect
	github.com/alecthomas/chroma/v2 v2.18.0 // indirect
	github.com/andybalholm/cascadia v1.3.3 // indirect
	github.com/atotto/clipboard v0.1.4 // indirect
	github.com/aws/aws-sdk-go v1.55.7 // indirect
	github.com/aws/aws-sdk-go-v2 v1.36.5 // indirect
	github.com/aws/aws-sdk-go-v2/config v1.29.17 // indirect
	github.com/aws/aws-sdk-go-v2/credentials v1.17.70 // indirect
	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 // indirect
	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 // indirect
	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 // indirect
	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect
	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 // indirect
	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 // indirect
	github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 // indirect
	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 // indirect
	github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 // indirect
	github.com/aws/smithy-go v1.22.4 // indirect
	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
	github.com/aymerick/douceur v0.2.0 // indirect
	github.com/briandowns/spinner v1.23.2 // indirect
	github.com/calmh/randomart v1.1.0 // indirect
	github.com/charmbracelet/bubbles v0.21.0 // indirect
	github.com/charmbracelet/bubbletea v1.3.5 // indirect
	github.com/charmbracelet/charm v0.8.7 // indirect
	github.com/charmbracelet/colorprofile v0.3.1 // indirect
	github.com/charmbracelet/glamour v0.10.0 // indirect
	github.com/charmbracelet/glow v1.5.1 // indirect
	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
	github.com/charmbracelet/x/ansi v0.9.3 // indirect
	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
	github.com/charmbracelet/x/exp/slice v0.0.0-20250623112707-45752038d08d // indirect
	github.com/charmbracelet/x/term v0.2.1 // indirect
	github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8 // indirect
	github.com/chromedp/chromedp v0.13.3 // indirect
	github.com/chromedp/sysutil v1.1.0 // indirect
	github.com/coreos/go-systemd/v22 v22.5.0 // indirect
	github.com/cqroot/multichoose v0.1.1 // indirect
	github.com/cqroot/prompt v0.9.4 // indirect
	github.com/davecgh/go-spew v1.1.1 // indirect
	github.com/dgrijalva/jwt-go v3.2.0+incompatible // indirect
	github.com/dlclark/regexp2 v1.11.5 // indirect
	github.com/dustin/go-humanize v1.0.1 // indirect
	github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203 // indirect
	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
	github.com/fatih/color v1.18.0 // indirect
	github.com/fsnotify/fsnotify v1.6.0 // indirect
	github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4 // indirect
	github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535 // indirect
	github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4 // indirect
	github.com/gobwas/httphead v0.1.0 // indirect
	github.com/gobwas/pool v0.2.1 // indirect
	github.com/gobwas/ws v1.4.0 // indirect
	github.com/godbus/dbus/v5 v5.1.0 // indirect
	github.com/golang-migrate/migrate/v4 v4.18.3 // indirect
	github.com/google/go-cmp v0.7.0 // indirect
	github.com/google/uuid v1.6.0 // indirect
	github.com/gorilla/css v1.0.1 // indirect
	github.com/gorilla/mux v1.8.1 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/hashicorp/hcl v1.0.0 // indirect
	github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf // indirect
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/jinzhu/copier v0.4.0 // indirect
	github.com/jmespath/go-jmespath v0.4.0 // indirect
	github.com/jmoiron/sqlx v1.4.0 // indirect
	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
	github.com/lib/pq v1.10.9 // indirect
	github.com/lithammer/fuzzysearch v1.1.8 // indirect
	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
	github.com/magiconair/properties v1.8.6 // indirect
	github.com/mattn/go-colorable v0.1.14 // indirect
	github.com/mattn/go-isatty v0.0.20 // indirect
	github.com/mattn/go-localereader v0.0.1 // indirect
	github.com/mattn/go-runewidth v0.0.16 // indirect
	github.com/mattn/go-tty v0.0.3 // indirect
	github.com/meowgorithm/babyenv v1.3.1 // indirect
	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
	github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a // indirect
	github.com/mitchellh/go-homedir v1.1.0 // indirect
	github.com/mitchellh/mapstructure v1.5.0 // indirect
	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
	github.com/muesli/cancelreader v0.2.2 // indirect
	github.com/muesli/gitcha v0.2.0 // indirect
	github.com/muesli/go-app-paths v0.2.2 // indirect
	github.com/muesli/reflow v0.3.0 // indirect
	github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a // indirect
	github.com/muesli/termenv v0.16.0 // indirect
	github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d // indirect
	github.com/olekukonko/errors v1.1.0 // indirect
	github.com/olekukonko/ll v0.0.9 // indirect
	github.com/olekukonko/tablewriter v0.0.5 // indirect
	github.com/pelletier/go-toml v1.9.5 // indirect
	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
	github.com/pkg/errors v0.9.1 // indirect
	github.com/pkg/term v1.2.0-beta.2 // indirect
	github.com/pkoukk/tiktoken-go v0.1.7 // indirect
	github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c // indirect
	github.com/plandex-ai/survey/v2 v2.3.7 // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect
	github.com/sahilm/fuzzy v0.1.1 // indirect
	github.com/sashabaranov/go-openai v1.40.3 // indirect
	github.com/segmentio/ksuid v1.0.4 // indirect
	github.com/shopspring/decimal v1.4.0 // indirect
	github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82 // indirect
	github.com/spf13/afero v1.9.2 // indirect
	github.com/spf13/cast v1.5.0 // indirect
	github.com/spf13/cobra v1.8.0 // indirect
	github.com/spf13/jwalterweatherman v1.1.0 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	github.com/spf13/viper v1.14.0 // indirect
	github.com/subosito/gotenv v1.4.1 // indirect
	github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af // indirect
	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
	github.com/xlab/treeprint v1.2.0 // indirect
	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
	github.com/yuin/goldmark v1.7.12 // indirect
	github.com/yuin/goldmark-emoji v1.0.6 // indirect
	go.uber.org/atomic v1.11.0 // indirect
	golang.org/x/crypto v0.39.0 // indirect
	golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f // indirect
	golang.org/x/image v0.28.0 // indirect
	golang.org/x/mod v0.25.0 // indirect
	golang.org/x/net v0.41.0 // indirect
	golang.org/x/sync v0.15.0 // indirect
	golang.org/x/sys v0.33.0 // indirect
	golang.org/x/term v0.32.0 // indirect
	golang.org/x/text v0.26.0 // indirect
	gopkg.in/ini.v1 v1.67.0 // indirect
	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
	gopkg.in/yaml.v2 v2.4.0 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
)


================================================
FILE: app/server/syntax/file_map/cli/go.sum
================================================
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY=
cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM=
cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY=
cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A=
cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc=
cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU=
cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA=
cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw=
cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY=
cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI=
cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4=
cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4=
cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0=
cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ=
cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk=
cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o=
cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s=
cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0=
cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY=
cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw=
cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI=
cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0=
cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8=
cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA=
cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY=
cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s=
cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM=
cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI=
cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY=
cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI=
cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow=
cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM=
cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M=
cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s=
cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU=
cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U=
cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU=
cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU=
cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU=
cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU=
cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM=
cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I=
cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4=
cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0=
cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs=
cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc=
cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM=
cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ=
cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo=
cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE=
cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I=
cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ=
cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo=
cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA=
cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo=
cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ=
cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4=
cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0=
cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8=
cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU=
cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU=
cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y=
cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg=
cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk=
cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w=
cloud.google.com/go/firestore v1.8.0/go.mod h1:r3KB8cAdRIe8znzoPWLw8S6gpDVd9treohhn8b09424=
cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk=
cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg=
cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM=
cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA=
cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o=
cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A=
cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0=
cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0=
cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc=
cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY=
cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic=
cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI=
cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8=
cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08=
cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4=
cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w=
cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE=
cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM=
cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY=
cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s=
cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA=
cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o=
cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ=
cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU=
cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY=
cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34=
cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs=
cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg=
cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E=
cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU=
cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0=
cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA=
cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0=
cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI=
cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4=
cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o=
cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk=
cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo=
cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg=
cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4=
cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg=
cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c=
cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y=
cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A=
cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4=
cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY=
cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s=
cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI=
cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA=
cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4=
cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0=
cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU=
cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU=
cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc=
cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs=
cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg=
cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM=
cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ=
cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc=
cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw=
cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g=
cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU=
cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4=
cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0=
cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo=
cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo=
cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE=
cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg=
cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0=
cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
github.com/PuerkitoBio/goquery v1.10.3 h1:pFYcNSqHxBD06Fpj/KsbStFRsgRATgnf3LeXiUkhzPo=
github.com/PuerkitoBio/goquery v1.10.3/go.mod h1:tMUX0zDMHXYlAQk6p35XxQMqMweEKB7iK7iLNd4RH4Y=
github.com/alecthomas/chroma v0.10.0 h1:7XDcGkCQopCNKjZHfYrNLraA+M7e0fMiJ/Mfikbfjek=
github.com/alecthomas/chroma v0.10.0/go.mod h1:jtJATyUxlIORhUOFNA9NZDWGAQ8wpxQQqNSB4rjA/1s=
github.com/alecthomas/chroma/v2 v2.18.0 h1:6h53Q4hW83SuF+jcsp7CVhLsMozzvQvO8HBbKQW+gn4=
github.com/alecthomas/chroma/v2 v2.18.0/go.mod h1:RVX6AvYm4VfYe/zsk7mjHueLDZor3aWCNE14TFlepBk=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc=
github.com/armon/go-metrics v0.4.0/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4=
github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/atotto/clipboard v0.1.2/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
github.com/aws/aws-sdk-go v1.55.7 h1:UJrkFq7es5CShfBwlWAC8DA077vp8PyVbQd3lqLiztE=
github.com/aws/aws-sdk-go v1.55.7/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
github.com/aws/aws-sdk-go-v2 v1.36.3 h1:mJoei2CxPutQVxaATCzDUjcZEjVRdpsiiXi2o38yqWM=
github.com/aws/aws-sdk-go-v2 v1.36.3/go.mod h1:LLXuLpgzEbD766Z5ECcRmi8AzSwfZItDtmABVkRLGzg=
github.com/aws/aws-sdk-go-v2 v1.36.5 h1:0OF9RiEMEdDdZEMqF9MRjevyxAQcf6gY+E7vwBILFj0=
github.com/aws/aws-sdk-go-v2 v1.36.5/go.mod h1:EYrzvCCN9CMUTa5+6lf6MM4tq3Zjp8UhSGR/cBsjai0=
github.com/aws/aws-sdk-go-v2/config v1.29.14 h1:f+eEi/2cKCg9pqKBoAIwRGzVb70MRKqWX4dg1BDcSJM=
github.com/aws/aws-sdk-go-v2/config v1.29.14/go.mod h1:wVPHWcIFv3WO89w0rE10gzf17ZYy+UVS1Geq8Iei34g=
github.com/aws/aws-sdk-go-v2/config v1.29.17 h1:jSuiQ5jEe4SAMH6lLRMY9OVC+TqJLP5655pBGjmnjr0=
github.com/aws/aws-sdk-go-v2/config v1.29.17/go.mod h1:9P4wwACpbeXs9Pm9w1QTh6BwWwJjwYvJ1iCt5QbCXh8=
github.com/aws/aws-sdk-go-v2/credentials v1.17.67 h1:9KxtdcIA/5xPNQyZRgUSpYOE6j9Bc4+D7nZua0KGYOM=
github.com/aws/aws-sdk-go-v2/credentials v1.17.67/go.mod h1:p3C44m+cfnbv763s52gCqrjaqyPikj9Sg47kUVaNZQQ=
github.com/aws/aws-sdk-go-v2/credentials v1.17.70 h1:ONnH5CM16RTXRkS8Z1qg7/s2eDOhHhaXVd72mmyv4/0=
github.com/aws/aws-sdk-go-v2/credentials v1.17.70/go.mod h1:M+lWhhmomVGgtuPOhO85u4pEa3SmssPTdcYpP/5J/xc=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30 h1:x793wxmUWVDhshP8WW2mlnXuFrO4cOd3HLBroh1paFw=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.30/go.mod h1:Jpne2tDnYiFascUEs2AWHJL9Yp7A5ZVy3TNyxaAjD6M=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 h1:KAXP9JSHO1vKGCr5f4O6WmlVKLFFXgWYAGoJosorxzU=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32/go.mod h1:h4Sg6FQdexC1yYG9RDnOvLbW1a/P986++/Y/a+GyEM8=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34 h1:ZK5jHhnrioRkUNOc+hOgQKlUL5JeC3S6JgLxtQ+Rm0Q=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.34/go.mod h1:p4VfIceZokChbA9FzMbRGz5OV+lekcVtHlPKEO0gSZY=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 h1:SsytQyTMHMDPspp+spo7XwXTP44aJZZAC7fBV2C5+5s=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36/go.mod h1:Q1lnJArKRXkenyog6+Y+zr7WDpk4e6XlR6gs20bbeNo=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34 h1:SZwFm17ZUNNg5Np0ioo/gq8Mn6u9w19Mri8DnJ15Jf0=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.34/go.mod h1:dFZsC0BLo346mvKQLWmoJxT+Sjp+qcVR1tRVHQGOH9Q=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 h1:i2vNHQiXUvKhs3quBR6aqlgJaiaexz/aNvdCktW/kAM=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36/go.mod h1:UdyGa7Q91id/sdyHPwth+043HhmP6yP9MBHgbZM0xo8=
github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo=
github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3 h1:eAh2A4b5IzM/lum78bZ590jy36+d/aFLgKF/4Vd1xPE=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.3/go.mod h1:0yKJC/kb8sAnmlYa6Zs3QVYqaC8ug2AbnNChv5Ox3uA=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 h1:CXV68E2dNqhuynZJPB80bhPQwAKqBWVer887figW6Jc=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4/go.mod h1:/xFi9KtvBXP97ppCz1TAEvU1Uf66qvid89rbem3wCzQ=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15 h1:dM9/92u2F1JbDaGooxTq18wmmFzbJRfXfVfy96/1CXM=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.15/go.mod h1:SwFBy2vjtA0vZbjjaFtfN045boopadnoVPhu4Fv66vY=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 h1:t0E6FzREdtCsiLIoLCWsYliNsRBgyGD/MCK571qk4MI=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17/go.mod h1:ygpklyoaypuyDvOM5ujWGrYWpAK3h7ugnmKCU/76Ys4=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.3 h1:1Gw+9ajCV1jogloEv1RRnvfRFia2cL6c9cuKV2Ps+G8=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.3/go.mod h1:qs4a9T5EMLl/Cajiw2TcbNt2UNo/Hqlyp+GiuG4CFDI=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 h1:AIRJ3lfb2w/1/8wOOSqYb9fUKGwQbtysJ2H1MofRUPg=
github.com/aws/aws-sdk-go-v2/service/sso v1.25.5/go.mod h1:b7SiVprpU+iGazDUqvRSLf5XmCdn+JtT1on7uNL6Ipc=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1 h1:hXmVKytPfTy5axZ+fYbR5d0cFmC3JvwLm5kM83luako=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.1/go.mod h1:MlYRNmYu/fGPoxBQVvBYr9nyr948aY/WLUvwBMBJubs=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 h1:BpOxT3yhLwSJ77qIY3DoHAQjZsc4HEGfMCE4NGy3uFg=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3/go.mod h1:vq/GQR1gOFLquZMSrxUK/cpvKCNVYibNyJ1m7JrU88E=
github.com/aws/aws-sdk-go-v2/service/sts v1.33.19 h1:1XuUZ8mYJw9B6lzAkXhqHlJd/XvaX32evhproijJEZY=
github.com/aws/aws-sdk-go-v2/service/sts v1.33.19/go.mod h1:cQnB8CUnxbMU82JvlqjKR2HBOm3fe9pWorWBza6MBJ4=
github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 h1:NFOJ/NXEGV4Rq//71Hs1jC/NvPs1ezajK+yQmkwnPV0=
github.com/aws/aws-sdk-go-v2/service/sts v1.34.0/go.mod h1:7ph2tGpfQvwzgistp2+zga9f+bCjlQJPkPUmMgDSD7w=
github.com/aws/smithy-go v1.22.2 h1:6D9hW43xKFrRx/tXXfAlIZc4JI+yQe6snnWcQyxSyLQ=
github.com/aws/smithy-go v1.22.2/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg=
github.com/aws/smithy-go v1.22.4 h1:uqXzVZNuNexwc/xrh6Tb56u89WDlJY6HS+KC0S4QSjw=
github.com/aws/smithy-go v1.22.4/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI=
github.com/aymanbagabas/go-osc52 v1.0.3/go.mod h1:zT8H+Rk4VSabYN90pWyugflM3ZhpTZNC7cASDfUCdT4=
github.com/aymanbagabas/go-osc52 v1.2.1/go.mod h1:zT8H+Rk4VSabYN90pWyugflM3ZhpTZNC7cASDfUCdT4=
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/briandowns/spinner v1.23.0 h1:alDF2guRWqa/FOZZYWjlMIx2L6H0wyewPxo/CH4Pt2A=
github.com/briandowns/spinner v1.23.0/go.mod h1:rPG4gmXeN3wQV/TsAY4w8lPdIM6RX3yqeBQJSrbXjuE=
github.com/briandowns/spinner v1.23.2 h1:Zc6ecUnI+YzLmJniCfDNaMbW0Wid1d5+qcTq4L2FW8w=
github.com/briandowns/spinner v1.23.2/go.mod h1:LaZeM4wm2Ywy6vO571mvhQNRcWfRUnXOs0RcKV0wYKM=
github.com/calmh/randomart v1.1.0 h1:evl+iwc10LXtHdMZhzLxmsCQVmWnkXs44SbC6Uk0Il8=
github.com/calmh/randomart v1.1.0/go.mod h1:DQUbPVyP+7PAs21w/AnfMKG5NioxS3TbZ2F9MSK/jFM=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/charmbracelet/bubbles v0.7.5/go.mod h1:IRTORFvhEI6OUH7WhN2Ks8Z8miNGimk1BE6cmHijOkM=
github.com/charmbracelet/bubbles v0.15.0/go.mod h1:Y7gSFbBzlMpUDR/XM9MhZI374Q+1p1kluf1uLl8iK74=
github.com/charmbracelet/bubbles v0.20.0 h1:jSZu6qD8cRQ6k9OMfR1WlM+ruM8fkPWkHvQWD9LIutE=
github.com/charmbracelet/bubbles v0.20.0/go.mod h1:39slydyswPy+uVOHZ5x/GjwVAFkCsV8IIVy+4MhzwwU=
github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
github.com/charmbracelet/bubbletea v0.12.2/go.mod h1:3gZkYELUOiEUOp0bTInkxguucy/xRbGSOcbMs1geLxg=
github.com/charmbracelet/bubbletea v0.23.1/go.mod h1:JAfGK/3/pPKHTnAS8JIE2u9f61BjWTQY57RbT25aMXU=
github.com/charmbracelet/bubbletea v0.23.2/go.mod h1:FaP3WUivcTM0xOKNmhciz60M6I+weYLF76mr1JyI7sM=
github.com/charmbracelet/bubbletea v1.3.0 h1:fPMyirm0u3Fou+flch7hlJN9krlnVURrkUVDwqXjoAc=
github.com/charmbracelet/bubbletea v1.3.0/go.mod h1:eTaHfqbIwvBhFQM/nlT1NsGc4kp8jhF8LfUK67XiTDM=
github.com/charmbracelet/bubbletea v1.3.5 h1:JAMNLTbqMOhSwoELIr0qyP4VidFq72/6E9j7HHmRKQc=
github.com/charmbracelet/bubbletea v1.3.5/go.mod h1:TkCnmH+aBd4LrXhXcqrKiYwRs7qyQx5rBgH5fVY3v54=
github.com/charmbracelet/charm v0.8.7 h1:FJ9b7IxWUWHOPR72zS/QJLEqtudOB2Mwfc+Sir0eZR8=
github.com/charmbracelet/charm v0.8.7/go.mod h1:ApJYwJljEjODkOYJgFDzbUqztLrCWQct9zyPD+xcVr4=
github.com/charmbracelet/colorprofile v0.3.1 h1:k8dTHMd7fgw4bnFd7jXTLZrSU/CQrKnL3m+AxCzDz40=
github.com/charmbracelet/colorprofile v0.3.1/go.mod h1:/GkGusxNs8VB/RSOh3fu0TJmQ4ICMMPApIIVn0KszZ0=
github.com/charmbracelet/glamour v0.6.0 h1:wi8fse3Y7nfcabbbDuwolqTqMQPMnVPeZhDM273bISc=
github.com/charmbracelet/glamour v0.6.0/go.mod h1:taqWV4swIMMbWALc0m7AfE9JkPSU8om2538k9ITBxOc=
github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
github.com/charmbracelet/glow v1.5.1 h1:o1mwT4xXXpkfUhJG6euQayNxLZf9yKctOCNHLztrwdE=
github.com/charmbracelet/glow v1.5.1/go.mod h1:rGgop0a2/4gXWiAxUW1iEQseoE+9Ctpb7M4sM9cY9CU=
github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
github.com/charmbracelet/lipgloss v0.6.0/go.mod h1:tHh2wr34xcHjC2HCXIlGSG1jaDF0S0atAUvBMP6Ppuk=
github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
github.com/charmbracelet/x/ansi v0.9.3 h1:BXt5DHS/MKF+LjuK4huWrC6NCvHtexww7dMayh6GXd0=
github.com/charmbracelet/x/ansi v0.9.3/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
github.com/charmbracelet/x/exp/slice v0.0.0-20250623112707-45752038d08d h1:U/S+aA/k7pkJdYkBUhbmMOZXszU19WmauJ4bXe+7zRc=
github.com/charmbracelet/x/exp/slice v0.0.0-20250623112707-45752038d08d/go.mod h1:vI5nDVMWi6veaYH+0Fmvpbe/+cv/iJfMntdh+N0+Tms=
github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8 h1:AqW2bDQf67Zbq6Tpop/+yJSIknxhiQecO2B8jNYTAPs=
github.com/chromedp/cdproto v0.0.0-20250319231242-a755498943c8/go.mod h1:NItd7aLkcfOA/dcMXvl8p1u+lQqioRMq/SqDp71Pb/k=
github.com/chromedp/chromedp v0.13.3 h1:c6nTn97XQBykzcXiGYL5LLebw3h3CEyrCihm4HquYh0=
github.com/chromedp/chromedp v0.13.3/go.mod h1:khsDP9OP20GrowpJfZ7N05iGCwcAYxk7qf9AZBzR3Qw=
github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw=
github.com/containerd/console v1.0.3/go.mod h1:7LqA/THxQ86k76b8c/EMSiaJ3h1eZkMkXar0TQ1gf3U=
github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cqroot/multichoose v0.1.1 h1:diGuKYKea9ePOTwUyUDor9zKRqKFWXGkYGqUa9+firU=
github.com/cqroot/multichoose v0.1.1/go.mod h1:BJzIGqbQZNADPDuA3IzhmTMpRc2F3fZKysMRYP+Ydw8=
github.com/cqroot/prompt v0.9.3 h1:00Sjiasl1QL7ttEphJ+1xAl0fKQi+7s2F3aY0x7wnz4=
github.com/cqroot/prompt v0.9.3/go.mod h1:NZvCTeuvR9ew9Hkk7xlrZ9xdVH4AmkO9R0eeBkzOHXQ=
github.com/cqroot/prompt v0.9.4 h1:uFRlhXuOP3CSD+Pii0Z8VJhgXpavSloFf7/KAERwjz8=
github.com/cqroot/prompt v0.9.4/go.mod h1:6BVZiEv7XkW1K64y1k2wdzToDwspL3n/RkUIyPjQ808=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/creack/pty v1.1.17 h1:QeVUsEDNrLBW4tMgZHvxy18sKtr6VI492kBhUfhDJNI=
github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203 h1:XBBHcIb256gUJtLmY22n99HaZTz+r2Z51xUPi01m3wg=
github.com/eiannone/keyboard v0.0.0-20220611211555-0d226195f203/go.mod h1:E1jcSv8FaEny+OP/5k9UxZVw9YFWGj7eI4KR/iOBqCg=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
github.com/frankban/quicktest v1.14.3/go.mod h1:mgiwOwqx65TmIk1wJ6Q7wvnVMocbUorkibMOrVTHZps=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4 h1:ygs9POGDQpQGLJPlq4+0LBUmMBNox1N4JSpw+OETcvI=
github.com/gen2brain/beeep v0.0.0-20240516210008-9c006672e7f4/go.mod h1:0W7dI87PvXJ1Sjs0QPvWXKcQmNERY77e8l7GFhZB/s4=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535 h1:yE7argOs92u+sSCRgqqe6eF+cDaVhSPlioy1UkA0p/w=
github.com/go-json-experiment/json v0.0.0-20250211171154-1ae217ad3535/go.mod h1:BWmvoE1Xia34f3l/ibJweyhrT+aROb/FQ6d+37F0e2s=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4 h1:qZNfIGkIANxGv/OqtnntR4DfOY2+BgwR60cAcu/i3SE=
github.com/go-toast/toast v0.0.0-20190211030409-01e6764cf0a4/go.mod h1:kW3HQ4UdaAyrUCSSDR4xUzBKW6O2iA4uHhk7AtyYp10=
github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang-migrate/migrate/v4 v4.18.3 h1:EYGkoOsvgHHfm5U/naS1RP/6PL/Xv3S4B/swMiAmDLs=
github.com/golang-migrate/migrate/v4 v4.18.3/go.mod h1:99BKpIi6ruaaXRM1A77eqZ+FWPQ3cfRa+ZVy5bmWMaY=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f/go.mod h1:nOFQdrUlIlx6M6ODdSpBj1NVA+VgLC6kmw60mkw34H4=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg=
github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM=
github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM=
github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c=
github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo=
github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY=
github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4=
github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
github.com/hashicorp/consul/api v1.15.3/go.mod h1:/g/qgcoBcEXALCNZgRRisyTW0nY86++L0KbeAMXYCeY=
github.com/hashicorp/consul/sdk v0.11.0/go.mod h1:yPkX5Q6CsxTFMjQQDJwzeNmUUF5NUGGbrDsv9wTb8cw=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-hclog v0.14.1/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-msgpack v0.5.5/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8=
github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A=
github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc=
github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
github.com/hashicorp/memberlist v0.3.1/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE=
github.com/hashicorp/serf v0.9.7/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4=
github.com/hashicorp/serf v0.9.8/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog=
github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68=
github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf h1:WfD7VjIE6z8dIvMsI4/s+1qr5EL+zoIGev1BQj1eoJ8=
github.com/inconshreveable/go-update v0.0.0-20160112193335-8152e7eb6ccf/go.mod h1:hyb9oH7vZsitZCiBt0ZvifOrB+qc8PS5IiilCIb87rg=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
github.com/jmoiron/sqlx v1.4.0 h1:1PLqN7S1UYp5t4SrVVnt4nUVNemrDAtxlulVe+Qgm3o=
github.com/jmoiron/sqlx v1.4.0/go.mod h1:ZrZ7UsYB/weZdl2Bxg6jCRO9c3YHl8r3ahlKmRT4JLY=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
github.com/lithammer/fuzzysearch v1.1.8/go.mod h1:IdqeyBClc3FFqSzYq/MXESsS4S0FsZ5ajtkr5xPLts4=
github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/magiconair/properties v1.8.6 h1:5ibWZ6iY0NctNGWo87LalDlEZ6R41TqbbDamhfG/Qzo=
github.com/magiconair/properties v1.8.6/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
github.com/mattn/go-tty v0.0.3 h1:5OfyWorkyO7xP52Mq7tB36ajHDG5OHrmBGIS/DtakQI=
github.com/mattn/go-tty v0.0.3/go.mod h1:ihxohKRERHTVzN+aSVRwACLCeqIoZAWpoICkkvrWyR0=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/meowgorithm/babyenv v1.3.0/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
github.com/meowgorithm/babyenv v1.3.1 h1:18ZEYIgbzoFQfRLF9+lxjRfk/ui6w8U0FWl07CgWvvc=
github.com/meowgorithm/babyenv v1.3.1/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d h1:5PJl274Y63IEHC+7izoQE9x6ikvDFZS2mDVS3drnohI=
github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/microcosm-cc/bluemonday v1.0.21/go.mod h1:ytNkv4RrDrLJ2pqlsSI46O6IVXmZOBBD4SaJyDwwTkM=
github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso=
github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a h1:eU8j/ClY2Ty3qdHnn0TyW3ivFoPC/0F1gQZz8yTxbbE=
github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a/go.mod h1:v8eSC2SMp9/7FTKUncp7fH9IwPfw+ysMObcEz5FWheQ=
github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
github.com/muesli/gitcha v0.2.0 h1:+wOgT2dI9s2Tznj1t1rb/qkK5e0cb6qD8c4IX2TR/YY=
github.com/muesli/gitcha v0.2.0/go.mod h1:Ri8m9TZS4+ORG4JVmVKUQcWZuxDvUW3UKxMdQfzG2zI=
github.com/muesli/go-app-paths v0.2.1/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
github.com/muesli/go-app-paths v0.2.2 h1:NqG4EEZwNIhBq/pREgfBmgDmt3h1Smr1MjZiXbpZUnI=
github.com/muesli/go-app-paths v0.2.2/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
github.com/muesli/reflow v0.2.1-0.20210115123740-9e1d0d53df68/go.mod h1:Xk+z4oIWdQqJzsxyjgl3P22oYZnHdZ8FFTHAQQt5BMQ=
github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a h1:Hw/15RYEOUD6T9UCRkUmNBa33kJkH33Fui6hE4sRLKU=
github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a/go.mod h1:+XG0ne5zXWBTSbbe7Z3/RWxaT8PZY6zaZ1dX6KjprYY=
github.com/muesli/termenv v0.7.2/go.mod h1:ct2L5N2lmix82RaY3bMWwVu/jUFc9Ule0KGDCiKYPh8=
github.com/muesli/termenv v0.7.4/go.mod h1:pZ7qY9l3F7e5xsAOS0zCew2tME+p7bWeBkotCEcIIcc=
github.com/muesli/termenv v0.11.1-0.20220204035834-5ac8409525e0/go.mod h1:Bd5NYQ7pd+SrtBSrSNoBBmXlcY8+Xj4BMJgh8qcZrvs=
github.com/muesli/termenv v0.13.0/go.mod h1:sP1+uffeLaEYpyOTb8pLCUctGcGLnoFjSn4YJK5e2bc=
github.com/muesli/termenv v0.14.0/go.mod h1:kG/pF1E7fh949Xhe156crRUrHNyK221IuGO7Ez60Uc8=
github.com/muesli/termenv v0.15.1/go.mod h1:HeAQPTzpfs016yGtA4g00CsdYnVLJvxsS4ANqrZs2sQ=
github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a h1:2MaM6YC3mGu54x+RKAA6JiFFHlHDY1UbkxqppT7wYOg=
github.com/muesli/termenv v0.15.3-0.20240618155329-98d742f6907a/go.mod h1:hxSnBBYLK21Vtq/PHd0S2FYCxBXzBua8ov5s1RobyRQ=
github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d h1:VhgPp6v9qf9Agr/56bj7Y/xa04UccTW04VP0Qed4vnQ=
github.com/nu7hatch/gouuid v0.0.0-20131221200532-179d4d0c4d8d/go.mod h1:YUTz3bUH2ZwIWBy3CJBeOBEugqcmXREj14T+iG/4k4U=
github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/olekukonko/tablewriter v1.0.7 h1:HCC2e3MM+2g72M81ZcJU11uciw6z/p82aEnm4/ySDGw=
github.com/olekukonko/tablewriter v1.0.7/go.mod h1:H428M+HzoUXC6JU2Abj9IT9ooRmdq9CxuDmKMtrOCMs=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
github.com/pelletier/go-toml/v2 v2.0.5 h1:ipoSadvV8oGUjnUbMub59IDPPwfxF694nG/jwbMiyQg=
github.com/pelletier/go-toml/v2 v2.0.5/go.mod h1:OMHamSCAODeSsVrwwvcJOaoN0LIUIaFVNZzmWyNfXas=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
github.com/pkg/term v1.2.0-beta.2 h1:L3y/h2jkuBVFdWiJvNfYfKmzcCnILw7mJWm2JQuMppw=
github.com/pkg/term v1.2.0-beta.2/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw=
github.com/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c h1:bki/wkg5iFBOv3jCPUDNuH5yLngUPUdEJCSuvc2tiQ0=
github.com/plandex-ai/go-prompt v0.0.0-20250304173555-1f364907fc6c/go.mod h1:SqEsJfsIr0GYUyLatvezDOBe6XsCw64E7v33QzeH5PM=
github.com/plandex-ai/survey/v2 v2.3.7 h1:u1o6bflbaBpW8i8krm+91Z2cOcvZcMVS+AjV+rgR8Rk=
github.com/plandex-ai/survey/v2 v2.3.7/go.mod h1:RiBOKRDB5fOQrOzsiAPAN57hYqFKPkCxgSK7twcDOys=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94/go.mod h1:b18R55ulyQ/h3RaWyloPyER7fWQVZvimKKhnI5OfrJQ=
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI=
github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs=
github.com/sagikazarmark/crypt v0.8.0/go.mod h1:TmKwZAo97S4Fy4sfMH/HX/cQP5D+ijra2NyLpNNmttY=
github.com/sahilm/fuzzy v0.1.0/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
github.com/sashabaranov/go-openai v1.40.0 h1:Peg9Iag5mUJtPW00aYatlsn97YML0iNULiLNe74iPrU=
github.com/sashabaranov/go-openai v1.40.0/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/sashabaranov/go-openai v1.40.3 h1:PkOw0SK34wrvYVOuXF1HZzuTBRh992qRZHil4kG3eYE=
github.com/sashabaranov/go-openai v1.40.3/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
github.com/segmentio/ksuid v1.0.4 h1:sBo2BdShXjmcugAMwjugoGUdUV0pcxY5mW4xKRn3v4c=
github.com/segmentio/ksuid v1.0.4/go.mod h1:/XUiZBD3kVx5SmUOl55voK5yeAbBNNIed+2O73XgrPE=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82 h1:6C8qej6f1bStuePVkLSFxoU22XBS165D3klxlzRg8F4=
github.com/smacker/go-tree-sitter v0.0.0-20240827094217-dd81d9e9be82/go.mod h1:xe4pgH49k4SsmkQq5OT8abwhWmnzkhpgnXeekbx2efw=
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/afero v1.9.2 h1:j49Hj62F0n+DaZ1dDCvhABaPNSGNkt32oRFxI33IEMw=
github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w=
github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU=
github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY=
github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
github.com/spf13/viper v1.14.0 h1:Rg7d3Lo706X9tHsJMUjdiwMpHB7W8WnSVOssIY+JElU=
github.com/spf13/viper v1.14.0/go.mod h1:WT//axPky3FdvXHzGw33dNdXXXfFQqmEalje+egj8As=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.5/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/subosito/gotenv v1.4.1 h1:jyEFiXpy21Wm81FBN71l9VoMMV8H8jG+qIK3GCpY6Qs=
github.com/subosito/gotenv v1.4.1/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af h1:6yITBqGTE2lEeTPG04SN9W+iWHCRyHqlVYILiSXziwk=
github.com/tadvi/systray v0.0.0-20190226123456-11a2b8fa57af/go.mod h1:4F09kP5F+am0jAwlQLddpoMDM+iewkxxt6nxUQ5nq5o=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=
github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xlab/treeprint v1.2.0 h1:HzHnuAF1plUN2zGlAFHbSQP2qJ0ZAD3XF5XD7OesXRQ=
github.com/xlab/treeprint v1.2.0/go.mod h1:gj5Gd3gPdKtR1ikdDK6fnFLdmIS0X30kTTuNd/WEJu0=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.3.7/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.5.2/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.6.0 h1:boZcn2GTjpsynOsC0iJHnBWa4Bi0qzfJjthwauItG68=
github.com/yuin/goldmark v1.6.0/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.7.12 h1:YwGP/rrea2/CnCtUHgjuolG/PnMxdQtPMO5PvaE2/nY=
github.com/yuin/goldmark v1.7.12/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
github.com/yuin/goldmark-emoji v1.0.1/go.mod h1:2w1E6FEWLcDQkoTE+7HU6QF1F6SLlNGjRIBbIZQFqkQ=
github.com/yuin/goldmark-emoji v1.0.2 h1:c/RgTShNgHTtc6xdz2KKI74jJr6rWi7FPgnP9GAsO5s=
github.com/yuin/goldmark-emoji v1.0.2/go.mod h1:RhP/RWpexdp+KHs7ghKnifRoIs/Bq4nDS7tRbCkOwKY=
github.com/yuin/goldmark-emoji v1.0.6 h1:QWfF2FYaXwL74tfGOW5izeiZepUDroDJfWubQI9HTHs=
github.com/yuin/goldmark-emoji v1.0.6/go.mod h1:ukxJDKFpdFb5x0a5HqbdlcKtebh086iJpI31LTKmWuA=
go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
go.etcd.io/etcd/api/v3 v3.5.5/go.mod h1:KFtNaxGDw4Yx/BA4iPPwevUTAuqcsPxzyX8PHydchN8=
go.etcd.io/etcd/client/pkg/v3 v3.5.5/go.mod h1:ggrwbk069qxpKPq8/FKkQ3Xq9y39kbFR4LnKszpRXeQ=
go.etcd.io/etcd/client/v2 v2.305.5/go.mod h1:zQjKllfqfBVyVStbt4FaosoX2iYd8fV/GRy/PbowgP4=
go.etcd.io/etcd/client/v3 v3.5.5/go.mod h1:aApjR4WGlSumpnJ2kloS75h6aHUmAyaPLjHMxpc7E7c=
go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
go.uber.org/multierr v1.8.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo=
go.uber.org/zap v1.21.0/go.mod h1:wjWOCqI0f2ZZrJF/UufIOkiC8ii6tm1iqIsLo76RfJw=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f h1:XdNn9LlyWAhLVp6P/i8QYBW+hlyhrhei9uErw2B5GJo=
golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f/go.mod h1:D5SMRVC3C2/4+F/DB1wZsLRnSNimn2Sp/NPsCrsv8ak=
golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
golang.org/x/image v0.28.0 h1:gdem5JW1OLS4FbkWgLO+7ZeFzYtL3xClb97GaUzYMFE=
golang.org/x/image v0.28.0/go.mod h1:GUJYXtnGKEUgggyzh+Vxt+AviiCcyiwpsl8iQ8MvwGY=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8=
golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20211216030914-fe4d6282115f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200916030750-2334cc1a136f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201020230747-6e5568b54d1a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220204135822-1c1b9b1eba6a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20220609170525-579cf78fd858/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU=
google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94=
google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo=
google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4=
google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw=
google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU=
google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k=
google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo=
google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g=
google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA=
google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8=
google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs=
google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw=
google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg=
google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o=
google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g=
google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw=
google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI=
google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s=
google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70=
google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w=
google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE=
google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc=
google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk=
google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo=
google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw=
google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI=
google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U=
google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM=
google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k=
google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI=
google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=


================================================
FILE: app/server/syntax/file_map/cli/main.go
================================================
package main

import (
	"context"
	"fmt"
	"os"
	"plandex-server/syntax/file_map"
	"sync"
	"time"

	shared "plandex-shared"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	args := os.Args[1:]

	if len(args) < 1 {
		fmt.Println("usage: mapper [files-or-dirs...]")
		os.Exit(1)
	}

	var parserTree bool = false

	for i, arg := range args {
		if arg == "--trees" {
			parserTree = true
			args = append(args[:i], args[i+1:]...)
			break
		}
	}

	paths := args

	var filteredPaths []string
	for _, path := range paths {
		if shared.HasFileMapSupport(path) {
			filteredPaths = append(filteredPaths, path)
		}
	}

	errCh := make(chan error, len(filteredPaths))
	fileInputs := map[string]string{}
	var mu sync.Mutex

	for _, path := range filteredPaths {
		go func(path string) {
			content, err := os.ReadFile(path)
			if err != nil {
				errCh <- fmt.Errorf("error reading file: %v", err)
				return
			}
			mu.Lock()
			fileInputs[path] = string(content)
			mu.Unlock()
			errCh <- nil
		}(path)
	}

	for i := 0; i < len(filteredPaths); i++ {
		err := <-errCh
		if err != nil {
			fmt.Printf("error reading file: %v\n", err)
			os.Exit(1)
		}
	}

	if parserTree {
		trees, err := file_map.ProcessMapTrees(ctx, fileInputs)
		if err != nil {
			fmt.Printf("error processing map files: %v\n", err)
			os.Exit(1)
		}
		fmt.Println(trees.CombinedTrees())
	} else {
		mapBodies, err := file_map.ProcessMapFiles(ctx, fileInputs)
		if err != nil {
			fmt.Printf("error processing map files: %v\n", err)
			os.Exit(1)
		}

		fmt.Println(mapBodies.CombinedMap(map[string]int{}))
	}
}


================================================
FILE: app/server/syntax/file_map/examples/bash_example.sh
================================================
#!/bin/bash

# Global variables
GLOBAL_VAR="Hello World"
readonly CONSTANT_VAR="This is constant"

# Function definition
function print_message() {
    local message="$1"
    echo "$message"
}

# Function with return value
get_date() {
    echo $(date +%Y-%m-%d)
}

# Array declaration
declare -a fruits=("apple" "banana" "orange")

# Associative array
declare -A user_info=(
    ["name"]="John"
    ["age"]="30"
    ["city"]="New York"
)

# Main script execution
main() {
    print_message "$GLOBAL_VAR"
    current_date=$(get_date)
    echo "Today is: $current_date"
    
    # Loop through array
    for fruit in "${fruits[@]}"; do
        echo "Fruit: $fruit"
    done
    
    # Access associative array
    echo "User ${user_info[name]} is ${user_info[age]} years old"
}

# Call main function
main


================================================
FILE: app/server/syntax/file_map/examples/c_example.c
================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Macro definitions
#define MAX_SIZE 100
#define SQUARE(x) ((x) * (x))

// Type definitions
typedef struct {
    char name[50];
    int age;
} Person;

typedef enum {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY
} Weekday;

// Global variables
static const double PI = 3.14159;
int globalCounter = 0;

// Function declarations
void printPerson(const Person* p);
int factorial(int n);

// Union example
union Data {
    int i;
    float f;
    char str[20];
};

// Function pointer type
typedef int (*Operation)(int, int);

// Function implementations
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

void printPerson(const Person* p) {
    printf("Name: %s, Age: %d\n", p->name, p->age);
}

int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// Main function
int main() {
    // Local variable declarations
    Person person = {"John Doe", 30};
    union Data data;
    Operation op = add;
    
    // Using structs
    printPerson(&person);
    
    // Using unions
    data.i = 10;
    printf("data.i: %d\n", data.i);
    
    // Using function pointers
    printf("10 + 20 = %d\n", op(10, 20));
    op = subtract;
    printf("10 - 20 = %d\n", op(10, 20));
    
    // Using macros
    printf("Square of 5 is %d\n", SQUARE(5));
    
    // Using enums
    Weekday today = WEDNESDAY;
    printf("Day number: %d\n", today);
    
    // Using global variables
    globalCounter++;
    printf("Global counter: %d\n", globalCounter);
    
    return 0;
}


================================================
FILE: app/server/syntax/file_map/examples/cpp_example.cpp
================================================
#include <iostream>
#include <memory>
#include <vector>
#include <string>
#include <functional>

// Global variables at file scope
int globalInteger = 42;
const double PI = 3.14159;
static std::string globalString = "Global static string";

// Global enum and constant
enum Color { RED, GREEN, BLUE };
constexpr int MAX_SIZE = 100;

// Template class
template<typename T>
class Container {
public:
    static T defaultValue;  // Static class member
    const T maxCapacity = MAX_SIZE;  // Class constant
    void add(T item) { items.push_back(item); }
    const std::vector<T>& getItems() const { return items; }
private:
    std::vector<T> items;
};

// Static member definition
template<typename T>
T Container<T>::defaultValue = T();

// Abstract base class
class Animal {
public:
    virtual ~Animal() = default;
    virtual void makeSound() const = 0;
protected:
    std::string name;
};

// Derived class with virtual inheritance
class Dog : virtual public Animal {
public:
    Dog(const std::string& dogName) { name = dogName; }
    void makeSound() const override {
        std::cout << name << " says: Woof!" << std::endl;
    }
};

// Namespace example
namespace Utils {
    // Namespace-level variables
    inline int counter = 0;
    const std::string VERSION = "1.0.0";
    
    // Function template
    template<typename T>
    T max(T a, T b) {
        return (a > b) ? a : b;
    }

    // Lambda function stored in variable
    const auto printer = [](const std::string& msg) {
        std::cout << "Message: " << msg << std::endl;
    };
}

// Smart pointer and move semantics example
class Resource {
public:
    Resource(const std::string& data) : data_(data) {
        std::cout << "Resource constructed" << std::endl;
    }
    ~Resource() {
        std::cout << "Resource destroyed" << std::endl;
    }
    Resource(Resource&& other) noexcept : data_(std::move(other.data_)) {}
    std::string getData() const { return data_; }
private:
    std::string data_;
};

// Static member variable and function
class Counter {
public:
    static int getCount() { return count; }
    Counter() { ++count; }
    ~Counter() { --count; }
private:
    static int count;
};
int Counter::count = 0;

// Friend function example
class Box {
    friend std::ostream& operator<<(std::ostream& os, const Box& box);
public:
    Box(int w, int h) : width(w), height(h) {}
private:
    int width;
    int height;
};

std::ostream& operator<<(std::ostream& os, const Box& box) {
    return os << "Box(" << box.width << "x" << box.height << ")";
}

// Main function
int main() {
    // Smart pointer usage
    auto resource = std::make_unique<Resource>("Hello");
    std::cout << resource->getData() << std::endl;

    // Template class usage
    Container<int> numbers;
    numbers.add(1);
    numbers.add(2);

    // Polymorphism
    std::unique_ptr<Animal> dog = std::make_unique<Dog>("Rex");
    dog->makeSound();

    // Template function
    std::cout << "Max: " << Utils::max(10, 20) << std::endl;

    // Lambda function
    Utils::printer("Hello from lambda!");

    // Counter static example
    Counter c1, c2;
    std::cout << "Count: " << Counter::getCount() << std::endl;

    // Friend function
    Box box(10, 20);
    std::cout << box << std::endl;

    return 0;
}


================================================
FILE: app/server/syntax/file_map/examples/csharp_example.cs
================================================
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;

// Namespace declaration
namespace ExampleApp
{
    // Interface definition
    public interface IProcessor<T>
    {
        Task<T> ProcessAsync(T input);
        bool Validate(T input);
    }

    // Enum definition
    public enum Status
    {
        Pending,
        Active,
        Completed,
        Failed
    }

    // Delegate declaration
    public delegate void StatusChangedEventHandler(Status oldStatus, Status newStatus);

    // Generic class implementing interface
    public class DataProcessor<T> : IProcessor<T> where T : class
    {
        // Event declaration
        public event StatusChangedEventHandler StatusChanged;

        // Auto-implemented property
        public Status CurrentStatus { get; private set; }

        // Static field
        private static readonly Dictionary<Type, int> _processedItems = new();

        // Constructor
        public DataProcessor()
        {
            CurrentStatus = Status.Pending;
        }

        // Async method implementation
        public async Task<T> ProcessAsync(T input)
        {
            var oldStatus = CurrentStatus;
            CurrentStatus = Status.Active;
            OnStatusChanged(oldStatus, CurrentStatus);

            await Task.Delay(100); // Simulate work

            if (_processedItems.ContainsKey(typeof(T)))
                _processedItems[typeof(T)]++;
            else
                _processedItems[typeof(T)] = 1;

            CurrentStatus = Status.Completed;
            OnStatusChanged(Status.Active, CurrentStatus);

            return input;
        }

        // Interface method implementation
        public bool Validate(T input) => input != null;

        // Protected virtual method
        protected virtual void OnStatusChanged(Status oldStatus, Status newStatus)
        {
            StatusChanged?.Invoke(oldStatus, newStatus);
        }

        // Static method
        public static int GetProcessedCount<TItem>() where TItem : class
        {
            return _processedItems.GetValueOrDefault(typeof(TItem));
        }
    }

    // Record type (C# 9.0+)
    public record Person(string Name, int Age)
    {
        // Property with validation
        public string Email { get; init; } = string.Empty;
    }

    // Extension method
    public static class StringExtensions
    {
        public static int WordCount(this string str)
        {
            return str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }

    // Main program class
    public class Program
    {
        public static async Task Main(string[] args)
        {
            var processor = new DataProcessor<Person>();
            processor.StatusChanged += (old, @new) => 
                Console.WriteLine($"Status changed from {old} to {@new}");

            var person = new Person("John Doe", 30) { Email = "john@example.com" };
            
            if (processor.Validate(person))
            {
                var result = await processor.ProcessAsync(person);
                Console.WriteLine($"Processed person: {result.Name}");
                Console.WriteLine($"Word count in name: {result.Name.WordCount()}");
            }

            Console.WriteLine($"Total processed persons: {DataProcessor<Person>.GetProcessedCount<Person>()}");
        }
    }
}


================================================
FILE: app/server/syntax/file_map/examples/css_example.css
================================================
/* Global variables */
:root {
  --primary-color: #3498db;
  --secondary-color: #2ecc71;
  --text-color: #2c3e50;
  --spacing-unit: 1rem;
  --border-radius: 4px;
}

/* Reset and base styles */
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

body {
  font-family: 'Arial', sans-serif;
  line-height: 1.6;
  color: var(--text-color);
}

/* Layout containers */
.container {
  max-width: 1200px;
  margin: 0 auto;
  padding: var(--spacing-unit);
}

/* Grid system */
.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: var(--spacing-unit);
}

/* Flexbox components */
.flex-container {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

/* Component styles */
.button {
  padding: calc(var(--spacing-unit) / 2) var(--spacing-unit);
  border-radius: var(--border-radius);
  border: none;
  cursor: pointer;
  transition: background-color 0.3s ease;
}

.button:hover {
  opacity: 0.9;
}

.button--primary {
  background-color: var(--primary-color);
  color: white;
}

.button--secondary {
  background-color: var(--secondary-color);
  color: white;
}

/* Card component */
.card {
  border-radius: var(--border-radius);
  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
  padding: var(--spacing-unit);
}

/* Media queries */
@media screen and (max-width: 768px) {
  .grid {
    grid-template-columns: repeat(6, 1fr);
  }
}

@media screen and (max-width: 480px) {
  .grid {
    grid-template-columns: 1fr;
  }
  
  .flex-container {
    flex-direction: column;
    gap: var(--spacing-unit);
  }
}

/* Animation keyframes */
@keyframes fadeIn {
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
}

.fade-in {
  animation: fadeIn 0.3s ease-in;
}

/* Form styles */
.form-group {
  margin-bottom: var(--spacing-unit);
}

.form-input {
  width: 100%;
  padding: calc(var(--spacing-unit) / 2);
  border: 1px solid #ddd;
  border-radius: var(--border-radius);
}

/* Navigation */
.nav {
  background-color: var(--primary-color);
  padding: var(--spacing-unit);
}

.nav__list {
  list-style: none;
  display: flex;
  gap: var(--spacing-unit);
}

.nav__link {
  color: white;
  text-decoration: none;
}

/* Utility classes */
.text-center { text-align: center; }
.text-right { text-align: right; }
.text-left { text-align: left; }

.mt-1 { margin-top: var(--spacing-unit); }
.mb-1 { margin-bottom: var(--spacing-unit); }
.ml-1 { margin-left: var(--spacing-unit); }
.mr-1 { margin-right: var(--spacing-unit); }


================================================
FILE: app/server/syntax/file_map/examples/cue_example.cue
================================================
// Package definition
package example

// Import statements
import (
    "strings"
    "time"
)

// Schema definitions
#Person: {
    name:     string
    age:      int & >=0 & <=120
    email?:   string & =~"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
    address?: #Address
}

#Address: {
    street:  string
    city:    string
    country: string
    zip:     string & =~"^[0-9]{5}$"
}

// Default values and constraints
#DefaultPerson: #Person & {
    name: string | *"John Doe"
    age:  int | *30
}

// List type definition
#Team: {
    name:    string
    members: [...#Person]
    leader:  #Person
}

// Computed fields
#Employee: #Person & {
    role:    string
    salary:  float
    taxRate: float

    // Computed field
    netSalary: salary * (1 - taxRate)
}

// Concrete values
exampleTeam: #Team & {
    name: "Engineering"
    members: [
        {
            name: "Alice Smith"
            age:  28
            email: "alice@example.com"
        },
        {
            name: "Bob Jones"
            age:  35
            email: "bob@example.com"
        }
    ]
    leader: {
        name:  "Carol Wilson"
        age:   40
        email: "carol@example.com"
    }
}

// Configuration with references and templates
#Config: {
    environment: "development" | "staging" | "production"
    database: {
        host:     string
        port:     int & >0 & <65536
        username: string
        password: string
    }
    features: [string]: bool
}

// Template usage
productionConfig: #Config & {
    environment: "production"
    database: {
        host:     "db.example.com"
        port:     5432
        username: "admin"
        password: "secret"
    }
    features: {
        "feature1": true
        "feature2": false
    }
}


================================================
FILE: app/server/syntax/file_map/examples/dockerfile_example
================================================
# Multi-stage build example
FROM golang:1.21-alpine AS builder

# Build arguments
ARG VERSION=1.0.0
ARG BUILD_DATE

# Set working directory
WORKDIR /app

# Copy only necessary files for dependency resolution
COPY go.mod go.sum ./

# Download dependencies
RUN go mod download

# Copy source code
COPY . .

# Build the application
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-X main.Version=${VERSION} -X main.BuildDate=${BUILD_DATE}" -o /app/server

# Create final lightweight image
FROM alpine:latest

# Labels for metadata
LABEL maintainer="example@example.com" \
      version="${VERSION}" \
      description="Example Dockerfile with various syntax elements"

# Environment variables
ENV APP_ENV=production \
    PORT=8080

# Create non-root user
RUN addgroup -S appgroup && adduser -S appuser -G appgroup

# Install runtime dependencies
RUN apk add --no-cache \
    ca-certificates \
    tzdata

# Set working directory
WORKDIR /app

# Copy binary from builder stage
COPY --from=builder /app/server .

# Copy configuration files
COPY config/production.yaml /etc/app/config.yaml

# Create volume mount points
VOLUME ["/data", "/logs"]

# Expose ports
EXPOSE 8080 8443

# Switch to non-root user
USER appuser

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
    CMD wget --quiet --tries=1 --spider http://localhost:${PORT}/health || exit 1

# Set entry point and default command
ENTRYPOINT ["/app/server"]
CMD ["--config", "/etc/app/config.yaml"]


================================================
FILE: app/server/syntax/file_map/examples/elixir_example.ex
================================================
defmodule ExampleApp do                                                   
  # Module attributes                                                     
  @default_timeout 5000                                                   
  @version "1.0.0"                                                        
                                                                          
  # Protocol definition                                                   
  defprotocol Formatter do                                                
    @doc "Format the data for display"                                    
    def format(data)                                                      
  end                                                                     
                                                                          
  # Protocol implementation                                               
  defimpl Formatter, for: Map do                                          
    def format(data) do                                                   
      inspect(data, pretty: true)                                         
    end                                                                   
  end                                                                     
                                                                          
  # Struct definition                                                     
  defstruct name: "", age: 0, email: nil                                  
                                                                          
  # Exception definition                                                  
  defexception message: "A custom error occurred"                         
                                                                          
  # Callback definition                                                   
  @callback process(term) :: {:ok, term} | {:error, term}                 
  @macrocallback validate(term) :: Macro.t()                              
                                                                          
  # Public function                                                       
  def calculate_age(birth_year) when is_integer(birth_year) do            
    current_year = DateTime.utc_now().year                                
    current_year - birth_year                                             
  end                                                                     
                                                                          
  # Private function                                                      
  defp validate_email(email) do                                           
    String.match?(email, ~r/^[^\s]+@[^\s]+\.[^\s]+$/)                     
  end                                                                     
                                                                          
  # Function with pattern matching                                        
  def handle_result({:ok, value}), do: "Success: #{value}"                
  def handle_result({:error, reason}), do: "Error: #{reason}"             
  def handle_result(_), do: "Unknown result"                              
                                                                          
  # Macro definition                                                      
  defmacro debug(expression) do                                           
    quote do                                                              
      IO.puts "Debug: #{inspect(unquote(expression))}"                    
    end                                                                   
  end                                                                     
                                                                          
  # Private macro                                                         
  defmacrop log(message) do                                               
    quote do                                                              
      IO.puts("[#{__MODULE__}] #{unquote(message)}")                      
    end                                                                   
  end                                                                     
                                                                          
  # Guard definition                                                      
  defguard is_positive(value) when is_integer(value) and value > 0        
  defguardp is_even(value) when is_integer(value) and rem(value, 2) == 0  
                                                                          
  # Function delegation                                                   
  defdelegate parse_int(string), to: String, as: :to_integer              
                                                                          
  # Overridable function                                                  
  defoverridable [process: 1]                                             
                                                                          
  # Using with for complex operations                                     
  def create_user(params) do                                              
    with {:ok, name} <- Map.fetch(params, "name"),                        
          {:ok, email} <- Map.fetch(params, "email"),                      
          true <- validate_email(email) do                                 
      %ExampleApp{name: name, email: email}                               
    else                                                                  
      :error -> {:error, "Missing required fields"}                       
      false -> {:error, "Invalid email format"}                           
    end                                                                   
  end                                                                     
end   

================================================
FILE: app/server/syntax/file_map/examples/elm_example.elm
================================================
module Example exposing (..)

import Browser
import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Http
import Json.Decode as Decode exposing (Decoder)
import Json.Encode as Encode

-- MODEL

type alias Model =
    { users : List User
    , inputText : String
    , error : Maybe String
    }

type alias User =
    { id : Int
    , name : String
    , email : String
    }

init : () -> (Model, Cmd Msg)
init _ =
    ( { users = []
      , inputText = ""
      , error = Nothing
      }
    , fetchUsers
    )

-- UPDATE

type Msg
    = GotUsers (Result Http.Error (List User))
    | InputChanged String
    | AddUser
    | UserAdded (Result Http.Error User)

update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
    case msg of
        GotUsers result ->
            case result of
                Ok users ->
                    ( { model | users = users, error = Nothing }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to fetch users" }
                    , Cmd.none
                    )

        InputChanged text ->
            ( { model | inputText = text }
            , Cmd.none
            )

        AddUser ->
            ( model
            , addUser model.inputText
            )

        UserAdded result ->
            case result of
                Ok user ->
                    ( { model 
                      | users = user :: model.users
                      , inputText = ""
                      , error = Nothing
                      }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to add user" }
                    , Cmd.none
                    )

-- HTTP

fetchUsers : Cmd Msg
fetchUsers =
    Http.get
        { url = "/api/users"
        , expect = Http.expectJson GotUsers usersDecoder
        }

addUser : String -> Cmd Msg
addUser name =
    Http.post
        { url = "/api/users"
        , body = Http.jsonBody (userEncoder name)
        , expect = Http.expectJson UserAdded userDecoder
        }

-- JSON

userEncoder : String -> Encode.Value
userEncoder name =
    Encode.object
        [ ("name", Encode.string name)
        ]

userDecoder : Decoder User
userDecoder =
    Decode.map3 User
        (Decode.field "id" Decode.int)
        (Decode.field "name" Decode.string)
        (Decode.field "email" Decode.string)

usersDecoder : Decoder (List User)
usersDecoder =
    Decode.list userDecoder

-- VIEW

view : Model -> Html Msg
view model =
    div []
        [ h1 [] [ text "User Management" ]
        , viewError model.error
        , viewInput model.inputText
        , viewUsers model.users
        ]

viewError : Maybe String -> Html Msg
viewError maybeError =
    case maybeError of
        Just error ->
            div [ class "error" ] [ text error ]
        Nothing ->
            text ""

viewInput : String -> Html Msg
viewInput inputText =
    div []
        [ input
            [ value inputText
            , onInput InputChanged
            , placeholder "Enter user name"
            ] []
        , button [ onClick AddUser ] [ text "Add User" ]
        ]

viewUsers : List User -> Html Msg
viewUsers users =
    div []
        [ h2 [] [ text "Users" ]
        , ul [] (List.map viewUser users)
        ]

viewUser : User -> Html Msg
viewUser user =
    li []
        [ text (user.name ++ " (" ++ user.email ++ ")")
        ]

-- MAIN

main : Program () Model Msg
main =
    Browser.element
        { init = init
        , update = update
        , view = view
        , subscriptions = \_ -> Sub.none
        }


================================================
FILE: app/server/syntax/file_map/examples/go_example.go
================================================
//go:build ignore

package main

import (
	"context"
	"fmt"
	"log"
	"sync"
	"time"
)

// Interface definition
type DataProcessor interface {
	Process(ctx context.Context, data interface{}) error
	Validate(data interface{}) bool
}

// Custom error type
type ValidationError struct {
	Field   string
	Message string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation error on field %s: %s", e.Field, e.Message)
}

// Struct with embedded type and tags
type User struct {
	sync.Mutex
	ID        int64     `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at,omitempty"`
}

// Type alias and constants
type UserID = int64

const (
	MaxRetries   = 3
	DefaultLimit = 100
)

// single line const
const singleLineConst string = "single line const"

// Global variables
var (
	defaultTimeout = time.Second * 30
	processor      DataProcessor
)

// single line var
var singleLineVar string = "single line var"

// Generic type
type Result[T any] struct {
	Data    T
	Error   error
	Retries int
}

// Implementation of DataProcessor
type UserProcessor struct {
	cache map[UserID]*User
	mu    sync.RWMutex
}

func NewUserProcessor() *UserProcessor {
	return &UserProcessor{
		cache: make(map[UserID]*User),
	}
}

func (p *UserProcessor) Process(ctx context.Context, data interface{}) error {
	user, ok := data.(*User)
	if !ok {
		return fmt.Errorf("invalid data type: expected *User")
	}

	p.mu.Lock()
	defer p.mu.Unlock()

	p.cache[user.ID] = user
	return nil
}

func (p *UserProcessor) Validate(data interface{}) bool {
	user, ok := data.(*User)
	return ok && user.Name != "" && user.Email != ""
}

// Channel operations
func processUsers(ctx context.Context, users <-chan *User) <-chan *Result[*User] {
	results := make(chan *Result[*User])

	go func() {
		defer close(results)
		for user := range users {
			select {
			case <-ctx.Done():
				return
			case results <- &Result[*User]{Data: user}:
			}
		}
	}()

	return results
}

// Function with multiple return values and named returns
func createUser(name, email string) (user *User, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("panic recovered: %v", r)
		}
	}()

	user = &User{
		Name:      name,
		Email:     email,
		CreatedAt: time.Now(),
	}

	if !processor.Validate(user) {
		return nil, &ValidationError{Field: "user", Message: "invalid user data"}
	}

	return user, nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
	defer cancel()

	processor = NewUserProcessor()

	users := make(chan *User)
	results := processUsers(ctx, users)

	// Anonymous struct
	config := struct {
		Workers int
		Buffer  int
	}{
		Workers: 3,
		Buffer:  10,
	}

	var wg sync.WaitGroup
	wg.Add(config.Workers)

	for i := 0; i < config.Workers; i++ {
		go func(id int) {
			defer wg.Done()
			for result := range results {
				if result.Error != nil {
					log.Printf("Worker %d: Error processing user: %v", id, result.Error)
					continue
				}
				log.Printf("Worker %d: Processed user: %+v", id, result.Data)
			}
		}(i)
	}

	// Cleanup
	close(users)
	wg.Wait()
}


================================================
FILE: app/server/syntax/file_map/examples/groovy_example.groovy
================================================
#!/usr/bin/env groovy

// Trait definition
trait Loggable {
    def log(String message) {
        println "[${new Date()}] $message"
    }
}

// Abstract class definition
abstract class Vehicle {
    String make
    String model
    Integer year
    
    abstract void start()
    abstract void stop()
}

// Class implementation - fixed inheritance syntax
class Car extends Vehicle implements Loggable {
    // Properties with type definitions
    private BigDecimal price
    protected Boolean running = false
    
    // Static fields with proper type declarations
    static final String MANUFACTURER = "Generic Motors"
    static int carCount = 0
    
    // Constructor - fixed parameter initialization
    Car(String make = 'Unknown', String model = 'Generic', Integer year = 2024) {
        this.make = make
        this.model = model
        this.year = year
        carCount++
    }
    
    // Lazy property evaluation
    @Lazy String fullName = "$make $model ($year)"
    
    // Method implementation with synchronized block
    void start() {
        running = true
        log("Starting ${fullName}")
        synchronized(this) {
            println("Engine started")
        }
    }
    
    void stop() {
        running = false
        log("Stopping ${fullName}")
    }
    
    // Operator overloading - fixed map construction
    def plus(Car other) {
        return new Car(
            make: "${this.make}-${other.make}",
            model: "${this.model}-${other.model}",
            year: Math.max(this.year, other.year)
        )
    }
    
    // Property accessors
    private BigDecimal _price
    
    void setPrice(BigDecimal price) {
        if (price < 0) {
            throw new IllegalArgumentException("Price cannot be negative")
        }
        this._price = price
    }
    
    BigDecimal getPrice() {
        return _price
    }
}

// Enum definition
enum Status {
    ACTIVE('A'),
    INACTIVE('I'),
    PENDING('P')
    
    final String code
    
    private Status(String code) {
        this.code = code
    }
    
    @Override
    String toString() {
        return code
    }
}

// Category class with explicit return
class StringExtensions {
    static String truncate(String self, Integer length) {
        return self.size() <= length ? self : self[0..<length] + "..."
    }
}

// Builder pattern class with proper return statements
class EmailBuilder {
    private Map email = [:]
    
    EmailBuilder to(String recipient) {
        email.to = recipient
        return this
    }
    
    EmailBuilder from(String sender) {
        email.from = sender
        return this
    }
    
    EmailBuilder subject(String subject) {
        email.subject = subject
        return this
    }
    
    EmailBuilder body(@DelegatesTo(StringBuilder) Closure body) {
        def builder = new StringBuilder()
        body.delegate = builder
        body.resolveStrategy = Closure.DELEGATE_FIRST
        body()
        email.body = builder.toString()
        return this
    }
    
    Map build() {
        return email.clone() as Map
    }
}

// Main execution with proper closure syntax
def main() {
    use(StringExtensions) {
        def description = "This is a very long description that needs truncating"
        println(description.truncate(20))
    }
    
    def car = new Car(make: "Tesla", model: "Model S")
    car.start()
    
    def email = new EmailBuilder()
        .to("recipient@example.com")
        .from("sender@example.com")
        .subject("Test Email")
        .body {
            append("Hello\n")
            append("This is a test email.\n")
            append("Regards")
        }
        .build()
    
    println(email)
}

// Script execution with proper binding check
if (this.binding.hasVariable('main')) {
    main()
}

================================================
FILE: app/server/syntax/file_map/examples/hcl_example.hcl
================================================
# Variable definitions
variable "environment" {
  type        = string
  description = "Deployment environment"
  default     = "development"
  validation {
    condition     = contains(["development", "staging", "production"], var.environment)
    error_message = "Environment must be development, staging, or production."
  }
}

# Local values
locals {
  common_tags = {
    Environment = var.environment
    Project     = "example"
    ManagedBy  = "terraform"
  }
  
  region_config = {
    us-east-1 = {
      instance_type = "t3.micro"
      az_count      = 2
    }
    us-west-2 = {
      instance_type = "t3.small"
      az_count      = 3
    }
  }
}

# Provider configuration
provider "aws" {
  region = "us-west-2"
  
  assume_role {
    role_arn = "arn:aws:iam::123456789012:role/terraform"
  }
  
  default_tags {
    tags = local.common_tags
  }
}

# Data source
data "aws_availability_zones" "available" {
  state = "available"
}

# Resource block with dynamic blocks
resource "aws_security_group" "example" {
  name_prefix = "example-sg"
  vpc_id      = aws_vpc.main.id
  
  dynamic "ingress" {
    for_each = var.service_ports
    content {
      from_port   = ingress.value
      to_port     = ingress.value
      protocol    = "tcp"
      cidr_blocks = ["0.0.0.0/0"]
    }
  }
  
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
  
  lifecycle {
    create_before_destroy = true
  }
}

# Module usage
module "vpc" {
  source = "terraform-aws-modules/vpc/aws"
  
  name = "example-vpc"
  cidr = "10.0.0.0/16"
  
  azs             = data.aws_availability_zones.available.names
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
  public_subnets  = ["10.0.101.0/24", "10.0.102.0/24"]
  
  enable_nat_gateway = true
  single_nat_gateway = true
  
  tags = merge(
    local.common_tags,
    {
      Name = "example-vpc"
    }
  )
}

# Output values
output "vpc_id" {
  description = "The ID of the VPC"
  value       = module.vpc.vpc_id
}

output "private_subnets" {
  description = "List of private subnet IDs"
  value       = module.vpc.private_subnets
}

# Terraform settings block
terraform {
  required_version = ">= 1.0.0"
  
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }
  }
  
  backend "s3" {
    bucket         = "terraform-state-example"
    key            = "example/terraform.tfstate"
    region         = "us-west-2"
    encrypt        = true
    dynamodb_table = "terraform-locks"
  }
}


================================================
FILE: app/server/syntax/file_map/examples/html_example.html
================================================
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <!-- Example HTML file demonstrating various HTML syntax elements -->
    <title>HTML Syntax Example</title>
    <link rel="stylesheet" href="styles.css">
    <script defer src="main.js"></script>
</head>

<body>
    <!-- Header section with navigation -->
    <header class="main-header" role="banner">
        <nav class="main-nav" aria-label="Main navigation">
            <ul class="nav-list">
                <li><a href="#home" class="nav-link active">Home</a></li>
                <li><a href="#about" class="nav-link">About</a></li>
                <li><a href="#contact" class="nav-link">Contact</a></li>
            </ul>
        </nav>
    </header>

    <!-- Main content area -->
    <main id="main-content" role="main">
        <!-- Hero section -->
        <section class="hero" aria-labelledby="hero-title">
            <h1 id="hero-title">Welcome to Our Site</h1>
            <p class="lead">This is an example of semantic HTML structure.</p>
        </section>

        <!-- Article with sections -->
        <article class="content-article">
            <header>
                <h2>Main Article</h2>
                <p class="article-meta">Published on <time datetime="2024-02-20">February 20, 2024</time></p>
            </header>

            <section class="article-section">
                <h3>Section One</h3>
                <p>This section demonstrates text content with <em>emphasis</em> and <strong>strong importance</strong>.</p>
                <figure>
                    <img src="example.jpg" alt="Example image" width="600" height="400">
                    <figcaption>An example image with caption</figcaption>
                </figure>
            </section>

            <section class="article-section">
                <h3>Interactive Elements</h3>
                <!-- Form example -->
                <form class="contact-form" action="/submit" method="POST">
                    <fieldset>
                        <legend>Contact Information</legend>
                        
                        <div class="form-group">
                            <label for="name">Name:</label>
                            <input type="text" id="name" name="name" required 
                                   placeholder="Enter your name">
                        </div>

                        <div class="form-group">
                            <label for="email">Email:</label>
                            <input type="email" id="email" name="email" required 
                                   placeholder="Enter your email">
                        </div>

                        <div class="form-group">
                            <label for="message">Message:</label>
                            <textarea id="message" name="message" rows="4" 
                                    placeholder="Your message"></textarea>
                        </div>

                        <button type="submit" class="btn btn-primary">Send Message</button>
                    </fieldset>
                </form>
            </section>

            <!-- Table example -->
            <section class="article-section">
                <h3>Data Table</h3>
                <table class="data-table">
                    <caption>Monthly Sales Data</caption>
                    <thead>
                        <tr>
                            <th scope="col">Month</th>
                            <th scope="col">Sales</th>
                            <th scope="col">Growth</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <th scope="row">January</th>
                            <td>$10,000</td>
                            <td>5%</td>
                        </tr>
                        <tr>
                            <th scope="row">February</th>
                            <td>$12,000</td>
                            <td>20%</td>
                        </tr>
                    </tbody>
                    <tfoot>
                        <tr>
                            <th scope="row">Total</th>
                            <td>$22,000</td>
                            <td>25%</td>
                        </tr>
                    </tfoot>
                </table>
            </section>
        </article>

        <!-- Aside content -->
        <aside class="sidebar" role="complementary">
            <h2>Related Information</h2>
            <div class="widget">
                <h3>Categories</h3>
                <ul class="category-list">
                    <li><a href="#tech">Technology</a></li>
                    <li><a href="#design">Design</a></li>
                    <li><a href="#business">Business</a></li>
                </ul>
            </div>
        </aside>
    </main>

    <!-- Footer section -->
    <footer class="site-footer" role="contentinfo">
        <div class="footer-content">
            <p>&copy; 2024 Example Site. All rights reserved.</p>
            <address>
                Contact us at: <a href="mailto:info@example.com">info@example.com</a>
            </address>
        </div>
    </footer>

    <!-- Dialog for modal content -->
    <dialog id="modal" class="modal">
        <header>
            <h2>Modal Title</h2>
            <button type="button" class="close-button" aria-label="Close modal">×</button>
        </header>
        <div class="modal-content">
            <p>This is an example of the dialog element for modal content.</p>
        </div>
        <footer>
            <button type="button" class="btn">Close</button>
        </footer>
    </dialog>
</body>
</html>


================================================
FILE: app/server/syntax/file_map/examples/java_example.java
================================================
package example;

import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.stream.*;
import java.time.*;

// Generic interface with type bounds
interface DataProcessor<T extends Comparable<T>> {
    CompletableFuture<T> processAsync(T input);
    boolean validate(T input);
}

// Enum with methods and fields
enum Status {
    PENDING("P"),
    ACTIVE("A"),
    COMPLETED("C"),
    FAILED("F");

    private final String code;

    Status(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }
}

// Abstract class with generic type
abstract class BaseEntity<ID> {
    protected ID id;
    protected LocalDateTime createdAt;
    protected LocalDateTime updatedAt;

    public abstract void validate();
}

// Record type (Java 16+)
record UserDTO(
    String name,
    String email,
    Set<String> roles
) {}

// Annotation definition
@interface Audited {
    String value() default "";
    boolean required() default true;
}

// Main class with various Java features
public class Example extends BaseEntity<UUID> implements DataProcessor<String> {
    // Static fields and initialization block
    private static final int MAX_RETRIES = 3;
    private static final Map<String, Integer> CACHE;
    
    static {
        CACHE = new ConcurrentHashMap<>();
    }

    // Instance fields with different access modifiers
    private final Queue<String> queue;
    protected Status status;
    @Audited
    public String name;

    // Constructor with builder pattern
    private Example(Builder builder) {
        this.queue = new LinkedBlockingQueue<>();
        this.status = Status.PENDING;
        this.name = builder.name;
    }

    // Builder static class
    public static class Builder {
        private String name;

        public Builder name(String name) {
            this.name = name;
            return this;
        }

        public Example build() {
            return new Example(this);
        }
    }

    // Interface implementation
    @Override
    public CompletableFuture<String> processAsync(String input) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                queue.offer(input);
                return input.toUpperCase();
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        });
    }

    @Override
    public boolean validate(String input) {
        return input != null && !input.isEmpty();
    }

    // Abstract method implementation
    @Override
    public void validate() {
        if (name == null || name.isEmpty()) {
            throw new IllegalStateException("Name is required");
        }
    }

    // Generic method with wildcards
    public <T extends Comparable<? super T>> List<T> sort(Collection<T> items) {
        return items.stream()
                   .sorted()
                   .collect(Collectors.toList());
    }

    // Method with functional interfaces
    public void processItems(
        List<String> items,
        Predicate<String> filter,
        Consumer<String> processor
    ) {
        items.stream()
             .filter(filter)
             .forEach(processor);
    }

    // Exception class
    public static class ProcessingException extends RuntimeException {
        public ProcessingException(String message) {
            super(message);
        }
    }

    // Main method demonstrating usage
    public static void main(String[] args) {
        var example = new Builder()
            .name("Test Example")
            .build();

        // Lambda and method reference usage
        List<String> items = Arrays.asList("a", "b", "c");
        example.processItems(
            items,
            String::isEmpty,
            System.out::println
        );

        // Stream API usage
        Map<Status, Long> statusCounts = items.stream()
            .map(s -> Status.PENDING)
            .collect(Collectors.groupingBy(
                status -> status,
                Collectors.counting()
            ));

        // CompletableFuture with exception handling
        example.processAsync("test")
              .thenApply(String::toLowerCase)
              .exceptionally(throwable -> {
                  System.err.println("Error: " + throwable.getMessage());
                  return "";
              });

        // Try-with-resources and Optional usage
        try (var scanner = new Scanner(System.in)) {
            Optional.of(scanner.nextLine())
                    .filter(example::validate)
                    .ifPresent(example::processAsync);
        }
    }
}


================================================
FILE: app/server/syntax/file_map/examples/javascript_example.js
================================================
// ES Module imports
import { EventEmitter } from 'events';
import { promisify } from 'util';

// Global constants
const MAX_RETRIES = 3;
const DEFAULT_TIMEOUT = 5000;

// Symbol for private properties
const privateState = Symbol('privateState');

// Class using ES6+ features
class DataProcessor extends EventEmitter {
    // Private class field
    #cache = new Map();
    
    // Static class field
    static version = '1.0.0';
    
    // Constructor with parameter destructuring
    constructor({ maxRetries = MAX_RETRIES, timeout = DEFAULT_TIMEOUT } = {}) {
        super();
        this[privateState] = { maxRetries, timeout };
    }
    
    // Async method with error handling
    async processData(data) {
        try {
            const result = await this.#validateAndTransform(data);
            this.emit('processed', result);
            return result;
        } catch (error) {
            this.emit('error', error);
            throw error;
        }
    }
    
    // Private method
    async #validateAndTransform(data) {
        if (!data) throw new Error('Data is required');
        return { ...data, timestamp: Date.now() };
    }
    
    // Generator method
    *iterateCache() {
        for (const [key, value] of this.#cache) {
            yield { key, value };
        }
    }
}


// Decorator function (stage 3 proposal)
function deprecated(target, context) {
    if (context.kind === 'method') {
        const originalMethod = target;
        return function(...args) {
            console.warn(`Warning: ${context.name} is deprecated`);
            return originalMethod.apply(this, args);
        };
    }
}

// Proxy example
const handler = {
    get(target, prop) {
        return prop in target ? target[prop] : 'Property not found';
    }
};

const proxy = new Proxy({}, handler);

// Promise-based utility function
const delay = ms => new Promise(resolve => setTimeout(resolve, ms));

// Async generator function
async function* generateSequence(start, end) {
    for (let i = start; i <= end; i++) {
        await delay(100);
        yield i;
    }
}

// Higher-order function
const memoize = (fn) => {
    const cache = new Map();
    return (...args) => {
        const key = JSON.stringify(args);
        if (cache.has(key)) return cache.get(key);
        const result = fn.apply(this, args);
        cache.set(key, result);
        return result;
    };
};

// Custom error class
class ValidationError extends Error {
    constructor(message, field) {
        super(message);
        this.name = 'ValidationError';
        this.field = field;
    }
}

// Object with getter/setter
const config = {
    _theme: 'light',
    get theme() {
        return this._theme;
    },
    set theme(value) {
        if (!['light', 'dark'].includes(value)) {
            throw new ValidationError('Invalid theme', 'theme');
        }
        this._theme = value;
    }
};

// Array methods and destructuring
const processItems = (items) => {
    const [first, ...rest] = items;
    return rest
        .filter(item => item != null)
        .map(item => ({ ...item, processed: true }))
        .reduce((acc, curr) => {
            acc[curr.id] = curr;
            return acc;
        }, {});
};

// Async/await with Promise.all
const fetchData = async (urls) => {
    try {
        const responses = await Promise.all(
            urls.map(url => fetch(url).then(res => res.json()))
        );
        return responses;
    } catch (error) {
        console.error('Failed to fetch data:', error);
        throw error;
    }
};

// Export statement
export {
    DataProcessor,
    ValidationError,
    processItems,
    fetchData,
    delay,
    memoize,
    config
};


================================================
FILE: app/server/syntax/file_map/examples/kotlin_example.kt
================================================
// Package declaration
package example

// Imports
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import java.time.LocalDateTime
import kotlin.properties.Delegates

// Interface with generic type parameter
interface DataProcessor<T> {
    suspend fun process(data: T): Result<T>
    fun validate(data: T): Boolean
}

// Sealed class for representing states
sealed class ProcessingState<out T> {
    object Loading : ProcessingState<Nothing>()
    data class Success<T>(val data: T) : ProcessingState<T>()
    data class Error(val exception: Throwable) : ProcessingState<Nothing>()
}

// Data class with default parameters
data class User(
    val id: String,
    val name: String,
    val email: String,
    val roles: Set<Role> = emptySet(),
    val createdAt: LocalDateTime = LocalDateTime.now()
)

// Enum class with properties and function
enum class Role(val permission: Int) {
    ADMIN(0xFF) {
        override fun toString() = "Administrator"
    },
    USER(0x0F) {
        override fun toString() = "Regular User"
    },
    GUEST(0x00) {
        override fun toString() = "Guest User"
    }
}

// Object declaration (Singleton)
object Configuration {
    const val API_VERSION = "1.0.0"
    val defaultTimeout = 5000L
    
    fun getConfig(key: String) = config[key]
    
    private val config = mutableMapOf<String, Any>()
}

// Class with companion object and delegation
class UserProcessor : DataProcessor<User> {
    // Companion object with factory method
    companion object {
        fun create(): UserProcessor = UserProcessor()
    }
    
    // Property delegation
    private var processingCount: Int by Delegates.observable(0) { _, old, new ->
        println("Processing count changed from $old to $new")
    }
    
    // Property with custom getter
    val isActive: Boolean
        get() = processingCount > 0
    
    // Suspending function implementation
    override suspend fun process(data: User): Result<User> = runCatching {
        processingCount++
        validateEmail(data.email)
        data
    }.also {
        processingCount--
    }
    
    // Regular function implementation
    override fun validate(data: User): Boolean =
        data.email.isNotBlank() && data.name.isNotBlank()
    
    // Extension function
    private fun String.isValidEmail(): Boolean =
        matches(Regex("^[A-Za-z0-9+_.-]+@(.+)$"))
    
    // Inline function with reified type parameter
    inline fun <reified T> logType() =
        println("Processing type: ${T::class.simpleName}")
    
    // Private function using extension function
    private fun validateEmail(email: String) {
        require(email.isValidEmail()) { "Invalid email format" }
    }
}

// Higher-order function with function type parameter
fun <T> withRetry(
    times: Int = 3,
    action: suspend () -> T
): suspend () -> T = {
    var lastException: Exception? = null
    repeat(times) { attempt ->
        try {
            return@withRetry action()
        } catch (e: Exception) {
            lastException = e
            println("Attempt ${attempt + 1} failed: ${e.message}")
        }
    }
    throw lastException ?: IllegalStateException("All attempts failed")
}

// Coroutine scope extension
fun CoroutineScope.processUsers(users: List<User>): Flow<ProcessingState<User>> = flow {
    val processor = UserProcessor.create()
    
    emit(ProcessingState.Loading)
    
    users.forEach { user ->
        processor.process(user)
            .onSuccess { emit(ProcessingState.Success(it)) }
            .onFailure { emit(ProcessingState.Error(it)) }
    }
}

// Extension property
val User.displayName: String
    get() = "$name (${email})"

// Main function demonstrating usage
suspend fun main() = coroutineScope {
    val users = listOf(
        User("1", "John Doe", "john@example.com"),
        User("2", "Jane Smith", "jane@example.com", setOf(Role.ADMIN))
    )
    
    launch {
        processUsers(users)
            .collect { state ->
                when (state) {
                    is ProcessingState.Loading -> println("Processing started")
                    is ProcessingState.Success -> println("Processed: ${state.data.displayName}")
                    is ProcessingState.Error -> println("Error: ${state.exception.message}")
                }
            }
    }
}


================================================
FILE: app/server/syntax/file_map/examples/lua_example.lua
================================================
-- Module definition
local Example = {}

-- Constants
local MAX_RETRIES = 3
local DEFAULT_TIMEOUT = 5000

-- Private functions (local)
local function validateInput(input)
    if type(input) ~= "string" then
        error("Input must be a string")
    end
    return true
end

-- Metatable for creating classes
local function createClass(name)
    local cls = {}
    cls.__index = cls
    cls.__name = name
    
    -- Constructor
    function cls.new(...)
        local self = setmetatable({}, cls)
        if self.init then
            self:init(...)
        end
        return self
    end
    
    return cls
end

-- Class definition using metatables
local User = createClass("User")

function User:init(name, age)
    self.name = name
    self.age = age
    self.created_at = os.time()
end

function User:toString()
    return string.format("User(%s, %d)", self.name, self.age)
end

-- Table with custom metamethods
local DataStore = {
    data = {},
    __newindex = function(t, k, v)
        print("Setting value:", k, v)
        rawset(t.data, k, v)
    end,
    __index = function(t, k)
        return t.data[k]
    end
}
setmetatable(DataStore, DataStore)

-- Coroutine example
local function producer()
    return coroutine.create(function()
        for i = 1, 5 do
            coroutine.yield(i)
        end
    end)
end

-- Iterator function
local function range(from, to, step)
    step = step or 1
    local i = from - step
    return function()
        i = i + step
        if i <= to then
            return i
        end
    end
end

-- Module functions
function Example.process(input)
    assert(validateInput(input))
    
    local result = {
        original = input,
        processed = string.upper(input),
        timestamp = os.time()
    }
    
    return result
end

-- Function with multiple returns
function Example.divide(a, b)
    if b == 0 then
        return nil, "Division by zero"
    end
    return a / b
end

-- Closure example
function Example.counter(initial)
    local count = initial or 0
    return function()
        count = count + 1
        return count
    end
end

-- Table manipulation
function Example.merge(t1, t2)
    local result = {}
    for k, v in pairs(t1) do
        result[k] = v
    end
    for k, v in pairs(t2) do
        result[k] = v
    end
    return result
end

-- Pattern matching example
function Example.extractEmails(text)
    local emails = {}
    for email in string.gmatch(text, "[%w%.%-_]+@[%w%.%-_]+%.%w+") do
        table.insert(emails, email)
    end
    return emails
end

-- Event handling system
local EventEmitter = createClass("EventEmitter")

function EventEmitter:init()
    self.handlers = {}
end

function EventEmitter:on(event, handler)
    self.handlers[event] = self.handlers[event] or {}
    table.insert(self.handlers[event], handler)
end

function EventEmitter:emit(event, ...)
    if self.handlers[event] then
        for _, handler in ipairs(self.handlers[event]) do
            handler(...)
        end
    end
end

-- Add classes to module
Example.User = User
Example.EventEmitter = EventEmitter

-- Module return
return Example


================================================
FILE: app/server/syntax/file_map/examples/markdown_example.md
================================================
# SoundScape 🎵

An AI-powered music visualization and generation platform that creates real-time visual art from audio input.

## Features ✨

- Real-time audio processing using WebAudio API
- Dynamic visualization generation using Three.js
- AI-powered music analysis for enhanced visual mapping
- Multiple visualization styles (geometric, particle, liquid simulation)
- Audio recording and export capabilities
- Collaborative mode for live performances

## Getting Started 🚀

### Prerequisites

- Node.js (v18 or higher)
- GPU with WebGL 2.0 support
- Microphone access (for live input)

### Installation

1. Clone the repository:
```bash
git clone https://github.com/yourusername/soundscape.git
cd soundscape
```

2. Install dependencies:
```bash
npm install
```

3. Start the development server:
```bash
npm run dev
```

The application will be available at `http://localhost:3000`

## Architecture 🏗️

SoundScape uses a modular architecture with the following core components:

- **AudioEngine**: Handles audio input processing and analysis
- **VisualizationCore**: Manages the 3D rendering pipeline
- **AIProcessor**: Processes audio features for enhanced visualization
- **StateManager**: Handles application state and user preferences

## API Reference 📚

### Audio Processing

```typescript
interface AudioProcessor {
  analyze(input: AudioBuffer): AudioFeatures;
  extractBeat(features: AudioFeatures): BeatPattern;
  generateVisuals(pattern: BeatPattern): Scene;
}
```

### Visualization

```typescript
interface VisualizationStyle {
  name: string;
  parameters: VisualParameters;
  render(scene: Scene): void;
  updateParams(params: Partial<VisualParameters>): void;
}
```

## Contributing 🤝

We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING.md) before submitting a pull request.

### Development Workflow

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## Performance Optimization Tips 💡

- Use Web Workers for heavy audio processing
- Implement lazy loading for visualization styles
- Enable GPU acceleration when available
- Cache frequently used audio features
- Optimize render loops for smooth performance

## License 📄

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Acknowledgments 🙏

- Three.js community for 3D rendering support
- TensorFlow.js team for machine learning capabilities
- Web Audio API working group
- All our amazing contributors

## Contact 📧

Project Lead - [@projectlead](https://twitter.com/projectlead)

Project Link: [https://github.com/yourusername/soundscape](https://github.com/yourusername/soundscape)

---

Made with ❤️ by the SoundScape Team

================================================
FILE: app/server/syntax/file_map/examples/ocaml_example.ml
================================================
(* Module signature *)
module type DataProcessor = sig
  type 'a t
  val create : unit -> 'a t
  val process : 'a t -> 'a -> ('a, string) result
  val validate : 'a -> bool
end

(* Module implementation *)
module StringProcessor : DataProcessor with type 'a = string = struct
type 'a = string
  type t = {
    mutable processed_count: int;
    created_at: float;
  }

  let create () = {
    processed_count = 0;
    created_at = Unix.time ();
  }

  let process t input =
    t.processed_count <- t.processed_count + 1;
    if String.length input > 0 then
      Ok (String.uppercase_ascii input)
    else
      Error "Empty input"

  let validate input =
    String.length input > 0
end

(* Type definitions *)
type user = {
  id: int;
  name: string;
  email: string;
  created_at: float;
}

type 'a result = 
  | Success of 'a 
  | Error of string

(* Variant type *)
type message =
  | Text of string
  | Number of int
  | Tuple of string * int
  | Record of user

(* Functor definition *)
module type Comparable = sig
  type t
  val compare : t -> t -> int
end

module MakeSet (Item : Comparable) = struct
  type element = Item.t
  type t = element list

  let empty = []
  
  let rec add x = function
    | [] -> [x]
    | hd :: tl as l ->
        match Item.compare x hd with
        | 0 -> l
        | n when n < 0 -> x :: l
        | _ -> hd :: add x tl

  let member x set =
    List.exists (fun y -> Item.compare x y = 0) set
end

(* Exception definition *)
exception ValidationError of string

(* Higher-order function *)
let memoize f =
  let cache = Hashtbl.create 16 in
  fun x ->
    try Hashtbl.find cache x
    with Not_found ->
      let result = f x in
      Hashtbl.add cache x result;
      result

(* Object-oriented features *)
class virtual ['a] queue = object(self)
  val mutable items = []
  
  method virtual push : 'a -> unit
  method virtual pop : 'a option
  
  method size = List.length items
  
  method is_empty = items = []
  
  method protected get_items = items
  method protected set_items new_items = items <- new_items
end

class ['a] fifo_queue = object(self)
  inherit ['a] queue

  method push item =
    self#set_items (self#get_items @ [item])

  method pop =
    match self#get_items with
    | [] -> None
    | hd::tl ->
        self#set_items tl;
        Some hd
end

(* Module for handling JSON-like data *)
module Json = struct
  type t =
    | Null
    | Bool of bool
    | Number of float
    | String of string
    | Array of t list
    | Object of (string * t) list

  let rec to_string = function
    | Null -> "null"
    | Bool b -> string_of_bool b
    | Number n -> string_of_float n
    | String s -> "\"" ^ String.escaped s ^ "\""
    | Array items ->
        "[" ^ String.concat ", " (List.map to_string items) ^ "]"
    | Object pairs ->
        let pair_to_string (k, v) =
          "\"" ^ String.escaped k ^ "\": " ^ to_string v
        in
        "{" ^ String.concat ", " (List.map pair_to_string pairs) ^ "}"
end

(* Main execution *)
let () =
  let processor = StringProcessor.create () in
  let result = StringProcessor.process processor "hello world" in
  match result with
  | Ok processed -> Printf.printf "Processed: %s\n" processed
  | Error msg -> Printf.eprintf "Error: %s\n" msg;

  let queue = new fifo_queue in
  queue#push 1;
  queue#push 2;
  queue#push 3;
  
  let rec print_queue () =
    match queue#pop with
    | Some item -> 
        Printf.printf "Item: %d\n" item;
        print_queue ()
    | None -> ()
  in
  print_queue ()




================================================
FILE: app/server/syntax/file_map/examples/php_example.php
================================================
<?php

declare(strict_types=1);

namespace Example;

use DateTime;
use Exception;
use InvalidArgumentException;
use JsonSerializable;
use Psr\Log\LoggerInterface;

// Interface definition
interface DataProcessor
{
    public function process(mixed $data): mixed;
    public function validate(mixed $data): bool;
}

// Trait definition
trait Loggable
{
    protected ?LoggerInterface $logger = null;

    public function setLogger(LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }

    protected function log(string $message, array $context = []): void
    {
        $this->logger?->info($message, $context);
    }
}

// Abstract class
abstract class Entity implements JsonSerializable
{
    protected DateTime $createdAt;
    protected ?DateTime $updatedAt = null;

    public function __construct()
    {
        $this->createdAt = new DateTime();
    }

    abstract public function validate(): bool;

    public function jsonSerialize(): mixed
    {
        return [
            'createdAt' => $this->createdAt->format('c'),
            'updatedAt' => $this->updatedAt?->format('c'),
        ];
    }
}

// Enum definition (PHP 8.1+)
enum Status: string
{
    case PENDING = 'pending';
    case ACTIVE = 'active';
    case COMPLETED = 'completed';
    case FAILED = 'failed';

    public function label(): string
    {
        return match($this) {
            self::PENDING => 'Pending',
            self::ACTIVE => 'Active',
            self::COMPLETED => 'Completed',
            self::FAILED => 'Failed',
        };
    }
}

// Class implementing interface and using trait
class User extends Entity implements DataProcessor
{
    use Loggable;

    private static int $instanceCount = 0;

    public function __construct(
        private string $name,
        private string $email,
        private Status $status = Status::PENDING,
        private array $metadata = []
    ) {
        parent::__construct();
        self::$instanceCount++;
    }

    public static function getInstanceCount(): int
    {
        return self::$instanceCount;
    }

    // Property getter with validation
    public function getEmail(): string
    {
        return $this->email;
    }

    // Property setter with validation
    public function setEmail(string $email): void
    {
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException('Invalid email format');
        }
        $this->email = $email;
        $this->updatedAt = new DateTime();
    }

    // Magic method implementation
    public function __get(string $name)
    {
        return $this->metadata[$name] ?? null;
    }

    public function __set(string $name, mixed $value): void
    {
        $this->metadata[$name] = $value;
    }

    // Interface method implementations
    public function process(mixed $data): mixed
    {
        if (!is_array($data)) {
            throw new InvalidArgumentException('Data must be an array');
        }

        $this->log('Processing user data', ['user' => $this->name]);

        foreach ($data as $key => $value) {
            $this->metadata[$key] = $value;
        }

        $this->status = Status::COMPLETED;
        return $this;
    }

    public function validate(mixed $data): bool
    {
        return is_array($data) && !empty($data);
    }

    // Abstract method implementation
    public function validate(): bool
    {
        return !empty($this->name) && !empty($this->email);
    }

    // Method using arrow functions (PHP 7.4+)
    public function getMetadataValues(): array
    {
        return array_map(
            fn($value) => is_array($value) ? json_encode($value) : (string)$value,
            $this->metadata
        );
    }

    // Implementation of JsonSerializable
    public function jsonSerialize(): mixed
    {
        return [
            ...parent::jsonSerialize(),
            'name' => $this->name,
            'email' => $this->email,
            'status' => $this->status->value,
            'metadata' => $this->metadata,
        ];
    }
}

// Custom exception
class ProcessingException extends Exception
{
    public function __construct(
        string $message = "",
        private ?string $errorCode = null,
        int $code = 0,
        ?Throwable $previous = null
    ) {
        parent::__construct($message, $code, $previous);
    }

    public function getErrorCode(): ?string
    {
        return $this->errorCode;
    }
}

// Anonymous class usage
$validator = new class {
    public function validateUser(User $user): bool
    {
        return $user->validate();
    }
};

// Example usage
try {
    $user = new User("John Doe", "john@example.com");
    $user->process(['role' => 'admin', 'preferences' => ['theme' => 'dark']]);
    
    // Using magic methods
    $user->customField = 'custom value';
    echo $user->customField;
    
    // JSON serialization
    echo json_encode($user, JSON_PRETTY_PRINT);
    
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}


================================================
FILE: app/server/syntax/file_map/examples/protobuf_example.proto
================================================
syntax = "proto3";

package example;

import "google/protobuf/timestamp.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/wrappers.proto";

option go_package = "example/generated";
option java_package = "com.example.generated";
option java_multiple_files = true;

// Enum definition
enum Status {
  STATUS_UNSPECIFIED = 0;
  STATUS_PENDING = 1;
  STATUS_ACTIVE = 2;
  STATUS_COMPLETED = 3;
  STATUS_FAILED = 4;
}

// Message with nested messages and various field types
message User {
  // Nested message definition
  message Address {
    string street = 1;
    string city = 2;
    string state = 3;
    string country = 4;
    string postal_code = 5;
  }

  // Nested enum
  enum Role {
    ROLE_UNSPECIFIED = 0;
    ROLE_ADMIN = 1;
    ROLE_USER = 2;
    ROLE_GUEST = 3;
  }

  // Fields with different types and options
  string id = 1;
  string name = 2 [(validate.rules).string = {
    min_len: 1,
    max_len: 100
  }];
  string email = 3 [(validate.rules).string.email = true];
  repeated string phone_numbers = 4;
  Role role = 5;
  Status status = 6;
  Address primary_address = 7;
  repeated Address additional_addresses = 8;
  map<string, string> metadata = 9;
  google.protobuf.Timestamp created_at = 10;
  google.protobuf.Timestamp updated_at = 11;
  oneof verification {
    string phone_verification = 12;
    string email_verification = 13;
  }
}

// Message using various repeated and map fields
message UserList {
  repeated User users = 1;
  int32 total_count = 2;
  string next_page_token = 3;
}

// Request/Response messages
message CreateUserRequest {
  User user = 1;
}

message UpdateUserRequest {
  string user_id = 1;
  User user = 2;
  google.protobuf.FieldMask update_mask = 3;
}

message GetUserRequest {
  string user_id = 1;
}

message DeleteUserRequest {
  string user_id = 1;
}

message ListUsersRequest {
  int32 page_size = 1;
  string page_token = 2;
  string filter = 3;
}

// Service definition with various RPC patterns
service UserService {
  // Unary RPC
  rpc CreateUser(CreateUserRequest) returns (User);
  
  // Unary RPC with custom error responses
  rpc GetUser(GetUserRequest) returns (User);
  
  // Unary RPC with field mask
  rpc UpdateUser(UpdateUserRequest) returns (User);
  
  // Unary RPC returning empty response
  rpc DeleteUser(DeleteUserRequest) returns (google.protobuf.Empty);
  
  // Server streaming RPC
  rpc ListUsers(ListUsersRequest) returns (stream User);
  
  // Client streaming RPC
  rpc BatchCreateUsers(stream CreateUserRequest) returns (UserList);
  
  // Bidirectional streaming RPC
  rpc ProcessUsers(stream User) returns (stream User);
}


================================================
FILE: app/server/syntax/file_map/examples/python_example.py
================================================
#!/usr/bin/env python3
from __future__ import annotations

import asyncio
import dataclasses
import enum
from abc import ABC, abstractmethod
from datetime import datetime
from functools import wraps
from typing import (
    Any, AsyncIterator, Callable, ClassVar, Dict, Generic, 
    List, Optional, Protocol, TypeVar, Union
)

# Type variable definitions
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')

# Protocol definition
class Processable(Protocol):
    def process(self) -> None: ...
    def validate(self) -> bool: ...

# Enum definition
class Status(enum.Enum):
    PENDING = "pending"
    ACTIVE = "active"
    COMPLETED = "completed"
    FAILED = "failed"

    def __str__(self) -> str:
        return self.value

# Dataclass with frozen and slots options
@dataclasses.dataclass(frozen=True, slots=True)
class UserCredentials:
    username: str
    email: str
    created_at: datetime = dataclasses.field(default_factory=datetime.now)

# Abstract base class
class BaseProcessor(ABC, Generic[T]):
    def __init__(self) -> None:
        self._items: List[T] = []
        self._processed_count: int = 0

    @abstractmethod
    async def process_item(self, item: T) -> None:
        pass

    @property
    def processed_count(self) -> int:
        return self._processed_count

# Decorator definition
def log_execution(func: Callable) -> Callable:
    @wraps(func)
    async def wrapper(*args: Any, **kwargs: Any) -> Any:
        print(f"Executing {func.__name__}")
        try:
            result = await func(*args, **kwargs)
            print(f"Completed {func.__name__}")
            return result
        except Exception as e:
            print(f"Error in {func.__name__}: {e}")
            raise
    return wrapper

# Class implementing abstract base class and protocol
class DataProcessor(BaseProcessor[UserCredentials], Processable):
    # Class variable
    DEFAULT_BATCH_SIZE: ClassVar[int] = 100

    def __init__(self, batch_size: Optional[int] = None) -> None:
        super().__init__()
        self.batch_size = batch_size or self.DEFAULT_BATCH_SIZE
        self._status = Status.PENDING

    # Property with getter and setter
    @property
    def status(self) -> Status:
        return self._status

    @status.setter
    def status(self, value: Status) -> None:
        if not isinstance(value, Status):
            raise ValueError("Status must be a Status enum value")
        self._status = value

    # Context manager methods
    async def __aenter__(self) -> DataProcessor:
        self.status = Status.ACTIVE
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
        self.status = Status.COMPLETED if exc_type is None else Status.FAILED

    # Generator method
    async def process_batch(self) -> AsyncIterator[List[UserCredentials]]:
        for i in range(0, len(self._items), self.batch_size):
            batch = self._items[i:i + self.batch_size]
            yield batch
            await asyncio.sleep(0.1)

    # Implementation of abstract method
    @log_execution
    async def process_item(self, item: UserCredentials) -> None:
        if not self.validate():
            raise ValueError("Processor is not in a valid state")
        self._items.append(item)
        self._processed_count += 1

    # Implementation of protocol method
    def process(self) -> None:
        if not self._items:
            raise ValueError("No items to process")
        self.status = Status.ACTIVE

    def validate(self) -> bool:
        return self.status != Status.FAILED

# Custom exception
class ProcessingError(Exception):
    def __init__(self, message: str, item: Any) -> None:
        self.item = item
        super().__init__(f"Error processing {item}: {message}")

# Async main function
async def main() -> None:
    async with DataProcessor(batch_size=10) as processor:
        # Create test data
        user = UserCredentials(
            username="test_user",
            email="test@example.com"
        )

        try:
            await processor.process_item(user)
            
            async for batch in processor.process_batch():
                print(f"Processing batch of {len(batch)} items")
                
        except ProcessingError as e:
            print(f"Processing failed: {e}")

if __name__ == "__main__":
    asyncio.run(main())


================================================
FILE: app/server/syntax/file_map/examples/ruby_example.rb
================================================
#!/usr/bin/env ruby

global_var = "Hello, World!"

# Module for mixing in common functionality
module Loggable
  def log(message)
    puts "[#{Time.now}] #{message}"
  end
end

# Module with class methods
module Utils
  class << self
    def generate_id
      SecureRandom.uuid
    end
  end
end

# Abstract base class
class BaseProcessor
  include Loggable

  # Class instance variable
  @processors = []

  class << self
    attr_reader :processors

    def register(processor)
      @processors << processor
    end
  end

  # Instance variables with attr accessors
  attr_reader :id, :created_at
  attr_accessor :status

  def initialize
    @id = Utils.generate_id
    @created_at = Time.now
    @status = :pending
    self.class.register(self)
  end

  # Abstract method
  def process
    raise NotImplementedError, "#{self.class} must implement process"
  end
end

# Custom exception class
class ProcessingError < StandardError
  attr_reader :item

  def initialize(message, item)
    @item = item
    super(message)
  end
end

# Struct definition
User = Struct.new(:name, :email, keyword_init: true) do
  def valid?
    name && email && email.include?('@')
  end
end

# Enum-like module using freeze
module Status
  PENDING = 'pending'.freeze
  ACTIVE = 'active'.freeze
  COMPLETED = 'completed'.freeze
  FAILED = 'failed'.freeze

  ALL = [PENDING, ACTIVE, COMPLETED, FAILED].freeze
end

# Class using inheritance and mixins
class DataProcessor < BaseProcessor
  # Constants
  MAX_RETRIES = 3
  DEFAULT_TIMEOUT = 5

  # Class variable
  @@instance_count = 0

  def self.instance_count
    @@instance_count
  end

  def initialize(options = {})
    super()
    @options = options
    @items = []
    @@instance_count += 1
  end

  # Method with keyword arguments and default value
  def add_item(item:, priority: :normal)
    validate_item(item)
    @items << [item, priority]
  end

  # Private methods
  private

  def validate_item(item)
    raise ArgumentError, "Invalid item" unless item.respond_to?(:valid?)
    raise ProcessingError.new("Invalid item", item) unless item.valid?
  end

  # Method using block
  def with_retry
    retries = 0
    begin
      yield
    rescue StandardError => e
      retries += 1
      retry if retries < MAX_RETRIES
      raise
    end
  end

  # Method using lambda
  def process_items
    sorter = ->(a, b) { a[1] <=> b[1] }
    @items.sort(&sorter).each do |item, _priority|
      process_item(item)
    end
  end

  protected

  def process_item(item)
    log("Processing item: #{item}")
    # Processing logic here
  end
end

# Singleton class
require 'singleton'
class Configuration
  include Singleton

  def initialize
    @settings = {}
  end

  def [](key)
    @settings[key]
  end

  def []=(key, value)
    @settings[key] = value
  end
end

# Example usage
if __FILE__ == $PROGRAM_NAME
  config = Configuration.instance
  config[:timeout] = 30

  processor = DataProcessor.new(timeout: config[:timeout])
  user = User.new(name: "John Doe", email: "john@example.com")

  begin
    processor.add_item(item: user, priority: :high)
    processor.process
  rescue ProcessingError => e
    puts "Failed to process #{e.item}: #{e.message}"
  end
end


================================================
FILE: app/server/syntax/file_map/examples/rust_example.rs
================================================
use std::{
    collections::{HashMap, HashSet},
    sync::{Arc, Mutex},
    time::{Duration, SystemTime},
};

use tokio::sync::mpsc;
use serde::{Deserialize, Serialize};

// Type alias
type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;

// Constants
const MAX_RETRIES: u32 = 3;
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(5);

// Custom error type
#[derive(Debug, thiserror::Error)]
pub enum ProcessError {
    #[error("Validation failed: {0}")]
    ValidationError(String),
    
    #[error("Processing failed: {0}")]
    ProcessingError(String),
    
    #[error(transparent)]
    Other(#[from] Box<dyn std::error::Error + Send + Sync>),
}

// Trait definition
#[async_trait::async_trait]
pub trait DataProcessor<T> {
    async fn process(&self, data: T) -> Result<T>;
    fn validate(&self, data: &T) -> bool;
}

// Struct with lifetime parameter and generic type
#[derive(Debug)]
pub struct ProcessorState<'a, T> {
    name: &'a str,
    data: T,
    created_at: SystemTime,
}

// Enum with different variants
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Status {
    Pending,
    Active { started_at: SystemTime },
    Completed { result: String },
    Failed { error: String },
}

// Struct implementing trait
pub struct ItemProcessor {
    items: Arc<Mutex<HashSet<String>>>,
    status: Status,
    tx: mpsc::Sender<String>,
}

// Trait implementation
#[async_trait::async_trait]
impl DataProcessor<String> for ItemProcessor {
    async fn process(&self, data: String) -> Result<String> {
        if !self.validate(&data) {
            return Err(Box::new(ProcessError::ValidationError("Invalid data".into())));
        }
        Ok(data.to_uppercase())
    }

    fn validate(&self, data: &String) -> bool {
        !data.is_empty()
    }
}

// Struct with derive macros
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    pub name: String,
    pub max_items: usize,
    #[serde(default)]
    pub timeout: Option<Duration>,
}


// Implementation with associated types
pub trait Storage {
    type Item;
    type Error;

    fn store(&mut self, item: Self::Item) -> std::result::Result<(), Self::Error>;
    fn retrieve(&self, id: &str) -> std::result::Result<Option<Self::Item>, Self::Error>;
}

// Struct implementing trait with associated types
pub struct MemoryStorage {
    data: HashMap<String, Vec<u8>>,
}

impl Storage for MemoryStorage {
    type Item = Vec<u8>;
    type Error = std::io::Error;

    fn store(&mut self, item: Self::Item) -> std::result::Result<(), Self::Error> {
        self.data.insert(String::from("default"), item);
        Ok(())
    }

    fn retrieve(&self, id: &str) -> std::result::Result<Option<Self::Item>, Self::Error> {
        Ok(self.data.get(id).cloned())
    }
}

// Async main function
#[tokio::main]
async fn main() -> Result<()> {
    let (tx, mut rx) = mpsc::channel(100);
    let mut processor = ItemProcessor::new(tx);

    // Spawn background task
    tokio::spawn(async move {
        while let Some(item) = rx.recv().await {
            println!("Received: {}", item);
        }
    });

    // Process items
    processor.add_item("test".into()).await?;
    
    let config = Config {
        name: "test".into(),
        max_items: 100,
        timeout: Some(DEFAULT_TIMEOUT),
    };

    println!("Config: {:?}", config);
    
    Ok(())
}


================================================
FILE: app/server/syntax/file_map/examples/scala_example.scala
================================================
package example

import scala.concurrent.{Future, ExecutionContext}
import scala.util.{Try, Success, Failure}
import scala.collection.mutable
import scala.annotation.tailrec

// Type alias
type Result[T] = Either[String, T]

// Trait with type parameter
trait DataProcessor[T] {
  def process(data: T): Result[T]
  def validate(data: T): Boolean
}

// Case class with type parameters
case class ProcessingState[T](
  data: T,
  status: ProcessingState.Status,
  timestamp: Long = System.currentTimeMillis()
)

// Companion object with sealed trait
object ProcessingState {
  sealed trait Status
  case object Pending extends Status
  case object Active extends Status
  case object Completed extends Status
  case class Failed(error: String) extends Status
}

// Abstract class
abstract class BaseProcessor[T] extends DataProcessor[T] {
  protected val logger = new Logger(getClass.getName)
  
  // Abstract method
  protected def transform(data: T): T
  
  // Concrete implementation using abstract method
  override def process(data: T): Result[T] = {
    if (!validate(data)) {
      Left("Invalid data")
    } else {
      Try(transform(data)).toEither.left.map(_.getMessage)
    }
  }
}

// Class with type bounds
class NumberProcessor[T <: Number] extends BaseProcessor[T] {
  override def validate(data: T): Boolean = data != null
  
  protected def transform(data: T): T = data
}

// Case class with default and optional parameters
case class User(
  id: String,
  name: String,
  email: String,
  roles: Set[String] = Set.empty,
  metadata: Map[String, String] = Map.empty
)

// Object for utility functions
object Utils {
  def withRetry[T](times: Int)(f: => T): Try[T] = {
    @tailrec
    def attempt(remaining: Int, lastError: Option[Throwable]): Try[T] = {
      if (remaining == 0) {
        Failure(lastError.getOrElse(new RuntimeException("Max retries exceeded")))
      } else {
        Try(f) match {
          case success @ Success(_) => success
          case Failure(error) => attempt(remaining - 1, Some(error))
        }
      }
    }
    attempt(times, None)
  }
}

// Implicit class for extensions
object Implicits {
  implicit class StringOps(val s: String) extends AnyVal {
    def isValidEmail: Boolean = s.matches(".+@.+\\..+")
  }
}

// Trait with self type annotation
trait Logging {
  self: Logger =>
  
  def debug(message: => String): Unit = log("DEBUG", message)
  def info(message: => String): Unit = log("INFO", message)
  def error(message: => String): Unit = log("ERROR", message)
}

// Class using self type trait
class Logger(name: String) extends Logging {
  def log(level: String, message: => String): Unit = {
    println(s"[$level] $name: $message")
  }
}

// Class with type constructor and higher-kinded type
trait Monad[F[_]] {
  def pure[A](a: A): F[A]
  def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
  
  def map[A, B](fa: F[A])(f: A => B): F[B] =
    flatMap(fa)(a => pure(f(a)))
}

// Implicit conversions
object Conversions {
  implicit def stringToUser(s: String): User = {
    val parts = s.split(":")
    User(parts(0), parts(1), parts(2))
  }
}

// Trait with path-dependent type
trait Container {
  type Content
  def content: Content
  def transform(f: Content => Content): Container
}

// Class implementing path-dependent type
class Box[T](initial: T) extends Container {
  type Content = T
  def content: T = initial
  def transform(f: T => T): Box[T] = new Box(f(initial))
}

// Main object with application
object Main extends App {
  import Implicits._
  import ExecutionContext.Implicits.global
  
  val processor = new NumberProcessor[java.lang.Integer]
  
  def processAsync[T](data: T)(implicit ec: ExecutionContext): Future[Result[T]] = {
    Future {
      Thread.sleep(100) // Simulate work
      Right(data)
    }
  }
  
  // Pattern matching
  def handleResult[T](result: Result[T]): Unit = result match {
    case Right(value) => println(s"Success: $value")
    case Left(error) => println(s"Error: $error")
  }
  
  // For comprehension
  val computation = for {
    a <- Future(1)
    b <- Future(2)
    c <- Future(a + b)
  } yield c
  
  // Partial function
  val handler: PartialFunction[Throwable, Unit] = {
    case e: IllegalArgumentException => println(s"Invalid argument: ${e.getMessage}")
    case e: Exception => println(s"Other error: ${e.getMessage}")
  }
  
  // Using implicit conversion
  val user: User = "1:John Doe:john@example.com"
  
  // Using type class
  val box = new Box(42)
  val transformed = box.transform(_ * 2)
  
  println(s"Transformed value: ${transformed.content}")
}


================================================
FILE: app/server/syntax/file_map/examples/svelte_example.svelte
================================================
<script lang="ts">
  import { onMount, onDestroy } from 'svelte';
  import { writable, derived } from 'svelte/store';
  import type { Writable } from 'svelte/store';

  // Props with TypeScript types
  export let title: string;
  export let initialCount: number = 0;

  // Reactive declarations
  $: doubled = count * 2;
  $: {
    if (count > 10) {
      console.log('Count is getting high!');
    }
  }

  // Local state
  let count: number = initialCount;
  let inputValue: string = '';
  let mounted: boolean = false;

  // Stores
  const items: Writable<string[]> = writable([]);
  const filteredItems = derived(items, $items => 
    $items.filter(item => item.includes(inputValue))
  );

  // Event handlers
  function handleClick() {
    count += 1;
  }

  function addItem() {
    if (inputValue.trim()) {
      items.update(items => [...items, inputValue.trim()]);
      inputValue = '';
    }
  }

  function removeItem(index: number) {
    items.update(items => items.filter((_, i) => i !== index));
  }

  // Lifecycle
  onMount(() => {
    mounted = true;
    return () => {
      mounted = false;
    };
  });

  onDestroy(() => {
    console.log('Component destroyed');
  });
</script>

<!-- Markup section -->
<div class="container">
  <h1>{title}</h1>

  <!-- Event binding and reactive values -->
  <div class="counter">
    <button on:click={handleClick}>
      Count: {count}
    </button>
    <p>Doubled: {doubled}</p>
  </div>

  <!-- Form with two-way binding -->
  <div class="form">
    <input
      type="text"
      bind:value={inputValue}
      placeholder="Add item"
      on:keydown={e => e.key === 'Enter' && addItem()}
    />
    <button on:click={addItem}>Add</button>
  </div>

  <!-- Conditional rendering -->
  {#if $items.length > 0}
    <!-- List with store subscription -->
    <ul>
      {#each $filteredItems as item, index (item)}
        <li class="item">
          {item}
          <button on:click={() => removeItem(index)}>×</button>
        </li>
      {/each}
    </ul>
  {:else}
    <p>No items added yet</p>
  {/if}

  <!-- Slots for content projection -->
  <div class="content">
    <slot name="header">
      <h2>Default Header</h2>
    </slot>
    
    <slot>
      <p>Default content</p>
    </slot>
    
    <slot name="footer" />
  </div>
</div>

<style>
  .container {
    padding: 1rem;
    max-width: 600px;
    margin: 0 auto;
  }

  .counter {
    margin: 1rem 0;
  }

  .form {
    display: flex;
    gap: 0.5rem;
    margin-bottom: 1rem;
  }

  input {
    flex: 1;
    padding: 0.5rem;
    border: 1px solid #ccc;
    border-radius: 4px;
  }

  button {
    padding: 0.5rem 1rem;
    background: #4CAF50;
    color: white;
    border: none;
    border-radius: 4px;
    cursor: pointer;
  }

  button:hover {
    background: #45a049;
  }

  ul {
    list-style: none;
    padding: 0;
  }

  .item {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 0.5rem;
    margin: 0.25rem 0;
    background: #f5f5f5;
    border-radius: 4px;
  }

  .item button {
    background: #ff4444;
    padding: 0.25rem 0.5rem;
  }

  .item button:hover {
    background: #cc0000;
  }

  .content {
    margin-top: 2rem;
    padding: 1rem;
    border: 1px solid #ddd;
    border-radius: 4px;
  }

  /* Scoped styles - only apply to this component */
  :global(.theme-dark) .container {
    background: #333;
    color: #fff;
  }
</style>


================================================
FILE: app/server/syntax/file_map/examples/swift_example.swift
================================================
import Foundation

// Protocol definitions
protocol DataProcessor {
    associatedtype Input
    associatedtype Output
    
    func process(_ input: Input) async throws -> Output
    func validate(_ input: Input) -> Bool
}

// Error type
enum ProcessingError: LocalizedError {
    case invalidInput(String)
    case processingFailed(String)
    
    var errorDescription: String? {
        switch self {
        case .invalidInput(let reason): return "Invalid input: \(reason)"
        case .processingFailed(let reason): return "Processing failed: \(reason)"
        }
    }
}

// Property wrapper
@propertyWrapper
struct Validated<T> {
    private var value: T
    private let validator: (T) -> Bool
    
    var wrappedValue: T {
        get { value }
        set {
            guard validator(newValue) else {
                fatalError("Invalid value")
            }
            value = newValue
        }
    }
    
    init(wrappedValue: T, validator: @escaping (T) -> Bool) {
        guard validator(wrappedValue) else {
            fatalError("Invalid initial value")
        }
        self.value = wrappedValue
        self.validator = validator
    }
}

// Actor for thread-safe state management
actor ProcessingState {
    private(set) var processedCount: Int = 0
    private var status: Status = .pending
    
    enum Status {
        case pending
        case processing
        case completed
        case failed(Error)
    }
    
    func incrementCount() {
        processedCount += 1
    }
    
    func updateStatus(_ newStatus: Status) {
        status = newStatus
    }
}

// Generic struct with where clause
struct Queue<Element> where Element: Sendable {
    private var elements: [Element] = []
    private let lock = NSLock()
    
    mutating func enqueue(_ element: Element) {
        lock.lock()
        defer { lock.unlock() }
        elements.append(element)
    }
    
    mutating func dequeue() -> Element? {
        lock.lock()
        defer { lock.unlock() }
        return elements.isEmpty ? nil : elements.removeFirst()
    }
}

// Class inheritance and protocol conformance
class StringProcessor: DataProcessor {
    typealias Input = String
    typealias Output = String
    
    private let state = ProcessingState()
    
    @Validated(validator: { !$0.isEmpty })
    private var currentInput: String = "default"
    
    func process(_ input: String) async throws -> String {
        guard validate(input) else {
            throw ProcessingError.invalidInput("String is empty")
        }
        
        await state.updateStatus(.processing)
        
        // Simulate processing
        try await Task.sleep(nanoseconds: 1_000_000_000)
        let result = input.uppercased()
        
        await state.incrementCount()
        await state.updateStatus(.completed)
        
        return result
    }
    
    func validate(_ input: String) -> Bool {
        !input.isEmpty
    }
}

// Extension with async sequence
extension StringProcessor: AsyncSequence, AsyncIteratorProtocol {
    typealias Element = String
    
    func makeAsyncIterator() -> StringProcessor {
        self
    }
    
    func next() async throws -> String? {
        try await process(currentInput)
    }
}

// Result builders
@resultBuilder
struct ArrayBuilder<T> {
    static func buildBlock(_ components: T...) -> [T] {
        components
    }
}

// Function using result builder
func makeArray<T>(@ArrayBuilder<T> content: () -> [T]) -> [T] {
    content()
}

// Async main function demonstrating usage
@main
struct Example {
    static func main() async throws {
        let processor = StringProcessor()
        var queue = Queue<String>()
        
        // Using result builder
        let inputs = makeArray {
            "Hello"
            "World"
            "Swift"
        }
        
        // Process inputs
        for input in inputs {
            queue.enqueue(input)
        }
        
        // Process queue
        while let input = queue.dequeue() {
            do {
                let result = try await processor.process(input)
                print("Processed: \(result)")
            } catch {
                print("Error: \(error.localizedDescription)")
            }
        }
        
        // Using async sequence
        for try await result in processor.prefix(3) {
            print("Async sequence result: \(result)")
        }
    }
}


================================================
FILE: app/server/syntax/file_map/examples/toml_example.toml
================================================
# This is a TOML example file demonstrating various TOML syntax elements

# Basic key/value pairs
title = "TOML Example"
version = "1.0.0"
enabled = true

# String with special characters
description = """
A multi-line string that can contain "quotes"
and other special characters like \n or \t
"""

# Date and time
created = 1979-05-27T07:32:00Z
updated = 1979-05-27T00:32:00-07:00

# Numbers
integer = 42
float = 3.14159
scientific = 1e+12
hex = 0xDEADBEEF
octal = 0o755
binary = 0b11010110

# Arrays
colors = ["red", "yellow", "green"]
numbers = [1, 2, 3]
nested_arrays = [[1, 2], [3, 4, 5]]
mixed_array = [[1, 2], ["a", "b", "c"]]

# Array of tables
[[fruits]]
name = "apple"
color = "red"
season = "fall"

[[fruits]]
name = "banana"
color = "yellow"
season = "summer"

# Tables
[server]
host = "example.com"
port = 8080
enabled = true

[server.options]
timeout = 30
max_connections = 100

[database]
url = "postgresql://localhost:5432/mydb"
max_connections = 100

[database.replica]
enabled = true
hosts = [
    "replica1.example.com",
    "replica2.example.com"
]

# Nested tables
[owner]
name = "John Doe"
[owner.preferences]
theme = "dark"
notifications = true
[owner.preferences.display]
color_scheme = "monokai"
font_size = 12

# Table with inline tables
[endpoints]
status = { url = "/status", method = "GET" }
health = { url = "/health", method = "GET", timeout = 5 }

# Complex types
[types]
primitive_array = [ "red", "yellow", "green" ]
array_of_integers = [ 1, 2, 3 ]
array_of_floats = [ 1.1, 2.2, 3.3 ]
array_of_dates = [ 1979-05-27T07:32:00Z, 1979-05-28T07:32:00Z ]
array_of_tables = [
    { x = 1, y = 2, z = 3 },
    { x = 7, y = 8, z = 9 },
    { x = 2, y = 4, z = 8 }
]

# Example configuration
[app]
name = "MyApp"
environment = "production"

[app.logging]
level = "info"
format = "json"
output = "stdout"

[app.features]
experimental = false
beta_features = ["feature1", "feature2"]

[app.limits]
requests_per_second = 1000
concurrent_connections = 50


================================================
FILE: app/server/syntax/file_map/examples/tsx_example.tsx
================================================
import React, { useState, useEffect, useCallback, useRef } from 'react';
import type { FC, ReactNode, FormEvent } from 'react';

// Type definitions
interface User {
  id: string;
  name: string;
  email: string;
  role: 'admin' | 'user';
}

type ValidationResult = {
  valid: boolean;
  errors: string[];
};

// Props interface with generic type
interface DataListProps<T> {
  items: T[];
  renderItem: (item: T) => ReactNode;
  onItemSelect?: (item: T) => void;
}

// Custom hook with TypeScript
function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value);

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => {
      clearTimeout(timer);
    };
  }, [value, delay]);

  return debouncedValue;
}

// Higher-order component with TypeScript
function withLoading<P extends object>(
  WrappedComponent: React.ComponentType<P>
): FC<P & { loading?: boolean }> {
  return ({ loading = false, ...props }) => (
    <div className="wrapper">
      {loading ? (
        <div className="loading-spinner" />
      ) : (
        <WrappedComponent {...(props as P)} />
      )}
    </div>
  );
}

// Form component with controlled inputs
const UserForm: FC<{ onSubmit: (user: Partial<User>) => void }> = ({ onSubmit }) => {
  const [formData, setFormData] = useState<Partial<User>>({
    name: '',
    email: '',
    role: 'user'
  });

  const handleSubmit = (e: FormEvent) => {
    e.preventDefault();
    onSubmit(formData);
  };

  return (
    <form onSubmit={handleSubmit} className="user-form">
      <div className="form-group">
        <label htmlFor="name">Name:</label>
        <input
          type="text"
          id="name"
          value={formData.name}
          onChange={e => setFormData(prev => ({
            ...prev,
            name: e.target.value
          }))}
          required
        />
      </div>

      <div className="form-group">
        <label htmlFor="email">Email:</label>
        <input
          type="email"
          id="email"
          value={formData.email}
          onChange={e => setFormData(prev => ({
            ...prev,
            email: e.target.value
          }))}
          required
        />
      </div>

      <div className="form-group">
        <label htmlFor="role">Role:</label>
        <select
          id="role"
          value={formData.role}
          onChange={e => setFormData(prev => ({
            ...prev,
            role: e.target.value as User['role']
          }))}
        >
          <option value="user">User</option>
          <option value="admin">Admin</option>
        </select>
      </div>

      <button type="submit">Submit</button>
    </form>
  );
};

// Generic list component
const DataList = <T extends { id: string }>({
  items,
  renderItem,
  onItemSelect
}: DataListProps<T>): JSX.Element => {
  return (
    <ul className="data-list">
      {items.map(item => (
        <li
          key={item.id}
          onClick={() => onItemSelect?.(item)}
          role="button"
          tabIndex={0}
        >
          {renderItem(item)}
        </li>
      ))}
    </ul>
  );
};

// Main app component using all features
const App: FC = () => {
  const [users, setUsers] = useState<User[]>([]);
  const [searchTerm, setSearchTerm] = useState('');
  const debouncedSearch = useDebounce(searchTerm, 300);
  const formRef = useRef<HTMLFormElement>(null);

  const handleUserSubmit = useCallback((userData: Partial<User>) => {
    const newUser: User = {
      id: crypto.randomUUID(),
      ...userData as Omit<User, 'id'>
    };
    setUsers(prev => [...prev, newUser]);
  }, []);

  const filteredUsers = users.filter(user =>
    user.name.toLowerCase().includes(debouncedSearch.toLowerCase())
  );

  return (
    <div className="app">
      <header className="app-header">
        <h1>User Management</h1>
        <input
          type="search"
          placeholder="Search users..."
          value={searchTerm}
          onChange={e => setSearchTerm(e.target.value)}
          className="search-input"
        />
      </header>

      <main>
        <section className="user-form-section">
          <h2>Add New User</h2>
          <UserForm onSubmit={handleUserSubmit} />
        </section>

        <section className="user-list-section">
          <h2>Users</h2>
          <DataList
            items={filteredUsers}
            renderItem={user => (
              <div className="user-item">
                <strong>{user.name}</strong>
                <span>{user.email}</span>
                <badge className={`role-badge ${user.role}`}>
                  {user.role}
                </badge>
              </div>
            )}
            onItemSelect={user => console.log('Selected user:', user)}
          />
        </section>
      </main>
    </div>
  );
};

export default App;


================================================
FILE: app/server/syntax/file_map/examples/typescript_example.ts
================================================
// @ts-nocheck

// Type imports
import type { Request, Response, NextFunction } from 'express';

// Interface definitions
interface DataProcessor<T> {
    process(data: T): Promise<T>;
    validate(data: T): boolean;
}

// Type aliases
type Result<T> = {
    data: T;
    error?: string;
    metadata: Record<string, unknown>;
};

// Enum with string values
enum Status {
    PENDING = 'pending',
    ACTIVE = 'active',
    COMPLETED = 'completed',
    FAILED = 'failed'
}

// Union type
type ValidationResult =
    | { valid: true; data: unknown }
    | { valid: false; errors: string[] };

// Intersection type
type AdminUser = User & {
    permissions: string[];
    role: 'admin';
};

// Mapped type
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

// Utility type
type Partial<T> = {
    [P in keyof T]?: T[P];
};

// Class with decorators

// Decorator factory
function validate(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value;
    descriptor.value = function (...args: any[]) {
        if (this.validate(args[0])) {
            return originalMethod.apply(this, args);
        }
        throw new Error('Validation failed');
    };
    return descriptor;
}

@logger
class User {
    @required
    private name: string;

    @email
    private email: string;

    @format('YYYY-MM-DD')
    private createdAt: Date;

    constructor(name: string, email: string) {
        this.name = name;
        this.email = email;
        this.createdAt = new Date();
    }

    // Method decorator
    @validate
    public updateEmail(newEmail: string): void {
        this.email = newEmail;
    }

    // Getter with type guard
    public get isAdmin(): this is AdminUser {
        return 'role' in this && (this as AdminUser).role === 'admin';
    }
}


// Abstract class
abstract class BaseProcessor<T> implements DataProcessor<T> {
    protected status: Status = Status.PENDING;

    abstract process(data: T): Promise<T>;

    validate(data: T): boolean {
        return data !== null && data !== undefined;
    }
}

// Generic class extending abstract class
class StringProcessor extends BaseProcessor<string> {
    async process(data: string): Promise<string> {
        this.status = Status.ACTIVE;
        const result = await this.transform(data);
        this.status = Status.COMPLETED;
        return result;
    }

    private async transform(data: string): Promise<string> {
        return data.toUpperCase();
    }
}

// Function overloads
function process(data: string): Promise<string>;
function process(data: number): Promise<number>;
function process(data: string | number): Promise<string | number> {
    return Promise.resolve(data);
}

// Generic function with constraints
async function validateData<T extends { id: string }>(
    data: T
): Promise<ValidationResult> {
    if (!data.id) {
        return { valid: false, errors: ['ID is required'] };
    }
    return { valid: true, data };
}

// Higher-order function
function withRetry<T>(
    fn: () => Promise<T>,
    retries: number = 3
): () => Promise<T> {
    return async () => {
        let lastError: Error | undefined;

        for (let i = 0; i < retries; i++) {
            try {
                return await fn();
            } catch (error) {
                lastError = error as Error;
            }
        }

        throw lastError;
    };
}

// Middleware function type
type Middleware = (
    req: Request,
    res: Response,
    next: NextFunction
) => Promise<void>;

// Utility functions with type inference
const createUser = <T extends User>(data: Partial<T>): T => {
    return { ...data } as T;
};

// Async generator function
async function* generateSequence(
    start: number,
    end: number
): AsyncGenerator<number> {
    for (let i = start; i <= end; i++) {
        await new Promise(resolve => setTimeout(resolve, 100));
        yield i;
    }
}

// Example usage
async function main() {
    const processor = new StringProcessor();
    const result = await processor.process('hello');

    const user = createUser<AdminUser>({
        name: 'Admin',
        email: 'admin@example.com',
        permissions: ['read', 'write'],
        role: 'admin'
    });

    const retryableProcess = withRetry(async () => {
        return await processor.process('retry me');
    });

    for await (const num of generateSequence(1, 5)) {
        console.log(num);
    }
}

// exported definitions
export const exportedFunction = (a: number, b: number) => {
    return a + b;
}
export const SOME_CONST: number = 123;
export var SOME_VAR: string = 'hello';
export let SOME_LET: boolean = true;
export type SOME_TYPE = string;
export interface SOME_INTERFACE {
    name: string;
}
export class SOME_CLASS {
    constructor(public name: string) { }
}

export function fn() {
    return 'hello';
}

export async function asyncFn() {
    return 'hello';
}

export enum Enum {
    A = 'a',
    B = 'b',
    C = 'c'
}

export const oneLineFunc = (a: number, b: number): number => a + b;


/* default-export variations (multiple defaults are illegal for the
   TS checker, but tree-sitter parses them just fine) */
export default function makeId<T = string>() { return '' as T }
export default class DefaultCls { }
export default (x: number) => x * 2

/* re-exports that should be ignored */
export { Foo as Renamed } from './foo'
export * as utils from './utils'

/* const / ambient enums */
const enum Flags { None = 0, Read = 1 }
declare enum Ambient { X }

/* namespace with nested export */
namespace Legacy { export function greet() { } }

/* Arrow returning an implicit object literal */
export const build = (id: string) => ({ id, ts: Date.now() })

/* Generic arrow function assigned to a const */
const identity = <T>(x: T) => x

/* Function expression assigned to a const */
const internal = function named() { return 1 }

/* Static field plus getter accessor inside a class */
class C {
    static value = 1
    static get inc() { return ++this.value }
}

/* New “accessor” keyword (TS 5.4 Stage-3) */
class Modern {
    accessor score = 0
}

/* Template-literal & conditional type aliases */
type Route<T extends string> = `/api/${T}`
type Flatten<T> = T extends (infer U)[] ? U : T

/* Module augmentation / ambient global */
declare global {
    interface Window { myLib: unknown }
}

================================================
FILE: app/server/syntax/file_map/examples/yaml_example.yaml
================================================

# Document metadata
# Example YAML file demonstrating various syntax elements
---
name: YAML Example
version: 1.0.0
description: Example YAML file demonstrating various syntax elements
updated_at: 2024-02-20T15:00:00Z

# Scalar types
strings:
  simple: Hello World
  quoted: "Hello \"quoted\" World"
  literal: |
    This is a literal block
    that preserves newlines
    and can contain special chars: *&[]
  folded: >
    This is a folded block
    that will be rendered
    as a single line

numbers:
  integer: 42
  float: 3.14159
  scientific: 1.23e+4
  infinity: .inf
  not_a_number: .nan

dates:
  simple: 2024-02-20
  datetime: 2024-02-20T15:00:00Z
  canonical: 2024-02-20T15:00:00.000Z

booleans:
  true_values: [true, True, TRUE, yes, Yes, YES, on, On, ON]
  false_values: [false, False, FALSE, no, No, NO, off, Off, OFF]

# Complex types
arrays:
  - simple
  - items
  - [nested, array]
  - 
    - deeply
    - nested
    - array

# Mapping types
object:
  key1: value1
  key2: value2
  nested:
    key3: value3
    key4: value4

# Anchors and aliases
definitions: &defaults
  timeout: 30
  retries: 3
  enabled: true

production:
  <<: *defaults  # Merge defaults
  environment: production
  host: prod.example.com

staging:
  <<: *defaults
  environment: staging
  host: staging.example.com
  timeout: 60  # Override default

# Complex mapping
services:
  - name: web
    image: nginx:latest
    ports:
      - "80:80"
      - "443:443"
    environment:
      - NODE_ENV=production
      - DEBUG=false
    volumes:
      - type: bind
        source: /var/www
        target: /usr/share/nginx/html
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3

  - name: database
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: !vault |
        $ANSIBLE_VAULT;1.1;AES256
        31613262363135363132666363366363
    volumes:
      - data:/var/lib/postgresql/data

# Sets
unique_values: !!set
  ? item1
  ? item2
  ? item3

# Binary data
certificate: !!binary |
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOf...

# Custom tags
datetime_obj: !!python/object:datetime.datetime
  year: 2024
  month: 2
  day: 20
  hour: 15
  minute: 0
  second: 0

# Explicit typing
explicit_strings: !!str 42
explicit_int: !!int "42"
explicit_float: !!float "3.14159"
explicit_bool: !!bool "yes"




================================================
FILE: app/server/syntax/file_map/map.go
================================================
package file_map

import (
	"context"
	"fmt"
	"os"
	"plandex-server/syntax"
	"strings"

	shared "plandex-shared"

	tree_sitter "github.com/smacker/go-tree-sitter"
)

var verboseLogging = os.Getenv("VERBOSE_LOGGING") == "true"

// FileMap represents a file's important definitions
type FileMap struct {
	Definitions []Definition
}

type Definition struct {
	Type      string       // "function", "class", "key", "selector", "instruction" etc
	Signature string       // The full signature/header without implementation
	Comments  []string     // Any comments that precede this definition
	TagAttrs  []string     // For xml style markup tags, the class and id attributes
	TagReps   int          // For tags, the number of times this tag is repeated
	Line      int          // Line number where definition starts
	Children  []Definition // For parent types that can contain nested definitions
}

type Node struct {
	Type   string
	Lang   shared.Language
	TsNode *tree_sitter.Node
	Bytes  []byte
}

func MapFile(ctx context.Context, filename string, content []byte) (*FileMap, error) {
	if !shared.HasFileMapSupport(filename) {
		// return nil, fmt.Errorf("unsupported file type: %s", filename)
		return &FileMap{
			Definitions: []Definition{
				{
					Type:      "no_map",
					Signature: "[NO MAP]",
				},
			},
		}, nil
	}

	lang := syntax.GetLanguageForPath(filename)

	if lang == "" {
		// return nil, fmt.Errorf("unsupported file type: %s", ext)
		return &FileMap{
			Definitions: []Definition{},
		}, nil
	}

	if !shared.IsTreeSitterLanguage(lang) {
		switch lang {
		case shared.LanguageMarkdown:
			return &FileMap{
				Definitions: mapMarkdownSimple(content),
			}, nil
		default:
			// return nil, fmt.Errorf("unsupported file type: %s", ext)
			return &FileMap{
				Definitions: []Definition{},
			}, nil
		}
	}

	// Get appropriate parser
	var parser *tree_sitter.Parser
	var fallbackParser *tree_sitter.Parser
	var fallbackLang shared.Language

	parser, lang, fallbackParser, fallbackLang = syntax.GetParserForPath(filename)

	if parser == nil && fallbackParser == nil {
		// return nil, fmt.Errorf("unsupported file type: %s", ext)
		return &FileMap{
			Definitions: []Definition{},
		}, nil
	}

	if parser != nil {
		defer parser.Close()
	}

	if fallbackParser != nil {
		defer fallbackParser.Close()
	}

	var tree *tree_sitter.Tree
	var err error

	if parser != nil {
		// Parse file
		tree, err = parser.ParseCtx(ctx, nil, content)
		if err != nil {
			// return nil, fmt.Errorf("failed to parse file: %v", err)
			return &FileMap{
				Definitions: []Definition{},
			}, nil
		}
		defer tree.Close()
	}

	if tree == nil || tree.RootNode().Type() == "error" {
		fallbackTree, err := fallbackParser.ParseCtx(ctx, nil, content)
		if err != nil {
			// return nil, fmt.Errorf("failed to parse file: %v", err)
			return &FileMap{
				Definitions: []Definition{},
			}, nil
		}
		defer fallbackTree.Close()

		if fallbackTree.RootNode().Type() != "error" {
			return &FileMap{
				Definitions: mapNode(fallbackTree.RootNode(), content, fallbackLang),
			}, nil
		}
	}

	return &FileMap{
		Definitions: mapNode(tree.RootNode(), content, lang),
	}, nil

}

func mapNode(node *tree_sitter.Node, content []byte, lang shared.Language) []Definition {
	switch lang {
	case shared.LanguageHtml:
		return mapMarkup(content)
	case shared.LanguageSvelte:
		return mapSvelte(content)
	default:
		return mapTraditional(Node{
			Lang:   lang,
			TsNode: node,
			Bytes:  content,
		}, nil)
	}
}

// For traditional programming languages
func mapTraditional(baseNode Node, parentNode *Node) []Definition {
	var defs []Definition
	cursor := tree_sitter.NewTreeCursor(baseNode.TsNode)
	defer cursor.Close()

	// potentially too much output even for verbose logging — uncomment if you need to see the full tree
	// if verboseLogging {
	// 	fmt.Println("mapTraditional", baseNode.TsNode)
	// }

	if cursor.GoToFirstChild() {
		for {
			tsNode := cursor.CurrentNode()
			node := Node{
				Type:   tsNode.Type(),
				Lang:   baseNode.Lang,
				TsNode: tsNode,
				Bytes:  baseNode.Bytes,
			}

			if isIncludeAndContinueNode(node) {
				if verboseLogging {
					fmt.Println("include and continue node", cursor.CurrentNode().Type())
				}
				if !cursor.GoToNextSibling() {
					break
				}
				continue
			}

			if verboseLogging {
				fmt.Println()
				fmt.Println("node", node.Type)
				// fmt.Println("content", string(node.Content(content)))
				fmt.Println()
			}

			// Check if this is a definition node
			if isDefinitionNode(node, parentNode) {
				if verboseLogging {
					fmt.Println("definition node", node.Type)
				}

				def := Definition{
					Type: node.Type,
					Line: int(tsNode.StartPoint().Row) + 1,
				}

				if isAssignmentNode(node) {
					if verboseLogging {
						fmt.Println("assignment node", node.Type)
					}
					// Try different field names for identifiers
					// fmt.Printf("assignment node: %s\n", node.Type)
					sig := ""

					assignmentBoundary := findAssignmentBoundary(node)

					if assignmentBoundary != nil {
						start := tsNode.StartByte()
						end := assignmentBoundary.TsNode.StartByte()
						sig = string(node.Bytes[start:end])
						sig = strings.TrimSuffix(strings.TrimSpace(sig), "=")
					} else {
						identifiers := findIdentifier(node)
						if len(identifiers) > 0 {
							if verboseLogging {
								fmt.Println("found identifiers", len(identifiers))
							}

							start := tsNode.StartByte()
							end := identifiers[len(identifiers)-1].TsNode.EndByte()
							sig = string(node.Bytes[start:end])
						} else {
							if verboseLogging {
								fmt.Println("no identifier found", node.Type)
							}
							sig = string(node.TsNode.Content(node.Bytes)) + " "
						}
					}

					def.Signature = sig
				} else if isPassThroughParentNode(node) {
					if verboseLogging {
						fmt.Println("pass through parent node", node.Type)
					}

					start := tsNode.StartByte()

					firstChild := firstDefinitionChild(node)
					if firstChild != nil {
						if verboseLogging {
							fmt.Println("firstChild", firstChild.Type)
						}
						end := firstChild.TsNode.StartByte()

						sig := string(node.Bytes[start:end])
						sig = strings.TrimSpace(sig)

						if verboseLogging {
							fmt.Println("got pass through parent signature", def.Signature)
							fmt.Println("recursing into first child", firstChild.Type)
						}

						children := mapTraditional(node, nil)

						if sig == "" {
							// collapse if signature is empty
							if len(children) > 0 {
								sig = children[0].Signature
								grandchildren := children[0].Children
								sibs := children[1:]
								children = append(grandchildren, sibs...)
							}
						}

						def.Signature = sig
						def.Children = children
					} else {
						if verboseLogging {
							fmt.Println("no first child found", node.Type)
						}
					}

				} else {
					if verboseLogging {
						fmt.Println("not assignment node", node.Type)
						fmt.Println("looking for implementation boundary")
					}
					// Get signature (up to body)
					if body := findImplementationBoundary(node); body != nil {
						if verboseLogging {
							fmt.Println("found implementation boundary", body.Type)
						}

						start := tsNode.StartByte()
						var end uint32
						if tsNode == body.TsNode {
							if verboseLogging {
								fmt.Println("node == body")
							}
							firstChild := firstDefinitionChild(*body)
							if firstChild != nil {
								if verboseLogging {
									fmt.Println("firstChild != nil")
									fmt.Println("firstChild", firstChild.Type)
								}
								end = firstChild.TsNode.StartByte()
							} else {
								if verboseLogging {
									fmt.Println("firstChild == nil")
								}
								end = body.TsNode.EndByte()
							}
						} else {
							end = body.TsNode.StartByte()
						}
						if verboseLogging {
							fmt.Println("start", start)
							fmt.Println("end", end)
						}
						def.Signature = string(node.Bytes[start:end])
						if verboseLogging {
							fmt.Println("got signature", def.Signature)
						}

						// If this is a parent type node, recurse into the body
						if isParentNode(node) {
							if verboseLogging {
								fmt.Println("isParentNode, recursing into body", node.Type)
							}
							def.Children = mapTraditional(*body, &node)
						}
					} else {
						if verboseLogging {
							fmt.Println("no implementation boundary found", node.Type)
						}
						def.Signature = string(node.TsNode.Content(node.Bytes))
					}
				}

				// Get preceding comments
				// no comments for now to minimize tokens
				// def.Comments = getPrecedingComments(node)

				defs = append(defs, def)
			} else {
				if verboseLogging {
					fmt.Println("not definition node", node.Type)
				}
			}

			if !cursor.GoToNextSibling() {
				break
			}
		}
	}

	return defs
}

// // Get preceding comments
// func getPrecedingComments(node Node) []string {
// 	var comments []string
// 	const maxCommentLength = 1000

// 	prevNode := node.TsNode.PrevSibling()
// 	for prevNode != nil {
// 		if !strings.Contains(prevNode.Type(), "comment") {
// 			break
// 		}
// 		comment := string(prevNode.Content(node.Bytes))
// 		if len(comment) > maxCommentLength {
// 			comment = comment[:maxCommentLength] + "..."
// 		}
// 		comments = append([]string{comment}, comments...)
// 		prevNode = prevNode.PrevSibling()
// 	}
// 	return comments
// }

// func mapConfig(node *tree_sitter.Node, content []byte) []Definition {
// 	cursor := tree_sitter.NewTreeCursor(node)
// 	defer cursor.Close()

// 	var walkConfig func(*tree_sitter.Node) []Definition
// 	walkConfig = func(node *tree_sitter.Node) []Definition {
// 		var defs []Definition

// 		// Handle key-value pairs
// 		switch node.Type() {
// 		case "block_mapping_pair": // YAML
// 			if key := node.ChildByFieldName("key"); key != nil {
// 				def := Definition{
// 					Type:      "key",
// 					Signature: string(key.Content(content)),
// 					Line:      int(key.StartPoint().Row) + 1,
// 				}

// 				// Handle nested structures
// 				if val := node.ChildByFieldName("value"); val != nil {
// 					switch val.Type() {
// 					case "block_mapping": // nested YAML map
// 						def.Children = walkConfig(val)
// 					case "block_sequence": // YAML array
// 						// Could track sequences if needed
// 					}
// 				}

// 				defs = append(defs, def)
// 			}
// 		case "pair": // TOML/JSON
// 			// Similar pattern for TOML/JSON
// 		case "field": // CUE/HCL
// 			// Similar pattern for CUE/HCL
// 		}

// 		return defs
// 	}

// 	return walkConfig(node)
// }

func (m *FileMap) String() string {
	var b strings.Builder

	var writeDefinition func(def *Definition, depth int)
	writeDefinition = func(def *Definition, depth int) {
		if def.Type == "svelte-style" {
			b.WriteString("\n")
		}

		// Indent
		if depth > 0 {
			b.WriteString(strings.Repeat("  ", depth))
			b.WriteString("- ")
		}

		// Write signature (for tags, include attrs)
		if def.Type == "tag" {
			// Extract tag name from signature (it's the first word)
			tagName := strings.Fields(def.Signature)[0]
			// Build full representation with attrs
			if len(def.TagAttrs) > 0 {
				if def.TagReps > 1 {
					b.WriteString(fmt.Sprintf("[%dx]", def.TagReps))
				}
				b.WriteString(fmt.Sprintf("%s%s", tagName, strings.Join(def.TagAttrs, "")))
			} else {
				b.WriteString(tagName)
			}
		} else {
			b.WriteString(strings.TrimSpace(def.Signature))
		}
		b.WriteString("\n")

		// Write children with increased depth
		for _, child := range def.Children {
			writeDefinition(&child, depth+1)
		}

		if def.Type == "svelte-script" {
			b.WriteString("\n")
		}
	}

	// Write all top-level definitions
	for _, def := range m.Definitions {
		writeDefinition(&def, 0)
	}

	return b.String()
}

func mapMarkdownSimple(content []byte) []Definition {
	var defs []Definition
	lines := strings.Split(string(content), "\n")

	for i, line := range lines {
		trimmedLine := strings.TrimSpace(line)

		// Skip empty lines
		if trimmedLine == "" {
			continue
		}

		// Check for ATX headings (# style)
		if strings.HasPrefix(trimmedLine, "#") {
			heading := trimmedLine
			level := 0
			// Count heading level
			for strings.HasPrefix(heading, "#") {
				level++
				heading = strings.TrimPrefix(heading, "#")
			}
			heading = strings.TrimSpace(heading)

			// Only add if there's actual heading content
			if heading != "" {
				defs = append(defs, Definition{
					Type:      fmt.Sprintf("h%d", level),
					Signature: heading,
					Line:      i + 1,
				})
			}
			continue
		}

		// Check for Setext headings (=== or --- style)
		if i > 0 && len(trimmedLine) > 0 {
			// Check if line consists entirely of = or -
			isAllEquals := strings.TrimSpace(strings.ReplaceAll(trimmedLine, "=", "")) == ""
			isAllDashes := strings.TrimSpace(strings.ReplaceAll(trimmedLine, "-", "")) == ""

			// Must have at least 2 characters and previous line must not be empty
			prevLine := strings.TrimSpace(lines[i-1])
			if len(trimmedLine) >= 2 && prevLine != "" {
				if isAllEquals {
					// Level 1 heading
					defs = append(defs, Definition{
						Type:      "h1",
						Signature: prevLine,
						Line:      i, // Use previous line's number
					})
				} else if isAllDashes {
					// Level 2 heading
					defs = append(defs, Definition{
						Type:      "h2",
						Signature: prevLine,
						Line:      i, // Use previous line's number
					})
				}
			}
		}
	}

	return defs
}


================================================
FILE: app/server/syntax/file_map/markup.go
================================================
package file_map

import (
	"bytes"
	"fmt"
	"strings"

	"golang.org/x/net/html"
)

func mapMarkup(content []byte) []Definition {
	reader := bytes.NewReader(content)
	doc, err := html.Parse(reader)
	if err != nil {
		return nil
	}

	var walk func(*html.Node) []Definition
	walk = func(n *html.Node) []Definition {
		var defs []Definition

		if n.Type == html.ElementNode {
			// Only track semantically significant elements
			if isSignificantTag(n.Data) {
				def := Definition{
					Type:      "tag",
					Signature: n.Data,
				}

				// Only include semantic classes/ids
				for _, attr := range n.Attr {
					if attr.Key == "id" {
						def.TagAttrs = append(def.TagAttrs, fmt.Sprintf("#%s", attr.Val))
					} else if attr.Key == "class" {
						classes := strings.Fields(attr.Val)
						if len(classes) > 3 {
							classes = classes[:3]
						}
						def.TagAttrs = append(def.TagAttrs, fmt.Sprintf(".%s", strings.Join(classes, ".")))
					}
				}

				// Get children of this element
				def.Children = []Definition{}
				for c := n.FirstChild; c != nil; c = c.NextSibling {
					def.Children = append(def.Children, walk(c)...)
				}

				defs = append(defs, def)
			}
		}

		// Only process siblings for non-significant elements
		if !isSignificantTag(n.Data) {
			for c := n.FirstChild; c != nil; c = c.NextSibling {
				defs = append(defs, walk(c)...)
			}
		}

		return defs
	}

	defs := walk(doc)
	defs = consolidateRepeatedTags(defs)
	return defs
}

// Helper function to check if two definitions are equivalent
func areMarkupDefinitionsEqual(a, b Definition) bool {
	if a.Type != b.Type || a.Signature != b.Signature || len(a.TagAttrs) != len(b.TagAttrs) {
		return false
	}

	// Compare attributes
	for i, attr := range a.TagAttrs {
		if attr != b.TagAttrs[i] {
			return false
		}
	}

	return true
}

// Helper function to consolidate repeated tags
func consolidateRepeatedTags(defs []Definition) []Definition {
	var result []Definition

	firstDef := defs[0]
	count := 1
	allEqual := true

	// fmt.Printf("consolidateRepeatedTags: checking %d definitions for equality\n", len(defs))
	// spew.Dump(defs)

	if len(defs) > 1 {
		for i, def := range defs {
			if len(def.Children) > 0 {
				// fmt.Printf("consolidateRepeatedTags: definition %d has children, cannot consolidate\n", i)
				allEqual = false
				break
			}

			if i == 0 {
				continue
			}

			if !areMarkupDefinitionsEqual(firstDef, def) {
				// fmt.Printf("consolidateRepeatedTags: definition %d is not equal to first definition\n", i)
				allEqual = false
				break
			}
			count++
		}
	}

	if allEqual && count > 1 {
		// fmt.Printf("consolidateRepeatedTags: consolidated %d equal definitions\n", count)
		firstDef.TagReps = count
		result = []Definition{firstDef}
	} else {
		// fmt.Printf("consolidateRepeatedTags: definitions not equal, keeping original %d definitions\n", len(defs))
		result = defs
	}

	for i := range result {
		def := &result[i]
		if len(def.Children) > 0 {
			// fmt.Printf("consolidateRepeatedTags: recursively consolidating children of definition %d\n", i)
			def.Children = consolidateRepeatedTags(def.Children)
		}
	}

	return result
}

var significantHtmlTags = map[string]bool{
	"html":     true,
	"head":     true,
	"body":     true,
	"main":     true,
	"nav":      true,
	"header":   true,
	"footer":   true,
	"article":  true,
	"section":  true,
	"form":     true,
	"dialog":   true,
	"template": true,
	"table":    true,
	"div":      true,
	"ul":       true,
	"aside":    true,
}

func isSignificantTag(tag string) bool {
	return significantHtmlTags[tag]
}


================================================
FILE: app/server/syntax/file_map/multi.go
================================================
package file_map

import (
	"context"
	"fmt"
	"log"
	"path/filepath"
	"plandex-server/syntax"
	"runtime"
	"sort"
	"strings"
	"sync"

	shared "plandex-shared"

	tree_sitter "github.com/smacker/go-tree-sitter"
)

// No longer used - all mapping is done via GetFileMap handler
// handles concurrent processing of multiple files for mapping
func ProcessMapFiles(ctx context.Context, inputs map[string]string) (shared.FileMapBodies, error) {
	log.Println("ProcessMapFiles")
	bodies := make(shared.FileMapBodies, len(inputs))
	var mu sync.Mutex
	errCh := make(chan error, len(inputs))

	// Use half of available CPUs
	cpus := runtime.NumCPU()
	log.Printf("ProcessMapFiles: Available CPUs: %d", cpus)
	maxWorkers := cpus / 2
	if maxWorkers < 1 {
		maxWorkers = 1 // Ensure at least one worker
	}
	log.Printf("ProcessMapFiles: Max workers: %d", maxWorkers)
	sem := make(chan struct{}, maxWorkers)

	for path, content := range inputs {
		if !shared.HasFileMapSupport(path) {
			mu.Lock()
			bodies[path] = "[NO MAP]"
			mu.Unlock()
			errCh <- nil
			continue
		} else if len(content) > shared.MaxContextMapSingleInputSize { // 1MB
			mu.Lock()
			bodies[path] = "[NO MAP - TOO LARGE]"
			mu.Unlock()
			errCh <- nil
			continue
		}

		sem <- struct{}{}
		go func(path, content string) {
			defer func() { <-sem }()
			fileMap, err := MapFile(ctx, path, []byte(content))
			if err != nil {
				errCh <- fmt.Errorf("error mapping file %s: %v", path, err)
				return
			}
			mu.Lock()
			defer mu.Unlock()
			bodies[path] = fileMap.String()
			errCh <- nil
		}(path, content)
	}

	for i := 0; i < len(inputs); i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	return bodies, nil
}

type MapTrees map[string]string

func ProcessMapTrees(ctx context.Context, inputs map[string]string) (MapTrees, error) {
	trees := make(MapTrees, len(inputs))
	var mu sync.Mutex
	errCh := make(chan error, len(inputs))

	for path, content := range inputs {
		go func(path, content string) {
			// Get appropriate parser
			var parser *tree_sitter.Parser
			file := filepath.Base(path)
			if strings.Contains(strings.ToLower(file), "dockerfile") {
				parser = syntax.GetParserForLanguage(shared.LanguageDockerfile)
			} else {
				parser, _, _, _ = syntax.GetParserForPath(path)

				if parser == nil {
					errCh <- fmt.Errorf("unsupported file type: %s", path)
					return
				}
			}

			contentBytes := []byte(content)

			// Parse file
			tree, err := parser.ParseCtx(ctx, nil, contentBytes)
			if err != nil {
				errCh <- fmt.Errorf("failed to parse file: %v", err)
				return
			}
			defer tree.Close()

			mu.Lock()
			defer mu.Unlock()
			trees[path] = string(tree.RootNode().String())
			errCh <- nil
		}(path, content)
	}

	for i := 0; i < len(inputs); i++ {
		err := <-errCh
		if err != nil {
			return nil, err
		}
	}

	return trees, nil
}

func (m MapTrees) CombinedTrees() string {
	var combinedMap strings.Builder
	paths := make([]string, 0, len(m))
	for path := range m {
		paths = append(paths, path)
	}
	sort.Strings(paths)
	for _, path := range paths {
		body := m[path]
		body = strings.TrimSpace(body)
		fileHeading := fmt.Sprintf("\n### %s\n", path)
		combinedMap.WriteString(fileHeading)
		if body == "" {
			combinedMap.WriteString("[NO MAP]\n")
		} else {
			combinedMap.WriteString(body)
		}
		combinedMap.WriteString("\n")
	}
	return combinedMap.String()
}


================================================
FILE: app/server/syntax/file_map/nodes_config.go
================================================
package file_map

import shared "plandex-shared"

type nodeType string

type matchType string

const (
	matchTypeEqual  matchType = "equal"
	matchTypePrefix matchType = "prefix"
	matchTypeSuffix matchType = "suffix"
)

type langSet map[shared.Language]bool

type nodeConfig struct {
	nodeMatch    matchType
	ignore       bool
	all          bool
	except       langSet
	languages    langSet
	onlyChildren map[nodeType]bool
	skipForward  map[nodeType]bool
}

type nodeMap map[nodeType]nodeConfig

var assignmentNodeMap = nodeMap{
	// Common patterns across many languages
	"assignment_expression": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"declaration": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"variable_declaration": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"variable_assignment": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},

	"const_spec": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},
	"var_spec": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},

	"lexical_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJavascript: true,
			shared.LanguageTypescript: true,
			shared.LanguageJsx:        true,
			shared.LanguageTsx:        true,
		},
	},

	"field_definition": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJavascript: true,
			shared.LanguageTypescript: true,
			shared.LanguageJsx:        true,
			shared.LanguageTsx:        true,
		},
	},

	"interface_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp: true,
		},
	},

	"trait_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp: true,
		},
	},

	"enum_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp:    true,
			shared.LanguageCsharp: true,
		},
	},

	"global_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp: true,
		},
	},
	"static_variable_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp: true,
		},
	},

	"type_alias_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageTsx:        true,
			shared.LanguageElm:        true,
		},
	},

	"assignment_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePython: true,
		},
	},

	"class_variable_assignment": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},
	"assignment": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},

	"let_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},
	"const_item": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"static_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJava:   true,
			shared.LanguageCsharp: true,
		},
	},
	"member_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJava:   true,
			shared.LanguageCsharp: true,
		},
	},
	"field_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJava:   true,
			shared.LanguageCsharp: true,
		},
	},

	"property_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageKotlin: true,
			shared.LanguageScala:  true,
			shared.LanguagePhp:    true,
			shared.LanguageSwift:  true,
		},
	},

	"let_binding": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageOCaml: true,
		},
	},
	"value_binding": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageOCaml: true,
		},
	},

	"unary_operator": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElixir: true,
		},
	},

	"value_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElm: true,
		},
	},

	"declaration_command": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageBash: true,
		},
	},

	"type_item": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"val_definition": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},

	"type_definition": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},

	"typealias_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageSwift: true,
		},
	},

	"_field_definition": {
		nodeMatch: matchTypeSuffix,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJavascript: true,
			shared.LanguageJsx:        true,
		},
	},
}

var definitionNodeMap = nodeMap{
	// Common patterns across languages
	"_definition": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"_declaration": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"_declarator": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"_spec": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"_binding": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"_signature": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"declaration": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"_specifier": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"interface_": {
		nodeMatch: matchTypePrefix,
		all:       true,
	},

	// Language-specific definitions
	"def": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},
	"method": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},
	"defmodule": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElixir: true,
		},
	},
	"defmacro": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElixir: true,
		},
	},
	"port": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElm: true,
		},
	},
	"functor": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageOCaml: true,
		},
	},
	"_def": {
		nodeMatch: matchTypeSuffix,
		languages: langSet{
			shared.LanguageC:   true,
			shared.LanguageCpp: true,
		},
	},
	"type_annotation": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElm: true,
		},
	},
	"function_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageLua: true,
		},
	},
	"rule_set": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageCss: true,
		},
	},
	"from_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},
	"entrypoint_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},
	"cmd_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},
	"expose_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},
	"copy_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},
	"env_instruction": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageDockerfile: true,
		},
	},

	// Ignored patterns
	"import_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"require_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"use_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"namespace_use_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"using_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"include_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"package_": {
		nodeMatch: matchTypePrefix,
		ignore:    true,
		all:       true,
	},
	"_include": {
		nodeMatch: matchTypeSuffix,
		ignore:    true,
		languages: langSet{
			shared.LanguageC:   true,
			shared.LanguageCpp: true,
		},
	},
	"_item": {
		nodeMatch: matchTypeSuffix,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},
}

var parentNodeMap = nodeMap{
	// Common patterns
	"class_": {
		nodeMatch: matchTypePrefix,
		all:       true,
	},
	"module_": {
		nodeMatch: matchTypePrefix,
		all:       true,
	},
	"namespace_": {
		nodeMatch: matchTypePrefix,
		all:       true,
	},

	// Language-specific parents
	"object": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},
	"object_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageKotlin: true,
		},
	},
	"protocol": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageSwift: true,
		},
	},
	"protocol_": {
		nodeMatch: matchTypePrefix,
		languages: langSet{
			shared.LanguageElixir: true,
		},
	},
	"extension": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageSwift: true,
		},
	},

	"const_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},

	"var_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},

	"template_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageCpp: true,
		},
	},

	"export_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
		onlyChildren: map[nodeType]bool{
			"lexical_declaration":    true,
			"variable_declaration":   true,
			"type_alias_declaration": true,
			"interface_declaration":  true,
			"enum_declaration":       true,
			"class_declaration":      true,
			"function_declaration":   true,
			"arrow_function":         true,
		},
	},

	"module": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},

	"class": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},

	"singleton_class": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},

	"enum_entry": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageKotlin: true,
		},
	},

	"closure": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGroovy: true,
		},
	},

	"impl_item": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"trait_item": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"trait_definition": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},

	"object_definition": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},

	"function_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageLua: true,
		},
		onlyChildren: map[nodeType]bool{
			"function_statement": true,
		},
	},

	"internal_module": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
	},

	"expression_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
		onlyChildren: map[nodeType]bool{
			"internal_module": true,
		},
	},

	"ambient_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageTsx:        true,
		},
	},

	"interface_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageTsx:        true,
		},
	},
}

var implBoundaryNodeMap = nodeMap{
	// Common patterns
	"block": {
		nodeMatch: matchTypeEqual,
		all:       true,
		except: langSet{
			shared.LanguageRuby:   true,
			shared.LanguageElixir: true,
		},
	},
	"body": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"_body": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},
	"compound_statement": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},

	// Language-specific boundaries
	"do_block": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby:   true,
			shared.LanguageElixir: true,
		},
	},
	"body_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},
	"field_declaration_list": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo:  true,
			shared.LanguageC:   true,
			shared.LanguageCpp: true,
		},
	},
	"property_accessors": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageCsharp: true,
			shared.LanguageSwift:  true,
		},
	},
	"const_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},
	"var_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},
	"method_elem": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageGo: true,
		},
	},

	"preproc_arg": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageC:   true,
			shared.LanguageCpp: true,
		},
	},

	"statement_block": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageJavascript: true,
			shared.LanguageTypescript: true,
			shared.LanguageJsx:        true,
			shared.LanguageTsx:        true,
		},
	},

	"declaration_list": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp:    true,
			shared.LanguageCsharp: true,
			shared.LanguageRust:   true,
		},
	},

	"_declaration_list": {
		nodeMatch: matchTypeSuffix,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"enum_variant_list": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRust: true,
		},
	},

	"=": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageScala: true,
		},
	},
}

var assignmentBoundaryNodeMap = nodeMap{
	"=": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	":=": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"<-": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"expression": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"interface_body": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageTsx:        true,
		},
	},
	"declaration_list": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp:    true,
			shared.LanguageCsharp: true,
		},
	},
	"_declaration_list": {
		nodeMatch: matchTypeSuffix,
		languages: langSet{
			shared.LanguagePhp:    true,
			shared.LanguageCsharp: true,
		},
	},
	"lambda_literal": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageKotlin: true,
		},
	},
	"arguments": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElixir: true,
		},
	},
	"eq": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageElm: true,
		},
	},
	"statements": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageSwift: true,
		},
	},
}

var assignmentBoundarySkipForwardNodeMap = nodeMap{
	"=": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
		skipForward: map[nodeType]bool{
			"statement_block": true,
			"=>":              true,
		},
	},
}

var identifierNodeMap = nodeMap{
	// Common patterns
	"identifier": {
		nodeMatch: matchTypeEqual,
		all:       true,
	},
	"_identifier": {
		nodeMatch: matchTypeSuffix,
		all:       true,
	},

	// Language-specific identifiers
	"constant": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageRuby: true,
		},
	},
	"name": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguagePhp: true,
		},
	},
	"bare_key": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageToml: true,
			shared.LanguageYaml: true,
		},
	},
}

var passThroughParentNodeMap = nodeMap{
	"template_declaration": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageCpp: true,
		},
	},
	"export_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
	},
	"expression_statement": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageTypescript: true,
			shared.LanguageJavascript: true,
			shared.LanguageTsx:        true,
			shared.LanguageJsx:        true,
		},
		onlyChildren: map[nodeType]bool{
			"internal_module": true,
		},
	},
}

var includeAndContinueNodeMap = nodeMap{
	"template_parameter_list": {
		nodeMatch: matchTypeEqual,
		languages: langSet{
			shared.LanguageCpp: true,
		},
	},
}


================================================
FILE: app/server/syntax/file_map/nodes_find.go
================================================
package file_map

import (
	"fmt"
	"strings"

	shared "plandex-shared"
)

func isDefinitionNode(node Node, parentNode *Node) bool {
	setNodeType(&node)

	res := false

	config := definitionNodeMap.getConfig(node.Type, node.Lang)

	var parentConfig *nodeConfig
	if parentNode != nil {
		parentConfig = parentNodeMap.getConfig(parentNode.Type, parentNode.Lang)
	}

	if config == nil {
		res = isAssignmentNode(node) || isParentNode(node)
		if res && parentConfig != nil && parentConfig.onlyChildren != nil {
			res = parentConfig.onlyChildren[nodeType(node.Type)]
		}
		return res
	}

	res = !config.ignore
	if res {
		if parentConfig != nil && parentConfig.onlyChildren != nil {
			res = parentConfig.onlyChildren[nodeType(node.Type)]
		}
	}
	return res
}

func isAssignmentNode(node Node) bool {
	setNodeType(&node)
	config := assignmentNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isParentNode(node Node) bool {
	setNodeType(&node)
	config := parentNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isImplBoundaryNode(node Node) bool {
	setNodeType(&node)
	config := implBoundaryNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isAssignmentBoundaryNode(node Node) bool {
	setNodeType(&node)
	config := assignmentBoundaryNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isIdentifierNode(node Node) bool {
	setNodeType(&node)
	config := identifierNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isPassThroughParentNode(node Node) bool {
	setNodeType(&node)
	config := passThroughParentNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func isIncludeAndContinueNode(node Node) bool {
	setNodeType(&node)
	config := includeAndContinueNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return false
	}
	return !config.ignore
}

func (m nodeMap) getConfig(t string, lang shared.Language) *nodeConfig {
	// first look for exact match
	config, ok := m[nodeType(t)]
	if ok {
		if config.all {
			if config.except == nil || !config.except[lang] {
				return &config
			}
		}

		if config.languages != nil && config.languages[lang] {
			return &config
		}
	}

	// then look for prefix or suffix match
	var foundConfig *nodeConfig
	for k, config := range m {
		var maybeConfig *nodeConfig
		if config.nodeMatch == matchTypePrefix && strings.HasPrefix(t, string(k)) {
			maybeConfig = &config
		} else if config.nodeMatch == matchTypeSuffix && strings.HasSuffix(t, string(k)) {
			maybeConfig = &config
		}

		var wouldSet *nodeConfig
		if maybeConfig != nil {
			if maybeConfig.all {
				if maybeConfig.except == nil || !maybeConfig.except[lang] {
					wouldSet = maybeConfig
				}
			} else if maybeConfig.languages != nil && maybeConfig.languages[lang] {
				wouldSet = maybeConfig
			}
		}

		if wouldSet != nil {
			if foundConfig != nil {
				// ignore takes precedence
				if wouldSet.ignore {
					foundConfig = wouldSet
				}
			} else {
				foundConfig = wouldSet
			}
		}
	}

	return foundConfig
}

func findImplementationBoundary(node Node) *Node {
	if isImplBoundaryNode(node) {
		return &node
	}

	for i := 0; i < int(node.TsNode.ChildCount()); i++ {
		child := node.TsNode.Child(i)

		if verboseLogging {
			fmt.Println("  findImplementationBoundary child", child.Type())
		}

		childNode := Node{
			Type:   child.Type(),
			Lang:   node.Lang,
			TsNode: child,
			Bytes:  node.Bytes,
		}

		if isImplBoundaryNode(childNode) {
			return &childNode
		} else {
			found := findImplementationBoundary(childNode)
			if found != nil {
				return found
			}
		}
	}
	return nil
}

func findIdentifier(node Node) []Node {
	if isIdentifierNode(node) {
		return []Node{node}
	}

	nodes := []Node{}
	for i := 0; i < int(node.TsNode.ChildCount()); i++ {
		child := node.TsNode.Child(i)
		childNode := Node{
			Type:   child.Type(),
			Lang:   node.Lang,
			TsNode: child,
			Bytes:  node.Bytes,
		}

		if verboseLogging {
			fmt.Println("  child", child.Type())
		}

		found := findIdentifier(childNode)
		if found != nil {
			nodes = append(nodes, found...)
		}
	}
	return nodes
}

func firstDefinitionChild(node Node) *Node {
	for i := 0; i < int(node.TsNode.ChildCount()); i++ {
		child := node.TsNode.Child(i)

		if verboseLogging {
			fmt.Println("  child", child.Type())
		}

		childNode := Node{
			Type:   child.Type(),
			Lang:   node.Lang,
			TsNode: child,
			Bytes:  node.Bytes,
		}

		if isDefinitionNode(childNode, &node) && !isIncludeAndContinueNode(childNode) {
			return &childNode
		}
	}
	return nil
}

func findAssignmentBoundary(node Node) *Node {
	return findAssignmentBoundaryOnly(node, nil)
}

func findAssignmentBoundaryOnly(node Node, only map[nodeType]bool) *Node {
	if only != nil {
		if _, ok := only[nodeType(node.Type)]; ok {
			return &node
		}
	} else if isAssignmentBoundaryNode(node) {
		return skipForwardIfNeeded(node)
	}

	for i := 0; i < int(node.TsNode.ChildCount()); i++ {
		child := node.TsNode.Child(i)

		childNode := Node{
			Type:   child.Type(),
			Lang:   node.Lang,
			TsNode: child,
			Bytes:  node.Bytes,
		}

		if verboseLogging {
			fmt.Println("  child", child.Type())
		}

		found := findAssignmentBoundaryOnly(childNode, only)
		if found != nil {
			return found
		}
	}
	return nil
}

func skipForwardIfNeeded(node Node) *Node {
	config := assignmentBoundarySkipForwardNodeMap.getConfig(node.Type, node.Lang)
	if config == nil {
		return &node
	}

	if config.skipForward != nil {
		tsParent := node.TsNode.Parent()
		if tsParent == nil {
			return &node
		}

		parent := Node{
			Type:   tsParent.Type(),
			Lang:   node.Lang,
			TsNode: tsParent,
			Bytes:  node.Bytes,
		}

		skipToNode := findAssignmentBoundaryOnly(parent, config.skipForward)
		if skipToNode != nil {
			return skipToNode
		}
	}
	return &node
}

func setNodeType(node *Node) {
	if node.Lang == shared.LanguageElixir && node.Type == "call" {
		content := node.TsNode.Content(node.Bytes)

		switch {
		case strings.HasPrefix(string(content), "defmodule"):
			node.Type = "module_definition"
		case strings.HasPrefix(string(content), "defprotocol"):
			node.Type = "protocol_definition"
		case strings.HasPrefix(string(content), "defimpl"):
			node.Type = "protocol_implementation"
		case strings.HasPrefix(string(content), "defstruct"):
			node.Type = "struct_definition"
		case strings.HasPrefix(string(content), "defexception"):
			node.Type = "exception_definition"
		case strings.HasPrefix(string(content), "defdelegate"):
			node.Type = "delegate_definition"
		case strings.HasPrefix(string(content), "defoverridable"):
			node.Type = "overridable_definition"
		case strings.HasPrefix(string(content), "defcallback"):
			node.Type = "callback_definition"
		case strings.HasPrefix(string(content), "defmacrocallback"):
			node.Type = "macro_callback_definition"
		case strings.HasPrefix(string(content), "defmacrop"):
			node.Type = "private_macro_definition"
		case strings.HasPrefix(string(content), "defmacro"):
			node.Type = "macro_definition"
		case strings.HasPrefix(string(content), "defguardp"):
			node.Type = "private_guard_definition"
		case strings.HasPrefix(string(content), "defguard"):
			node.Type = "guard_definition"
		case strings.HasPrefix(string(content), "defp"):
			node.Type = "private_function_definition"
		case strings.HasPrefix(string(content), "def"):
			node.Type = "function_definition"
		}
	}
}


================================================
FILE: app/server/syntax/file_map/svelte.go
================================================
package file_map

import (
	"bytes"
	"context"
	"fmt"
	"log"
	"plandex-server/syntax"
	"strings"

	shared "plandex-shared"

	"golang.org/x/net/html"
)

func mapSvelte(content []byte) []Definition {
	scriptContent, scriptLang, styleContent := getSvelteScriptAndStyle(content)
	defs := []Definition{}

	if scriptContent != "" {
		var lang shared.Language
		if scriptLang == "ts" {
			lang = shared.LanguageTypescript
		} else {
			lang = shared.LanguageJavascript
		}

		parser := syntax.GetParserForLanguage(lang)
		tree, err := parser.ParseCtx(context.Background(), nil, []byte(scriptContent))
		if err != nil {
			log.Printf("mapSvelte - error parsing script content: %v\n", err)
			return defs
		}

		def := Definition{
			Type:      "svelte-script",
			Signature: fmt.Sprintf("<script lang=%q>", scriptLang),
			Children: mapTraditional(Node{
				Lang:   lang,
				TsNode: tree.RootNode(),
				Bytes:  []byte(scriptContent),
			}, nil),
		}

		defs = append(defs, def)
	}

	defs = append(defs, mapMarkup(content)...)

	if styleContent != "" {
		parser := syntax.GetParserForLanguage(shared.LanguageCss)
		tree, err := parser.ParseCtx(context.Background(), nil, []byte(styleContent))
		if err != nil {
			log.Printf("mapSvelte - error parsing style content: %v\n", err)
			return defs
		}

		def := Definition{
			Type:      "svelte-style",
			Signature: "<style>",
			Children: mapTraditional(Node{
				Lang:   shared.LanguageCss,
				TsNode: tree.RootNode(),
				Bytes:  []byte(styleContent),
			}, nil),
		}

		defs = append(defs, def)
	}

	return defs
}

func getSvelteScriptAndStyle(content []byte) (scriptContent, scriptLang, styleContent string) {
	reader := bytes.NewReader(content)
	doc, err := html.Parse(reader)
	if err != nil {
		return "", "", ""
	}

	// Helper function to extract text content from a node
	var getTextContent func(*html.Node) string
	getTextContent = func(n *html.Node) string {
		if n.Type == html.TextNode {
			return n.Data
		}
		var result string
		for c := n.FirstChild; c != nil; c = c.NextSibling {
			result += getTextContent(c)
		}
		return result
	}

	// Helper function to find script and style tags
	var findTags func(*html.Node)
	findTags = func(n *html.Node) {
		if n.Type == html.ElementNode {
			if n.Data == "script" {
				scriptContent = strings.TrimSpace(getTextContent(n))
				// Check for lang attribute
				for _, attr := range n.Attr {
					if attr.Key == "lang" {
						scriptLang = attr.Val
						break
					}
				}
			} else if n.Data == "style" {
				styleContent = strings.TrimSpace(getTextContent(n))
			}
		}

		// Recursively search children
		for c := n.FirstChild; c != nil; c = c.NextSibling {
			findTags(c)
		}
	}

	findTags(doc)
	return scriptContent, scriptLang, styleContent
}


================================================
FILE: app/server/syntax/map.txt
================================================
### ../examples/bash_example.sh
function print_message()
get_date()
main()

### ../examples/c_example.c
#define MAX_SIZE
#define SQUARE(x)
typedef struct
typedef enum {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY
} Weekday;
static const double PI
int globalCounter
void printPerson(const Person* p
int factorial(int n
union Data
typedef int (*Operation)(int, int);
int add(int a, int b)
int subtract(int a, int b)
void printPerson(const Person* p)
int factorial(int n)
int main()

### ../examples/cpp_example.cpp
int globalInteger
const double PI
static std::string globalString
enum Color { RED, GREEN, BLUE }
constexpr int MAX_SIZE
template<typename T>
  - class Container
    - public
    - static T defaultValue;
    - const T maxCapacity = MAX_SIZE;
    - void add(T item)
    - const std::vector<T>& getItems() const
    - private
    - std::vector<T> items;
template<typename T>
  - T Container<T>::defaultValue
class Animal
  - public
  - virtual ~Animal() = default;
  - virtual void makeSound() const = 0;
  - protected
  - std::string name;
class Dog : virtual public Animal
  - public
  - Dog(const std::string& dogName)
  - void makeSound() const override
namespace Utils {
    // Namespace-level variables
    inline int counter = 0;
    const std::string VERSION = "1.0.0";
    
    // Function template
    template<typename T>
    T max(T a, T b)
class Resource
  - public
  - Resource(const std::string& data) : data_(data)
  - ~Resource()
  - Resource(Resource&& other) noexcept : data_(std::move(other.data_))
  - std::string getData() const
  - private
  - std::string data_;
class Counter
  - public
  - static int getCount()
  - Counter()
  - ~Counter()
  - private
  - static int count;
int Counter::count
class Box
  - friend std::ostream& operator<<(std::ostream& os, const Box& box);
  - public
  - Box(int w, int h) : width(w), height(h)
  - private
  - int width;
  - int height;
std::ostream& operator<<(std::ostream& os, const Box& box)
int main()

### ../examples/csharp_example.cs
namespace ExampleApp
{
    // Interface definition
    public interface IProcessor<T>
    {
        Task<T> ProcessAsync(T input);
        bool Validate(T input);
    }

    // Enum definition
    public enum Status
    {
        Pending,
        Active,
        Completed,
        Failed
    }

    // Delegate declaration
    public delegate void StatusChangedEventHandler(Status oldStatus, Status newStatus);

    // Generic class implementing interface
    public class DataProcessor<T> : IProcessor<T> where T : class
    {
        // Event declaration
        public event StatusChangedEventHandler StatusChanged;

        // Auto-implemented property
        public Status CurrentStatus { get; private set; }

        // Static field
        private static readonly Dictionary<Type, int> _processedItems = new();

        // Constructor
        public DataProcessor()

### ../examples/elm_example.elm
type alias Model =
    { users : List User
    , inputText : String
    , error : Maybe String
    }
type alias User =
    { id : Int
    , name : String
    , email : String
    }
init _ =
    ( { users = []
      , inputText = ""
      , error = Nothing
      }
    , fetchUsers
    )
type Msg
    = GotUsers (Result Http.Error (List User))
    | InputChanged String
    | AddUser
    | UserAdded (Result Http.Error User)
update msg model =
    case msg of
        GotUsers result ->
            case result of
                Ok users ->
                    ( { model | users = users, error = Nothing }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to fetch users" }
                    , Cmd.none
                    )

        InputChanged text ->
            ( { model | inputText = text }
            , Cmd.none
            )

        AddUser ->
            ( model
            , addUser model.inputText
            )

        UserAdded result ->
            case result of
                Ok user ->
                    ( { model 
                      | users = user :: model.users
                      , inputText = ""
                      , error = Nothing
                      }
                    , Cmd.none
                    )
                Err _ ->
                    ( { model | error = Just "Failed to add user" }
                    , Cmd.none
                    )
fetchUsers =
    Http.get
        { url = "/api/users"
        , expect = Http.expectJson GotUsers usersDecoder
        }
addUser name =
    Http.post
        { url = "/api/users"
        , body = Http.jsonBody (userEncoder name)
        , expect = Http.expectJson UserAdded userDecoder
        }
userEncoder name =
    Encode.object
        [ ("name", Encode.string name)
        ]
userDecoder =
    Decode.map3 User
        (Decode.field "id" Decode.int)
        (Decode.field "name" Decode.string)
        (Decode.field "email" Decode.string)
usersDecoder =
    Decode.list userDecoder
view model =
    div []
        [ h1 [] [ text "User Management" ]
        , viewError model.error
        , viewInput model.inputText
        , viewUsers model.users
        ]
viewError maybeError =
    case maybeError of
        Just error ->
            div [ class "error" ] [ text error ]
        Nothing ->
            text ""
viewInput inputText =
    div []
        [ input
            [ value inputText
            , onInput InputChanged
            , placeholder "Enter user name"
            ] []
        , button [ onClick AddUser ] [ text "Add User" ]
        ]
viewUsers users =
    div []
        [ h2 [] [ text "Users" ]
        , ul [] (List.map viewUser users)
        ]
viewUser user =
    li []
        [ text (user.name ++ " (" ++ user.email ++ ")")
        ]
main =
    Browser.element
        { init = init
        , update = update
        , view = view
        , subscriptions = \_ -> Sub.none
        }

### ../examples/go_example.go
type DataProcessor interface {
type ValidationError struct
func (e *ValidationError) Error() string
type User struct
type UserID = int64
const (
  - MaxRetries
  - DefaultLimit
const
  - singleLineConst string
var (
  - defaultTimeout
  - processor      DataProcessor
var
  - singleLineVar string
type Result[T any] struct
type UserProcessor struct
func NewUserProcessor() *UserProcessor
func (p *UserProcessor) Process(ctx context.Context, data interface{}) error
func (p *UserProcessor) Validate(data interface{}) bool
func processUsers(ctx context.Context, users <-chan *User) <-chan *Result[*User]
func createUser(name, email string) (user *User, err error)
func main()

### ../examples/groovy_example.groovy
trait Loggable
abstract class
class Car extends Vehicle implements Loggable {
    // Properties with type definitions
    private BigDecimal price
    protected Boolean running = false
    
    // Static fields
    static final String MANUFACTURER = "Generic Motors"
    static def carCount = 0
    
    // Constructor with default parameters
Car(String make = 'Unknown', String model = 'Generic', Integer year = 2024) {
    this.make = make
    this.model = model
    this.year = year
    carCount++
}
    
    // Getter with @Lazy annotation
    @Lazy
    String fullName = "$make $model ($year)"
    
    // Method implementation with closure parameter
    void start() {
        running = true
        log "Starting ${fullName}"
        withLock {
            // Some synchronized code
            println "Engine started"
        }
    }
    
    void stop() {
        running = false
        log "Stopping ${fullName}"
    }
    
    // Operator overloading
    def plus(Car other) {
        new Car(
make: "${this.make}-${other.make}",
model: "${this.model}-${other.model}",
year: Math.max(this.year, other.year)
        )
    }
    
    // Property with custom getter/setter
    private BigDecimal _price
    void setPrice(BigDecimal price) {
        if (price < 0) throw new IllegalArgumentException("Price cannot be negative")
        this._price = price
    }
    BigDecimal getPrice() { _price }
}
enum Status
class StringExtensions {
    static String truncate(String self, Integer length) {
        self.size() <= length ? self : self[0..<length] + "..."
    }
}
class EmailBuilder {
    private def email = [:]
    
    EmailBuilder to(String recipient) {
        email.to = recipient
        this
    }
    
    EmailBuilder from(String sender) {
        email.from = sender
        this
    }
    
    EmailBuilder subject(String subject) {
        email.subject = subject
        this
    }
    
    EmailBuilder body(@DelegatesTo(strategy=Closure.DELEGATE_FIRST) Closure body) {
        def builder = new StringBuilder()
        body.delegate = builder
        body.resolveStrategy = Closure.DELEGATE_FIRST
        body()
        email.body = builder.toString()
        this
    }
    
    Map build() {
        email.clone() as Map
    }
}
def main() {
    use(StringExtensions) {
        def description = "This is a very long description that needs truncating"
        println description.truncate(20)
    }
    
    def car = new Car(make: "Tesla", model: "Model S")
    car.start()
def email = new EmailBuilder()
    .to("recipient@example.com")
    .from("sender@example.com")
    .subject("Test Email")
    .body {
        append "Hello,\n"
        append "This is a test email.\n"
        append "Regards"
    }
    .build()
    .build()
    
    println email
}

### ../examples/java_example.java
interface DataProcessor<T extends Comparable<T>>
  - CompletableFuture<T> processAsync(T input);
  - boolean validate(T input);
enum Status
abstract class BaseEntity<ID>
  - protected ID id
  - protected LocalDateTime createdAt
  - protected LocalDateTime updatedAt
  - public abstract void validate();
record UserDTO(
    String name,
    String email,
    Set<String> roles
)
@interface Audited
public class Example extends BaseEntity<UUID> implements DataProcessor<String>
  - private static final int MAX_RETRIES
  - private static final Map<String, Integer> CACHE
  - private final Queue<String> queue
  - protected Status status
  - @Audited
    public String name
  - private Example(Builder builder)
  - public static class Builder
    - private String name
    - public Builder name(String name)
    - public Example build()
  - @Override
    public CompletableFuture<String> processAsync(String input)
  - @Override
    public boolean validate(String input)
  - @Override
    public void validate()
  - public <T extends Comparable<? super T>> List<T> sort(Collection<T> items)
  - public void processItems(
        List<String> items,
        Predicate<String> filter,
        Consumer<String> processor
    )
  - public static class ProcessingException extends RuntimeException
    - public ProcessingException(String message)
  - public static void main(String[] args)

### ../examples/javascript_example.js
const MAX_RETRIES
const DEFAULT_TIMEOUT
const privateState
class DataProcessor extends EventEmitter
  - #cache
  - static version
  - constructor({ maxRetries = MAX_RETRIES, timeout = DEFAULT_TIMEOUT } = {})
  - async processData(data)
  - async #validateAndTransform(data)
  - *iterateCache()
function deprecated(target, context)
const handler
const proxy
const delay
async function* generateSequence(start, end)
const memoize
class ValidationError extends Error
  - constructor(message, field)
const config
const processItems
const fetchData

### ../examples/kotlin_example.kt
interface DataProcessor<T>
  - suspend fun process(data: T): Result<T>
  - fun validate(data: T): Boolean
sealed class ProcessingState<out T>
  - object Loading : ProcessingState<Nothing>()
  - data class Success<T>(val data: T) : ProcessingState<T>()
  - data class Error(val exception: Throwable) : ProcessingState<Nothing>()
data class User(
    val id: String,
    val name: String,
    val email: String,
    val roles: Set<Role> = emptySet(),
    val createdAt: LocalDateTime = LocalDateTime.now()
)
enum class Role(val permission: Int)
object Configuration
class UserProcessor : DataProcessor<User>
  - private var processingCount: Int by Delegates.observable(0) { _, old, new ->
        println("Processing count changed from $old to $new
  - val isActive: Boolean
  - override suspend fun process(data: User): Result<User>
  - override fun validate(data: User): Boolean
  - private fun String.isValidEmail(): Boolean
  - inline fun <reified T> logType()
  - private fun validateEmail(email: String)
fun <T> withRetry(
    times: Int = 3,
    action: suspend () -> T
): suspend () -> T
fun CoroutineScope.processUsers(users: List<User>): Flow<ProcessingState<User>>
val User.displayName: String
suspend fun main()

### ../examples/lua_example.lua
local Example
local MAX_RETRIES
local DEFAULT_TIMEOUT
local User
local DataStore
local EventEmitter
Example.User
Example.EventEmitter

### ../examples/ocaml_example.ml
type 'a = string
type t = {
    mutable processed_count: int;
    created_at: float;
  }
let create () = {
    processed_count = 0;
    created_at = Unix.time ();
  }
let process t input =
    t.processed_count <- t.processed_count + 1;
    if String.length input > 0 then
      Ok (String.uppercase_ascii input)
    else
      Error "Empty input"
let validate input =
    String.length input > 0
end
type user = {
  id: int;
  name: string;
  email: string;
  created_at: float;
}
type 'a result = 
  | Success of 'a 
  | Error of string
type message =
  | Text of string
  | Number of int
  | Tuple of string * int
  | Record of user
exception ValidationError of string
let memoize f =
  let cache = Hashtbl.create 16 in
  fun x ->
    try Hashtbl.find cache x
    with Not_found ->
      let result = f x in
      Hashtbl.add cache x result;
      result
class virtual ['a] queue = object(self)
  val mutable items = []
  
  method virtual push : 'a -> unit
  method virtual pop : 'a option
  
  method size = List.length items
  
  method is_empty = items = []
  
  method protected get_items = items
  method protected set_items new_items = items <- new_items
end
class ['a] fifo_queue = object(self)
  inherit ['a] queue

  method push item =
    self#set_items (self#get_items @ [item])

  method pop =
    match self#get_items with
    | [] -> None
    | hd::tl ->
        self#set_items tl;
        Some hd
end
let () =
  let processor = StringProcessor.create () in
  let result = StringProcessor.process processor "hello world" in
  match result with
  | Ok processed -> Printf.printf "Processed: %s\n" processed
  | Error msg -> Printf.eprintf "Error: %s\n" msg;

  let queue = new fifo_queue in
  queue#push 1;
  queue#push 2;
  queue#push 3;
  
  let rec print_queue () =
    match queue#pop with
    | Some item -> 
        Printf.printf "Item: %d\n" item;
        print_queue ()
    | None -> ()
  in
  print_queue ()

### ../examples/php_example.php
namespace Example;
interface DataProcessor
trait Loggable
abstract class Entity implements JsonSerializable
  - protected DateTime $createdAt
  - protected ?DateTime $updatedAt
  - public function __construct()
  - abstract public function validate(): bool;
  - public function jsonSerialize(): mixed
enum Status: string
class User extends Entity implements DataProcessor
  - private static int $instanceCount
  - public function __construct(
        private string $name,
        private string $email,
        private Status $status = Status::PENDING,
        private array $metadata = []
    )
  - public static function getInstanceCount(): int
  - public function getEmail(): string
  - public function setEmail(string $email): void
  - public function __get(string $name)
  - public function __set(string $name, mixed $value): void
  - public function process(mixed $data): mixed
  - public function validate(mixed $data): bool
  - public function validate(): bool
  - public function getMetadataValues(): array
  - public function jsonSerialize(): mixed
class ProcessingException extends Exception
  - public function __construct(
        string $message = "",
        private ?string $errorCode = null,
        int $code = 0,
        ?Throwable $previous = null
    )
  - public function getErrorCode(): ?string

### ../examples/python_example.py
class Processable(Protocol):
  - def process(self) -> None:
  - def validate(self) -> bool:
class Status(enum.Enum):
  - def __str__(self) -> str:
@dataclasses.dataclass(frozen=True, slots=True)
class UserCredentials:
class BaseProcessor(ABC, Generic[T]):
  - def __init__(self) -> None:
  - @abstractmethod
    async def process_item(self, item: T) -> None:
  - @property
    def processed_count(self) -> int:
def log_execution(func: Callable) -> Callable:
class DataProcessor(BaseProcessor[UserCredentials], Processable):
    # Class variable
  - def __init__(self, batch_size: Optional[int] = None) -> None:
  - @property
    def status(self) -> Status:
  - @status.setter
    def status(self, value: Status) -> None:
  - async def __aenter__(self) -> DataProcessor:
  - async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
  - async def process_batch(self) -> AsyncIterator[List[UserCredentials]]:
  - @log_execution
    async def process_item(self, item: UserCredentials) -> None:
  - def process(self) -> None:
  - def validate(self) -> bool:
class ProcessingError(Exception):
  - def __init__(self, message: str, item: Any) -> None:
async def main() -> None:

### ../examples/ruby_example.rb
global_var
module Loggable
  - def log(message)
module Utils
  - class << self
    - def generate_id
class BaseProcessor
  - @processors
  - class << self
    - def register(processor)
  - def initialize
  - def process
class ProcessingError < StandardError
  - def initialize(message, item)
User
module Status
  - PENDING
  - ACTIVE
  - COMPLETED
  - FAILED
  - ALL
class DataProcessor < BaseProcessor
  # Constants
  - MAX_RETRIES
  - DEFAULT_TIMEOUT
  - @@instance_count
  - def initialize(options = {})
  - def add_item(item:, priority: :normal)
  - def validate_item(item)
  - def with_retry
  - def process_items
  - def process_item(item)
class Configuration
  - def initialize
  - def [](key)
  - def []=(key, value)

### ../examples/rust_example.rs
const MAX_RETRIES: u32
const DEFAULT_TIMEOUT: Duration

### ../examples/scala_example.scala
type Result[T] = Either[String, T]
trait DataProcessor[T]
case class ProcessingState[T](
  data: T,
  status: ProcessingState.Status,
  timestamp: Long = System.currentTimeMillis()
)
object ProcessingState
abstract class BaseProcessor[T] extends DataProcessor[T]
  - protected val logger = new Logger(getClass.getName)
  - protected def transform(data: T): T
  - override def process(data: T): Result[T] =
class NumberProcessor[T <: Number] extends BaseProcessor[T]
  - override def validate(data: T): Boolean = data != null
  - protected def transform(data: T): T = data
case class User(
  id: String,
  name: String,
  email: String,
  roles: Set[String] = Set.empty,
  metadata: Map[String, String] = Map.empty
)
object Utils
object Implicits
trait Logging
class Logger(name: String) extends Logging
  - def log(level: String, message: => String): Unit =
trait Monad[F[_]]
object Conversions
trait Container
class Box[T](initial: T) extends Container
  - type Content = T
  - def content: T = initial
  - def transform(f: T => T): Box[T] = new Box(f(initial))
object Main extends App

### ../examples/swift_example.swift
protocol DataProcessor
enum ProcessingError: LocalizedError
  - var errorDescription: String? {
        switch self {
        case .invalidInput(let reason): return "Invalid input: \(reason)"
        case .processingFailed(let reason): return "Processing failed: \(reason)"
        }
    }
@propertyWrapper
struct Validated<T>
  - private var value: T
  - private let validator: (T) -> Bool
  - var wrappedValue: T {
        get { value }
        set {
            guard validator(newValue) else {
                fatalError("Invalid value")
            }
            value = newValue
        }
    }
  - init(wrappedValue: T, validator: @escaping (T) -> Bool)
actor ProcessingState
  - private(set) var processedCount: Int = 0
  - private var status: Status = .pending
  - enum Status
  - func incrementCount()
  - func updateStatus(_ newStatus: Status)
struct Queue<Element> where Element: Sendable
  - private var elements: [Element] = []
  - private let lock = NSLock()
  - mutating func enqueue(_ element: Element)
  - mutating func dequeue() -> Element?
class StringProcessor: DataProcessor
  - typealias Input = String
  - typealias Output = String
  - private let state = ProcessingState()
  - @Validated(validator: { !$0.isEmpty })
    private var currentInput: String = "default"
  - func process(_ input: String) async throws -> String
  - func validate(_ input: String) -> Bool
extension StringProcessor: AsyncSequence, AsyncIteratorProtocol
  - typealias Element = String
  - func makeAsyncIterator() -> StringProcessor
  - func next() async throws -> String?
@resultBuilder
struct ArrayBuilder<T>
  - static func buildBlock(_ components: T...) -> [T]
func makeArray<T>(@ArrayBuilder<T> content: () -> [T]) -> [T]
@main
struct Example
  - static func main() async throws

### ../examples/tsx_example.tsx
interface User
type ValidationResult
interface DataListProps<T>
function useDebounce<T>(value: T, delay: number): T
function withLoading<P extends object>(
  WrappedComponent: React.ComponentType<P>
): FC<P & { loading?: boolean }>
const UserForm: FC<{ onSubmit: (user: Partial<User>) => void }>
const DataList
const App: FC

### ../examples/typescript_example.ts
interface DataProcessor<T>
type Result<T>
enum Status
type ValidationResult
type AdminUser
type Readonly<T>
type Partial<T>
function validate(target: any, propertyKey: string, descriptor: PropertyDescriptor)
@logger
class User
  - @required
    private name: string
  - @email
    private email: string
  - @format('YYYY-MM-DD')
    private createdAt: Date
  - constructor(name: string, email: string)
  - public updateEmail(newEmail: string): void
  - public get isAdmin(): this is AdminUser
abstract class BaseProcessor<T> implements DataProcessor<T>
class StringProcessor extends BaseProcessor<string>
  - async process(data: string): Promise<string>
  - private async transform(data: string): Promise<string>
function process(data: string): Promise<string>;
function process(data: number): Promise<number>;
function process(data: string | number): Promise<string | number>
async function validateData<T extends { id: string }>(
    data: T
): Promise<ValidationResult>
function withRetry<T>(
    fn: () => Promise<T>,
    retries: number = 3
): () => Promise<T>
type Middleware
const createUser
async function* generateSequence(
    start: number,
    end: number
): AsyncGenerator<number>
async function main()



================================================
FILE: app/server/syntax/parsers.go
================================================
package syntax

import (
	"path/filepath"
	"strings"

	tree_sitter "github.com/smacker/go-tree-sitter"
	"github.com/smacker/go-tree-sitter/bash"
	"github.com/smacker/go-tree-sitter/c"
	"github.com/smacker/go-tree-sitter/cpp"
	"github.com/smacker/go-tree-sitter/csharp"
	"github.com/smacker/go-tree-sitter/css"
	"github.com/smacker/go-tree-sitter/cue"
	"github.com/smacker/go-tree-sitter/dockerfile"
	"github.com/smacker/go-tree-sitter/elixir"
	"github.com/smacker/go-tree-sitter/elm"
	"github.com/smacker/go-tree-sitter/golang"
	"github.com/smacker/go-tree-sitter/groovy"
	"github.com/smacker/go-tree-sitter/hcl"
	"github.com/smacker/go-tree-sitter/html"
	"github.com/smacker/go-tree-sitter/java"
	"github.com/smacker/go-tree-sitter/javascript"
	"github.com/smacker/go-tree-sitter/kotlin"
	"github.com/smacker/go-tree-sitter/lua"
	"github.com/smacker/go-tree-sitter/ocaml"
	"github.com/smacker/go-tree-sitter/php"
	"github.com/smacker/go-tree-sitter/protobuf"
	"github.com/smacker/go-tree-sitter/python"
	"github.com/smacker/go-tree-sitter/ruby"
	"github.com/smacker/go-tree-sitter/rust"
	"github.com/smacker/go-tree-sitter/scala"
	"github.com/smacker/go-tree-sitter/svelte"
	"github.com/smacker/go-tree-sitter/swift"
	"github.com/smacker/go-tree-sitter/toml"
	"github.com/smacker/go-tree-sitter/typescript/tsx"
	"github.com/smacker/go-tree-sitter/typescript/typescript"
	"github.com/smacker/go-tree-sitter/yaml"

	shared "plandex-shared"
)

func GetLanguageForPath(path string) shared.Language {
	ext := filepath.Ext(path)
	lang, ok := shared.LanguageByExtension[ext]
	if !ok {
		if strings.Contains(strings.ToLower(path), "dockerfile") {
			return shared.LanguageDockerfile
		}
		if strings.Contains(strings.ToLower(path), "rakefile") {
			return shared.LanguageRuby
		}

		if strings.Contains(strings.ToLower(path), "gemfile") {
			return shared.LanguageRuby
		}

		if strings.Contains(strings.ToLower(path), "gemfile.lock") {
			return shared.LanguageRuby
		}

		if strings.Contains(strings.ToLower(path), "gemspec") {
			return shared.LanguageRuby
		}

		if strings.Contains(strings.ToLower(path), "guardfile") {
			return shared.LanguageRuby
		}

		return ""
	}
	return lang
}

func GetParserForPath(path string) (*tree_sitter.Parser, shared.Language, *tree_sitter.Parser, shared.Language) {
	lang := GetLanguageForPath(path)
	if lang == "" {
		return nil, "", nil, ""
	}

	parser := GetParserForLanguage(lang)

	ext := filepath.Ext(path)
	fallback := shared.LanguageFallbackByExtension[ext]
	var fallbackParser *tree_sitter.Parser
	if fallback != "" {
		fallbackParser = GetParserForLanguage(fallback)
	}

	return parser, lang, fallbackParser, fallback
}

func GetParserForLanguage(lang shared.Language) *tree_sitter.Parser {
	parser := tree_sitter.NewParser()
	switch lang {
	case shared.LanguageBash:
		parser.SetLanguage(bash.GetLanguage())
	case shared.LanguageC:
		parser.SetLanguage(c.GetLanguage())
	case shared.LanguageCpp:
		parser.SetLanguage(cpp.GetLanguage())
	case shared.LanguageCsharp:
		parser.SetLanguage(csharp.GetLanguage())
	case shared.LanguageCss:
		parser.SetLanguage(css.GetLanguage())
	case shared.LanguageCue:
		parser.SetLanguage(cue.GetLanguage())
	case shared.LanguageDockerfile:
		parser.SetLanguage(dockerfile.GetLanguage())
	case shared.LanguageElixir:
		parser.SetLanguage(elixir.GetLanguage())
	case shared.LanguageElm:
		parser.SetLanguage(elm.GetLanguage())
	case shared.LanguageGo:
		parser.SetLanguage(golang.GetLanguage())
	case shared.LanguageGroovy:
		parser.SetLanguage(groovy.GetLanguage())
	case shared.LanguageHcl:
		parser.SetLanguage(hcl.GetLanguage())
	case shared.LanguageHtml:
		parser.SetLanguage(html.GetLanguage())
	case shared.LanguageJava:
		parser.SetLanguage(java.GetLanguage())
	case shared.LanguageJavascript, shared.LanguageJson:
		parser.SetLanguage(javascript.GetLanguage())
	case shared.LanguageKotlin:
		parser.SetLanguage(kotlin.GetLanguage())
	case shared.LanguageLua:
		parser.SetLanguage(lua.GetLanguage())
	case shared.LanguageOCaml:
		parser.SetLanguage(ocaml.GetLanguage())
	case shared.LanguagePhp:
		parser.SetLanguage(php.GetLanguage())
	case shared.LanguageProtobuf:
		parser.SetLanguage(protobuf.GetLanguage())
	case shared.LanguagePython:
		parser.SetLanguage(python.GetLanguage())
	case shared.LanguageRuby:
		parser.SetLanguage(ruby.GetLanguage())
	case shared.LanguageRust:
		parser.SetLanguage(rust.GetLanguage())
	case shared.LanguageScala:
		parser.SetLanguage(scala.GetLanguage())
	case shared.LanguageSvelte:
		parser.SetLanguage(svelte.GetLanguage())
	case shared.LanguageSwift:
		parser.SetLanguage(swift.GetLanguage())
	case shared.LanguageToml:
		parser.SetLanguage(toml.GetLanguage())
	case shared.LanguageTypescript:
		parser.SetLanguage(typescript.GetLanguage())
	case shared.LanguageJsx, shared.LanguageTsx:
		parser.SetLanguage(tsx.GetLanguage())
	case shared.LanguageYaml:
		parser.SetLanguage(yaml.GetLanguage())
	default:
		return nil
	}
	return parser
}


================================================
FILE: app/server/syntax/structured_edits_apply.go
================================================
package syntax

import (
	"context"
	"fmt"
	"log"
	"regexp"
	"strconv"
	"strings"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
	sitter "github.com/smacker/go-tree-sitter"
)

// const duplicationThreshold = 20

type Reference int
type Removal int

type Anchor int

type NeedsVerifyReason string

const (
	NeedsVerifyReasonCodeRemoved       NeedsVerifyReason = "code_removed"
	NeedsVerifyReasonCodeDuplicated    NeedsVerifyReason = "code_duplicated"
	NeedsVerifyReasonAmbiguousLocation NeedsVerifyReason = "ambiguous_location"
)

type ApplyChangesResult struct {
	NewFile            string
	Proposed           string
	NeedsVerifyReasons []NeedsVerifyReason
	BlocksRemoved      []struct {
		Start   int
		End     int
		Content string
	}
	// Comments           []Comment
}

type AnchorMap = map[int]int

type ReferenceBlock struct {
	start int // Start line number in original file (inclusive)
	end   int // End line number in original file (inclusive)
}

type Comment struct {
	Txt   string
	IsRef bool
}

type RemovalRange struct {
	Start int
	End   int
}

func (r RemovalRange) Overlaps(other RemovalRange) bool {
	return (other.Start <= r.End && other.Start >= r.Start) ||
		(other.End <= r.End && other.End >= r.Start) ||
		(other.Start <= r.Start && other.End >= r.End)
}

const verboseLogging = false

func isRef(content string) bool {
	trimmedLower := strings.ToLower(strings.TrimSpace(content))
	if strings.Contains(trimmedLower, "... existing code ...") {
		return true
	}
	regex := regexp.MustCompile(`(\.\.\.)?.*?(existing|rest of|start of|end of).*?\.\.\.$`)
	return regex.MatchString(trimmedLower)
}

func isRemoval(content string) bool {
	return strings.Contains(strings.ToLower(content), "plandex: removed")
}

type ApplyChangesParams struct {
	Original               string
	Proposed               string
	Desc                   string
	AddMissingStartEndRefs bool
	Parser                 *sitter.Parser
	Language               shared.Language
}

func ApplyChanges(
	ctx context.Context,
	params ApplyChangesParams,
) *ApplyChangesResult {
	original := params.Original
	proposed := params.Proposed
	desc := params.Desc
	addMissingStartEndRefs := params.AddMissingStartEndRefs
	parser := params.Parser
	language := params.Language

	proposedInitial := proposed

	proposedLines := strings.Split(proposed, "\n")
	originalLines := strings.Split(original, "\n")

	var references []Reference
	hasRefByLine := map[int]bool{}

	var removals []Removal
	hasRemovalByLine := map[int]bool{}

	for i, line := range proposedLines {
		lineNum := i + 1
		content := strings.TrimSpace(line)
		found := false
		if isRef(content) {
			if !hasRefByLine[lineNum] {
				references = append(references, Reference(lineNum))
				hasRefByLine[lineNum] = true
			}
			found = true
		} else if isRemoval(content) {
			if !hasRemovalByLine[lineNum] {
				removals = append(removals, Removal(lineNum))
				hasRemovalByLine[lineNum] = true
			}
			found = true
		}

		if found {
			proposedLines[i] = strings.Replace(proposedLines[i], content, "", 1)
		}
	}

	desc = strings.ToLower(desc)
	desc = strings.TrimSpace(desc)
	desc = strings.ReplaceAll(desc, "*", "")
	desc = strings.ReplaceAll(desc, "`", "")
	desc = strings.ReplaceAll(desc, "'", "")
	desc = strings.ReplaceAll(desc, `"`, "")

	isEntireFileUpdate := strings.Contains(desc, "type: overwrite")
	isReplace := strings.Contains(desc, "type: replace")
	isRemove := strings.Contains(desc, "type: remove")
	isAdd := strings.Contains(desc, "type: add")
	isPrepend := strings.Contains(desc, "type: prepend")
	isAppend := strings.Contains(desc, "type: append")

	var removalRanges []RemovalRange

	// Parse line ranges from summary field
	// Matches formats like:
	// Replace: line 10
	// Remove: line 10
	// Replace: lines 10-20
	// Remove: lines 10-20
	singleLineRegex := regexp.MustCompile(`(?i)(Replace|Replaces|Remove|Removes).*?(\d+)`)
	lineRangeRegex := regexp.MustCompile(`(?i)(Replace|Replaces|Remove|Removes).*?(\d+)-(\d+)`)

	descLines := strings.Split(desc, "\n")

	for _, line := range descLines {
		line = strings.TrimSpace(line)

		matchesRemaining := true
		for matchesRemaining {
			// first see if there's a multi-line match
			if lineRangeMatch := lineRangeRegex.FindStringSubmatch(strings.ToLower(line)); len(lineRangeMatch) > 3 {
				// we have a multi-line match
				start, startErr := strconv.Atoi(lineRangeMatch[2])
				end, endErr := strconv.Atoi(lineRangeMatch[3])
				if startErr == nil && endErr == nil {
					removalRanges = append(removalRanges, RemovalRange{
						Start: start,
						End:   end,
					})
					line = strings.Replace(line, fmt.Sprintf("%d-%d", start, end), "", 1)
				} else {
					log.Println("ApplyChanges - multi-line match error")
					log.Println(spew.Sdump(startErr))
					log.Println(spew.Sdump(endErr))
					matchesRemaining = false
				}
			} else {

				// try single-line match
				if singleLineMatch := singleLineRegex.FindStringSubmatch(strings.ToLower(line)); len(singleLineMatch) > 2 {
					if lineNum, err := strconv.Atoi(singleLineMatch[2]); err == nil {
						removalRanges = append(removalRanges, RemovalRange{
							Start: lineNum,
							End:   lineNum,
						})
						line = strings.Replace(line, singleLineMatch[2], "", 1)
					} else {
						log.Println("ApplyChanges - single-line match error")
						log.Println(spew.Sdump(err))
						matchesRemaining = false
					}
				} else {
					matchesRemaining = false
				}
			}
		}
	}

	if verboseLogging {
		log.Println("ApplyChanges - removal ranges:")
		log.Println(spew.Sdump(removalRanges))
	}

	var res *ApplyChangesResult

	if isEntireFileUpdate {
		hasRefsOrRemovals := len(references) > 0 || len(removals) > 0

		if !hasRefsOrRemovals {
			// shortcut to just return the full updated file and skip verification
			// if any references were included or the first and last lines of the proposed file don't match the first and last lines of the original file
			res = &ApplyChangesResult{
				NewFile:  proposed,
				Proposed: proposed,
			}
		}
	}

	if res == nil {
		if addMissingStartEndRefs {
			var beginsWithRef bool = false
			var endsWithRef bool = false
			var foundNonRefLine bool = false

			for i, line := range proposedLines {
				hasRef := hasRefByLine[i+1] || hasRemovalByLine[i+1]

				if hasRef {
					if !foundNonRefLine {
						beginsWithRef = true
					}
					endsWithRef = true
				} else if line != "" {
					foundNonRefLine = true
					endsWithRef = false
				}
			}

			if !beginsWithRef &&
				!isEntireFileUpdate &&
				!((isReplace || isRemove) &&
					strings.Contains(desc, "start of the file")) {

				if verboseLogging {
					fmt.Println("adding ... existing code ... to start of file")
				}

				proposedLines = append([]string{""}, proposedLines...)

				// bump all existing references up by 1
				for i, ref := range references {
					references[i] = Reference(int(ref) + 1)
				}
				references = append([]Reference{Reference(1)}, references...)
			}

			if !endsWithRef &&
				!isEntireFileUpdate &&
				!((isReplace || isRemove) &&
					strings.Contains(desc, "end of the file")) {

				if verboseLogging {
					fmt.Println("adding ... existing code ... to end of file")
				}

				proposedLines = append(proposedLines, "")
				references = append(references, Reference(len(proposedLines)))
			}
		}

		proposed = strings.Join(proposedLines, "\n")

		isPureInsert := !isEntireFileUpdate && !isReplace && !isRemove && (isAdd || isPrepend || isAppend)

		if isPureInsert {
			if verboseLogging {
				fmt.Println("isPureInsert")
			}
		}

		if verboseLogging {
			fmt.Println("proposed:")
			fmt.Println(proposed)
			log.Println("ApplyChanges - references:")
			spew.Dump(references)
			log.Println("ApplyChanges - removals:")
			spew.Dump(removals)
		}

		if !isPureInsert {
			log.Println("ApplyChanges - removal ranges:")
			log.Println(spew.Sdump(removalRanges))
		}

		res = ExecApplyGeneric(
			execApplyGenericParams{
				original:      original,
				proposed:      proposed,
				originalLines: originalLines,
				proposedLines: proposedLines,
				references:    references,
				removals:      removals,
				isInsert:      isPureInsert,
				removalRanges: removalRanges,
			},
		)

		res.Proposed = proposed

		if len(res.NeedsVerifyReasons) > 0 {
			if verboseLogging {
				log.Println("ApplyChanges - needs verify reasons:")
				log.Println(spew.Sdump(res.NeedsVerifyReasons))

				log.Println("ApplyChanges - proposed:")
				log.Println(proposedInitial)
				log.Println("--------------------------------")

				// log.Println("ApplyChanges - original:")
				// log.Println(original)
				// log.Println("--------------------------------")
			}

			if len(res.NeedsVerifyReasons) == 1 && res.NeedsVerifyReasons[0] == NeedsVerifyReasonAmbiguousLocation && parser != nil {
				var err error
				prevRes := res
				res, err = ExecApplyTreeSitter(
					execApplyTreeSitterParams{
						original:   original,
						proposed:   proposed,
						references: references,
						removals:   removals,
						language:   language,
						parser:     parser,
						ctx:        ctx,
					},
				)

				if err != nil {
					log.Printf("ApplyChanges - error applying tree-sitter: %v", err)
					// since we got an error, give up and go back to the previous result
					res = prevRes
				} else if len(res.NeedsVerifyReasons) > 0 {
					return res
				}
			}
		}
	}

	// we want to verify if any code was removed/replaced based on length comparison or description
	// check if code was removed based on length comparison
	if len(res.NewFile) < len(original) {
		log.Println("ApplyChanges - code removed based on length comparison - needs verification")
		res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonCodeRemoved)
	} else if isRemove || isReplace || isEntireFileUpdate {
		log.Println("ApplyChanges - code removed based on description - needs verification")
		res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonCodeRemoved)
	} else {
		if verboseLogging {
			log.Println("ApplyChanges - checking for removed lines")
		}

		originalLineMap := make(map[string]bool)
		for _, line := range originalLines {
			originalLineMap[strings.TrimSpace(line)] = true
		}

		// log.Println("NewFile:")
		// log.Println(strconv.Quote(res.NewFile))

		newLines := strings.Split(res.NewFile, "\n")
		newLineMap := make(map[string]bool)
		for _, line := range newLines {
			newLineMap[strings.TrimSpace(line)] = true
		}

		log.Println("ApplyChanges - originalLineMap:")
		spew.Dump(originalLineMap)
		log.Println("ApplyChanges - newLineMap:")
		spew.Dump(newLineMap)

		// Check for removed lines (lines in original that are not in new)
		for line := range originalLineMap {
			if !newLineMap[line] {
				log.Println("ApplyChanges - code removed based on line comparison - needs verification")
				log.Println("line:")
				log.Println(line)

				res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonCodeRemoved)
				break
			}
		}
	}

	// Duplication check is now redundant since we verify all replacements
	// if strings.Contains(desc, " replace ") {
	// 	if verboseLogging {
	// 		log.Println("ApplyChanges - checking for duplicated lines")
	// 	}
	//
	// 	// Check for lines in proposed updates that are duplicated in new file
	// 	newLineFreq := make(map[string]int)
	// 	originalLineFreq := make(map[string]int)
	// 	proposedLineFreq := make(map[string]int)
	//
	// 	// First count frequencies in original file
	// 	for _, line := range originalLines {
	// 		trimmed := strings.TrimSpace(line)
	// 		if len(trimmed) > duplicationThreshold {
	// 			originalLineFreq[line]++
	// 		}
	// 	}
	//
	// 	// Count frequencies in proposed file
	// 	for _, line := range proposedLines {
	// 		trimmed := strings.TrimSpace(line)
	// 		if len(trimmed) > duplicationThreshold {
	// 			proposedLineFreq[line]++
	// 		}
	// 	}
	//
	// 	// Count frequencies in new file
	// 	for _, line := range newLines {
	// 		trimmed := strings.TrimSpace(line)
	// 		if len(trimmed) > duplicationThreshold {
	// 			newLineFreq[line]++
	// 		}
	// 	}
	//
	// 	// Check proposed lines against new frequencies, accounting for original duplicates
	// 	for _, line := range proposedLines {
	// 		trimmed := strings.TrimSpace(line)
	// 		if len(trimmed) > duplicationThreshold {
	// 			originalCount := originalLineFreq[line]
	// 			proposedCount := proposedLineFreq[line]
	// 			newCount := newLineFreq[line]
	// 			if newCount > originalCount && newCount > proposedCount {
	// 				if verboseLogging {
	// 					log.Println("ApplyChanges - code duplicated")
	// 					log.Println("line:")
	// 					log.Println(line)
	// 					log.Printf("original occurrences: %d, new occurrences: %d", originalCount, newLineFreq[line])
	// 				}
	// 				res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonCodeDuplicated)
	// 				break
	// 			}
	// 		}
	// 	}
	// }

	// if parser != nil {
	// 	comments, err := FindComments(ctx, parser, proposed)
	// 	if err != nil {
	// 		log.Printf("ApplyChanges - error finding comments: %v", err)
	// 	}
	// 	res.Comments = comments
	// }

	if verboseLogging && len(res.BlocksRemoved) > 0 {
		log.Printf("ApplyChanges - detected %d removed code blocks", len(res.BlocksRemoved))
		for i, block := range res.BlocksRemoved {
			log.Printf("Block %d: lines %d-%d", i+1, block.Start, block.End)
			if verboseLogging {
				log.Printf("Content: %s", block.Content)
			}
		}
	}

	return res
}


================================================
FILE: app/server/syntax/structured_edits_generic.go
================================================
package syntax

import (
	"fmt"
	"sort"
	"strings"

	"github.com/davecgh/go-spew/spew"
)

type execApplyGenericParams struct {
	original,
	proposed string
	originalLines,
	proposedLines []string
	references    []Reference
	removals      []Removal
	isInsert      bool
	removalRanges []RemovalRange
}

func ExecApplyGeneric(
	params execApplyGenericParams,
) *ApplyChangesResult {
	originalLines := params.originalLines
	proposedLines := params.proposedLines
	references := params.references
	removals := params.removals
	isInsert := params.isInsert
	removalRanges := params.removalRanges

	res := &ApplyChangesResult{}

	var b strings.Builder

	write := func(s string, newline bool) {
		if verboseLogging {
			toLog := s

			if len(toLog) > 200 {
				toLog = toLog[:100] + "\n...\n" + toLog[len(toLog)-100:]
			}

			fmt.Printf("writing: %s\n", toLog)
			fmt.Printf("newline: %v\n", newline)
		}

		b.WriteString(s)
		if newline {
			b.WriteByte('\n')
		}
	}

	refsByLine := map[Reference]bool{}
	removalsByLine := map[Removal]bool{}

	for _, ref := range references {
		refsByLine[ref] = true
	}

	for _, removal := range removals {
		removalsByLine[removal] = true
	}

	anchorMap := buildAnchorMap(
		originalLines,
		proposedLines,
		refsByLine,
		removalsByLine,
	)

	if verboseLogging {
		fmt.Printf("anchorMap:\n%v\n", spew.Sdump(anchorMap))
	}

	findAnchor := func(pLineNum int) *Anchor {
		oLineNum, ok := anchorMap[pLineNum]
		if ok {
			if verboseLogging {
				fmt.Printf("found anchor in anchorLines: oLineNum: %d, pLineNum: %d\n", oLineNum, pLineNum)
			}

			oLine := originalLines[oLineNum-1]
			if strings.TrimSpace(oLine) == "" {
				if verboseLogging {
					fmt.Printf("skipping anchor because oLine is blank: %q\n", oLine)
				}
				return nil
			}

			anchor := Anchor(oLineNum)
			if verboseLogging {
				fmt.Printf("found anchor: %d\n", anchor)
			}
			return &anchor
		} else {
			if verboseLogging {
				fmt.Printf("no anchor found in anchorMap: pLineNum: %d\n", pLineNum)
				fmt.Printf("anchorMap: %v\n", spew.Sdump(anchorMap))

				// for i, line := range originalLines {
				// 	fmt.Printf("originalLines[%d]: %q\n", i, line)
				// }

				// for i, line := range proposedLines {
				// 	fmt.Printf("proposedLines[%d]: %q\n", i, line)
				// }
			}
		}

		return nil
	}

	var oLineNum int = 0
	var refOpen bool
	var refStart int
	var postRefBuffers []strings.Builder

	lastLineMatched := true

	setOLineNum := func(n int) {
		if n < 1 {
			n = 1
		}
		if n > len(originalLines) {
			n = len(originalLines)
		}
		oLineNum = n
		if verboseLogging {
			fmt.Printf("setting oLineNum: %d\n", oLineNum)
		}
	}

	writeToLatestPostRefBuffer := func(s string) {
		latestBuffer := &postRefBuffers[len(postRefBuffers)-1]
		latestBuffer.WriteString(s)
		latestBuffer.WriteByte('\n')

		if verboseLogging {
			fmt.Printf("writing to latest postRefBuffer: %q\n", s)
		}
	}

	addNewPostRefBuffer := func() {
		postRefBuffers = append(postRefBuffers, strings.Builder{})

		if verboseLogging {
			fmt.Printf("adding new postRefBuffer\n")
		}
	}

	resetPostRefBuffers := func() {
		postRefBuffers = []strings.Builder{}

		if verboseLogging {
			fmt.Printf("resetting postRefBuffers\n")
		}
	}

	writeRefs := func(eof bool) bool {
		var fullRef []string
		if eof {
			start := refStart - 1
			if start < 0 {
				start = 0
			}
			if start >= len(originalLines) {
				start = len(originalLines) - 1
			}
			fullRef = originalLines[start:]
			if verboseLogging {
				fmt.Println("eof")
				fmt.Printf("fullRef refStart: %d\n", refStart)
				fmt.Printf("originalLines[refStart]: %q\n", originalLines[refStart])
				fmt.Printf("writing eof fullRef: %q\n", strings.Join(fullRef, "\n"))
			}
		} else {
			start := refStart - 1
			if start < 0 {
				start = 0
			}
			if start >= len(originalLines) {
				start = len(originalLines) - 1
			}
			end := oLineNum - 1
			if end < 1 {
				end = 0
			}
			if end >= len(originalLines) {
				end = len(originalLines) - 1
			}

			// Add detailed diagnostic logging for invalid slice bounds
			if start > end {
				fmt.Printf("\n=== INVALID SLICE BOUNDS DIAGNOSTIC INFO ===\n")
				fmt.Printf("start: %d, end: %d\n", start, end)
				fmt.Printf("refStart: %d, oLineNum: %d\n", refStart, oLineNum)

				// Log relevant lines for context
				fmt.Printf("\nOriginal lines context:\n")
				startContext := max(0, start-2)
				endContext := min(len(originalLines), end+3)
				for i := startContext; i < endContext; i++ {
					fmt.Printf("line %d: %q\n", i+1, originalLines[i])
				}

				fmt.Printf("\nProposed lines context:\n")
				fmt.Printf("=====================================\n\n")

				res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonAmbiguousLocation)

				return true
			}

			if verboseLogging {
				fmt.Printf("writing fullRef\n")
				fmt.Printf("refStart: %d, oLineNum: %d\n", refStart, oLineNum)
				fmt.Printf("start: %d, end: %d\n", start, end)
			}
			fullRef = originalLines[start:end]
			if verboseLogging {
				fmt.Printf("fullRef refStart: %d, oLineNum-1: %d\n", refStart, oLineNum-1)
				fmt.Printf("originalLines[start]: %q\n", originalLines[start])
				fmt.Printf("originalLines[end]: %q\n", originalLines[end])
			}
		}

		numRefs := len(postRefBuffers)
		if numRefs == 1 {
			if verboseLogging {
				fmt.Println("writeRefs")
				fmt.Printf("numRefs == 1, refStart: %d, oLineNum: %d\n", refStart, oLineNum)
			}

			write(strings.Join(fullRef, "\n"), !eof)

			postRefContent := postRefBuffers[0].String()

			if strings.TrimSpace(postRefContent) != "" {
				if verboseLogging {
					fmt.Println("writing postRefBuffer")
				}
				write(postRefBuffers[0].String(), false)
			}
		} else {
			if verboseLogging {
				fmt.Printf("writeRefs - ambiguous location - numRefs: %d\n", numRefs)
			}

			res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonAmbiguousLocation)

			return true
		}

		return false
	}

	reachedEndOfOriginal := false

	for idx, pLine := range proposedLines {
		finalLine := idx == len(proposedLines)-1
		pLineNum := idx + 1

		if verboseLogging {
			fmt.Printf("\n\ni: %d, num: %d, pLine: %q, refOpen: %v\n", idx, pLineNum, pLine, refOpen)
		}

		var isRef, isRemoval, nextPLineIsRef bool

		if !reachedEndOfOriginal {
			isRef = refsByLine[Reference(pLineNum)]
			isRemoval = removalsByLine[Removal(pLineNum)]
			nextPLineIsRef = refsByLine[Reference(pLineNum+1)]
		}

		if verboseLogging {
			fmt.Printf("isRef: %v\n", isRef)
			fmt.Printf("isRemoval: %v\n", isRemoval)
			fmt.Printf("nextPLineIsRef: %v\n", nextPLineIsRef)
			fmt.Printf("oLineNum before: %d\n", oLineNum)
			if oLineNum > 0 && oLineNum < len(originalLines) {
				fmt.Printf("oLine before: %q\n", originalLines[oLineNum-1])
			}
			fmt.Printf("lastLineMatched: %v\n", lastLineMatched)
		}

		if isRemoval {
			if verboseLogging {
				fmt.Println("isRemoval - skip line")
			}
			continue
		}

		if isRef {
			if !refOpen {
				if verboseLogging {
					fmt.Println("isRef - opening ref")
				}

				refOpen = true
				setOLineNum(oLineNum + 1)

				if verboseLogging {
					fmt.Printf("setting refStart: %d\n", refStart)
				}

				refStart = oLineNum
			}

			addNewPostRefBuffer()

			if oLineNum == len(originalLines) {
				reachedEndOfOriginal = true
			}

			continue
		}

		if !reachedEndOfOriginal && !refOpen && lastLineMatched {
			if strings.TrimSpace(pLine) == "" {
				if verboseLogging {
					fmt.Printf("pLine is blank\n")
					if oLineNum < len(originalLines) {
						fmt.Printf("nextOLine: %q\n", originalLines[oLineNum])
					}
				}

				nextOLineIsBlank := oLineNum > 0 && oLineNum < len(originalLines) && strings.TrimSpace(originalLines[oLineNum]) == ""

				if verboseLogging {
					fmt.Printf("nextPLineIsRef: %v\n", nextPLineIsRef)
					fmt.Printf("nextOLineIsBlank: %v\n", nextOLineIsBlank)
				}

				if !nextPLineIsRef || nextOLineIsBlank {
					write(pLine, !finalLine)
				}

				// Check if next line in original is also blank
				if nextOLineIsBlank {
					setOLineNum(oLineNum + 1)
				}

				if oLineNum == len(originalLines) {
					reachedEndOfOriginal = true
				}

				continue
			}
		}

		var matching bool

		prevOLineNum := oLineNum

		if !reachedEndOfOriginal {
			anchor := findAnchor(pLineNum)
			if anchor != nil {
				matching = true
				setOLineNum(int(*anchor))
			}
		}

		wroteRefs := false
		if matching {
			if verboseLogging {
				fmt.Printf("matching line: %s, oLineNum: %d\n", pLine, oLineNum)
			}

			if refOpen {
				// we found the end of the current reference
				if verboseLogging {
					fmt.Printf("closing ref, oLineNum: %d\n", oLineNum)
				}
				refOpen = false
				willAbort := writeRefs(false)
				write(pLine, !finalLine)
				wroteRefs = true
				if willAbort {
					return res
				}
			} else if oLineNum != prevOLineNum+1 {
				if verboseLogging {
					fmt.Printf("\nExecApplyChanges - found non-adjacent anchor jump:\n")
					fmt.Printf("prevOLineNum: %d ('%s')\n", prevOLineNum, originalLines[prevOLineNum])
					fmt.Printf("oLineNum: %d ('%s')\n", oLineNum, originalLines[oLineNum-1])
					fmt.Printf("Lines that would be removed:\n")
					for i := prevOLineNum; i < oLineNum-1; i++ {
						fmt.Printf("Line %d: '%s'\n", i, originalLines[i])
					}
				}

				removalRange := RemovalRange{
					Start: prevOLineNum,
					End:   oLineNum - 1,
				}

				if isInsert {
					// Write any lines that would have been removed
					for i := prevOLineNum; i < oLineNum-1; i++ {
						write(originalLines[i], true)
					}
				} else if len(removalRanges) > 0 {
					overlapsAny := false
					for _, r := range removalRanges {
						if removalRange.Overlaps(r) {
							overlapsAny = true
							break
						}
					}

					// if the removal doesn't overlap with any of the listed removal ranges, we can deterministically catch a mistake and write the lines that would have been removed
					if !overlapsAny {
						// Write any lines that would have been removed
						for i := prevOLineNum; i < oLineNum-1; i++ {
							write(originalLines[i], true)
						}
					}
				}
			}

		} else {
			if verboseLogging {
				fmt.Printf("no matching line\n")
			}
		}

		if wroteRefs {
			// reset buffers
			resetPostRefBuffers()
		} else {
			if refOpen {
				writeToLatestPostRefBuffer(pLine)
			} else {
				if verboseLogging {
					fmt.Printf("writing pLine: %s\n", pLine)
				}
				write(pLine, !finalLine)
			}

		}

		if oLineNum == len(originalLines) {
			reachedEndOfOriginal = true
		}
	}

	if refOpen {
		willAbort := writeRefs(true)
		if willAbort {
			return res
		}
	}

	if verboseLogging {
		// fmt.Printf("final result:\n%s\n", b.String())
	}

	res.NewFile = b.String()

	return res
}

func buildAnchorMap(
	originalLines []string,
	proposedLines []string,
	refsByLine map[Reference]bool,
	removalsByLine map[Removal]bool,
) AnchorMap {
	result := AnchorMap{}

	setAnchor := func(pLine, oLine int) {
		result[pLine] = oLine

		if verboseLogging {
			fmt.Printf("setAnchor - pLine: %d, oLine: %d\n", pLine, oLine)
		}
	}

	referenceBlocks := []ReferenceBlock{}

	// Helper to check if a line is in a reference block
	isInReference := func(lineNum int) bool {
		for _, block := range referenceBlocks {
			if lineNum >= block.start && lineNum <= block.end {
				return true
			}
		}
		return false
	}

	allRefsByLine := map[int]bool{}
	for ref := range refsByLine {
		allRefsByLine[int(ref)] = true
	}
	for removal := range removalsByLine {
		allRefsByLine[int(removal)] = true
	}

	// Keep track of definitely new code lines
	newCodeLines := make(map[int]bool)
	originalLinesSet := map[string]bool{}
	for _, line := range originalLines {
		originalLinesSet[line] = true
	}
	for idx, line := range proposedLines {
		if _, inOriginal := originalLinesSet[line]; !inOriginal {
			newCodeLines[idx+1] = true
		}
	}

	foundRefBounds := map[int]bool{}

	// When we establish an anchor match, check if we can determine reference bounds
	tryEstablishReferenceBounds := func() {
		if verboseLogging {
			fmt.Println("\n\ntryEstablishReferenceBounds")
		}
		for lineNum := range allRefsByLine {
			if !foundRefBounds[lineNum] {
				if verboseLogging {
					fmt.Printf("tryEstablishReferenceBounds - lineNum: %d\n", lineNum)
				}

				prevSignificantLineNum := lineNum - 1
				linesBack := 1
				for prevSignificantLineNum > 0 && proposedLines[prevSignificantLineNum-1] == "" {
					prevSignificantLineNum--
					linesBack++
				}

				nextSignificantLineNum := lineNum + 1
				linesForward := 1
				for nextSignificantLineNum <= len(proposedLines) && proposedLines[nextSignificantLineNum-1] == "" {
					nextSignificantLineNum++
					linesForward++
				}

				if verboseLogging {
					fmt.Printf("prevSignificantLineNum: %d, nextSignificantLineNum: %d\n", prevSignificantLineNum, nextSignificantLineNum)
				}

				var top, bottom int

				if prevSignificantLineNum <= 1 {
					if verboseLogging {
						fmt.Printf("prevSignificantLineNum <= 1 - setting top to 1\n")
					}
					top = 1
				} else if _, isAnchor := result[prevSignificantLineNum]; isAnchor {
					if verboseLogging {
						fmt.Printf("prevSignificantLineNum is anchor - setting top to %d\n", result[prevSignificantLineNum])
					}
					top = result[prevSignificantLineNum] + linesBack
				}

				if nextSignificantLineNum >= len(proposedLines) {
					if verboseLogging {
						fmt.Printf("nextSignificantLineNum >= len(proposedLines) - setting bottom to len(originalLines)\n")
					}
					bottom = len(originalLines)
				} else if _, isAnchor := result[nextSignificantLineNum]; isAnchor {
					if verboseLogging {
						fmt.Printf("nextSignificantLineNum is anchor - setting bottom to %d\n", result[nextSignificantLineNum])
					}
					bottom = result[nextSignificantLineNum] - linesForward
				} else if newCodeLines[nextSignificantLineNum] {

					if verboseLogging {
						fmt.Printf("nextSignificantLineNum is new code - finding next anchor\n")
					}

					// go forward from here to find the next anchor (or eof)
					foundAnchor := false
					for i := nextSignificantLineNum; i < len(proposedLines)+1; i++ {
						if _, isAnchor := result[i]; isAnchor {
							bottom = result[i] - 1
							foundAnchor = true
							if verboseLogging {
								fmt.Printf("found anchor at %d\n", i)
							}
							break
						}
					}
					if !foundAnchor {
						bottom = len(originalLines)
						if verboseLogging {
							fmt.Printf("no anchor found - setting bottom to len(originalLines)\n")
						}
					}
				}

				if top != 0 && bottom != 0 {
					foundRefBounds[lineNum] = true
					referenceBlocks = append(referenceBlocks, ReferenceBlock{start: top, end: bottom})
					if verboseLogging {
						fmt.Printf("found reference bounds: %d-%d\n", top, bottom)
					}
				} else {
					if verboseLogging {
						fmt.Printf("no reference bounds found for lineNum: %d\n", lineNum)
					}
				}
			}
		}
	}

	if verboseLogging {
		fmt.Printf("\n=== Building Anchor Map ===\n")
	}

	var matchSection func(pStart, pEnd, oStart, oEnd int)
	matchSection = func(pStart, pEnd, oStart, oEnd int) {
		if pEnd <= pStart || oEnd <= oStart {
			return
		}

		if verboseLogging {
			fmt.Printf("\n--- Processing Section ---\n")
			fmt.Printf("Proposed lines %d-%d, Original lines %d-%d\n", pStart, pEnd, oStart, oEnd)
		}

		// First find unique matches in this section
		sectionOriginal := make(map[string][]int)
		sectionProposed := make(map[string][]int)

		// Build frequency maps for this section
		for i := oStart; i < oEnd; i++ {
			content := originalLines[i]
			sectionOriginal[content] = append(sectionOriginal[content], i)
		}

		for i := pStart; i < pEnd; i++ {
			content := proposedLines[i]
			sectionProposed[content] = append(sectionProposed[content], i)
		}

		// Handle unique matches first
		if verboseLogging {
			fmt.Printf("\nProcessing unique matches...\n")
		}
		for content, pIndices := range sectionProposed {
			if oIndices, exists := sectionOriginal[content]; exists && len(oIndices) == 1 && len(pIndices) == 1 {
				pIdx, oIdx := pIndices[0], oIndices[0]
				if _, exists := result[pIdx+1]; !exists {
					setAnchor(pIdx+1, oIdx+1)
				}

				if verboseLogging {
					fmt.Printf("Found unique match: %q\n", content)
					fmt.Printf("Mapping proposed line %d (%q) -> original line %d (%q)\n",
						pIdx+1, proposedLines[pIdx], oIdx+1, originalLines[oIdx])
				}
			}
		}

		// after finding unique anchors, try to establish reference bounds
		tryEstablishReferenceBounds()

		// Get ordered anchors to establish subsections
		var orderedAnchors []struct {
			pLine int
			oLine int
		}
		for pLine := pStart; pLine < pEnd; pLine++ {
			if anchor, exists := result[pLine+1]; exists {
				orderedAnchors = append(orderedAnchors, struct {
					pLine int
					oLine int
				}{pLine, anchor - 1})
			}
		}

		if verboseLogging {
			fmt.Printf("\nOrdered anchors in section: %v\n", orderedAnchors)
		}

		// Sort anchors by proposed line number
		sort.Slice(orderedAnchors, func(i, j int) bool {
			return orderedAnchors[i].pLine < orderedAnchors[j].pLine
		})

		// Process each subsection between anchors
		lastPLine := pStart
		lastOLine := oStart

		for i := 0; i <= len(orderedAnchors); i++ {
			var nextPLine, nextOLine int
			if i < len(orderedAnchors) {
				nextPLine = orderedAnchors[i].pLine
				nextOLine = orderedAnchors[i].oLine
			} else {
				nextPLine = pEnd
				nextOLine = oEnd
			}

			if verboseLogging {
				fmt.Printf("\nProcessing subsection %d\n", i)
				fmt.Printf("Proposed lines %d-%d, Original lines %d-%d\n", lastPLine, nextPLine, lastOLine, nextOLine)
			}

			// Handle duplicates in this subsection using outside-in matching
			subSectionOriginal := make(map[string][]int)
			subSectionProposed := make(map[string][]int)

			// Build frequency maps for this subsection
			for i := lastOLine; i < nextOLine; i++ {
				content := originalLines[i]
				subSectionOriginal[content] = append(subSectionOriginal[content], i)
			}

			for i := lastPLine; i < nextPLine; i++ {
				content := proposedLines[i]
				subSectionProposed[content] = append(subSectionProposed[content], i)
			}

			// Match duplicates from outside-in
			for content, pIndices := range subSectionProposed {
				oIndices, exists := subSectionOriginal[content]
				if !exists {
					if verboseLogging {
						fmt.Printf("New code found: %q at proposed lines %v\n", content, pIndices)
					}

					continue // This is new code to be inserted
				}

				if verboseLogging {
					fmt.Printf("\nMatching duplicates for content: %q\n", content)
					fmt.Printf("Found in proposed lines: %v\n", pIndices)
					fmt.Printf("Found in original lines: %v\n", oIndices)
				}

				// Filter oIndices to only include matches within subsection boundaries
				var validOIndices []int
				for _, idx := range oIndices {
					if idx >= lastOLine && idx < nextOLine {
						validOIndices = append(validOIndices, idx)
					}
				}
				oIndices = validOIndices

				// Match from outside in until we run out of original occurrences
				matched := 0
				for matched < len(oIndices) && matched*2 < len(pIndices) {

					if isInReference(oIndices[matched] + 1) {
						if verboseLogging {
							fmt.Printf("Skipping reference line %d\n", oIndices[matched]+1)
						}
						matched++
						continue
					}

					// Match first unmatched occurrence
					if _, exists := result[pIndices[matched]+1]; !exists {
						setAnchor(pIndices[matched]+1, oIndices[matched]+1)

						if verboseLogging {
							fmt.Printf("Matched first occurrence: proposed line %d (%q) -> original line %d (%q)\n",
								pIndices[matched]+1, proposedLines[pIndices[matched]],
								oIndices[matched]+1, originalLines[oIndices[matched]])
						}

						// after finding anchor, try to establish reference bounds
						tryEstablishReferenceBounds()
					}

					// Match last unmatched occurrence if we have more to match
					if matched*2+1 < len(pIndices) {
						lastOrigIdx := oIndices[len(oIndices)-1-matched]
						lastPropIdx := pIndices[len(pIndices)-1-matched]
						if isInReference(lastOrigIdx + 1) {
							if verboseLogging {
								fmt.Printf("Skipping reference line %d\n", lastOrigIdx+1)
							}
							matched++
							continue
						}
						if _, exists := result[lastPropIdx+1]; !exists {
							setAnchor(lastPropIdx+1, lastOrigIdx+1)
							if verboseLogging {
								fmt.Printf("Matched last occurrence: proposed line %d (%q) -> original line %d (%q)\n",
									lastPropIdx+1, proposedLines[lastPropIdx],
									lastOrigIdx+1, originalLines[lastOrigIdx])
							}

							// after finding anchor, try to establish reference bounds
							tryEstablishReferenceBounds()
						}

					}
					matched++
				}
				// Any remaining occurrences in pIndices are new code to be inserted
			}

			// Recursively process the next subsection
			if i < len(orderedAnchors) {
				lastPLine = nextPLine
				lastOLine = nextOLine
			}
		}
	}

	// Start recursive matching with full file
	matchSection(0, len(proposedLines), 0, len(originalLines))

	if verboseLogging {
		fmt.Printf("\n=== Final Anchor Map ===\n")
		fmt.Printf("Result: %v\n", result)
	}

	return result
}


================================================
FILE: app/server/syntax/structured_edits_sections.go
================================================
package syntax

import (
	"fmt"
	"log"
	"strings"

	"github.com/davecgh/go-spew/spew"
	tree_sitter "github.com/smacker/go-tree-sitter"
)

type TreeSitterSection []*tree_sitter.Node

type NodeIndex struct {
	nodesByLine   map[int]*tree_sitter.Node
	parentsByLine map[int]*tree_sitter.Node
}

func getSections(parent *tree_sitter.Node, bytes []byte, numSections, fromLine, upToLine int, foundAnyAnchor bool) []TreeSitterSection {
	sections := make([]TreeSitterSection, numSections)
	structures := [][]*tree_sitter.Node{}
	latestStructure := []*tree_sitter.Node{}

	cursor := tree_sitter.NewTreeCursor(parent)
	defer cursor.Close()

	parentFirstLineNum := int(parent.StartPoint().Row) + 1
	parentEndLineNum := int(parent.EndPoint().Row) + 1
	if verboseLogging {
		fmt.Printf("parent.Type(): %s\n", parent.Type())
		fmt.Printf("parent.Content(bytes):\n%q\n", parent.Content(bytes))
		fmt.Printf("parentFirstLineNum: %d\n", parentFirstLineNum)
		fmt.Printf("parentEndLineNum: %d\n", parentEndLineNum)
	}

	if cursor.GoToFirstChild() {
		for {
			node := cursor.CurrentNode()

			startLineNum := int(node.StartPoint().Row) + 1
			endLineNum := int(node.EndPoint().Row) + 1
			if verboseLogging {
				fmt.Printf("startLineNum: %d, endLineNum: %d\n", startLineNum, endLineNum)
				fmt.Println(node.Type())
				fmt.Printf("node.Content(bytes):\n%q\n", node.Content(bytes))
			}

			if startLineNum < fromLine {
				if verboseLogging {
					fmt.Println("startLineNum < fromLine, skipping")
					fmt.Printf("skipping lineNum: %d | before fromLine: %d\n", startLineNum, fromLine)
				}
				if !cursor.GoToNextSibling() {
					if verboseLogging {
						fmt.Println("no next sibling, breaking")
					}
					break
				}
				continue
			}

			if startLineNum == parentFirstLineNum && foundAnyAnchor {
				if verboseLogging {
					fmt.Printf("skipping first line\n")
				}
				if !cursor.GoToNextSibling() {
					if verboseLogging {
						fmt.Println("no next sibling, breaking")
					}
					break
				}
				continue
			}

			if endLineNum > upToLine {
				if verboseLogging {
					fmt.Println("endLineNum > upToLine, breaking")
					fmt.Printf("upToLine: %d, endLineNum: %d, node.Type(): %s\n", upToLine, endLineNum, node.Type())

					toLog := node.Content(bytes)
					if len(toLog) > 200 {
						toLog = toLog[:100] + "\n...\n" + toLog[len(toLog)-100:]
					}
					fmt.Println(toLog)
				}

				break
			}

			if endLineNum == parentEndLineNum && !isStructuralNode(node) {
				if verboseLogging {
					fmt.Println("endLineNum == parentEndLineNum && !isStructuralNode(node), breaking")
				}
				break
			}

			if isStructuralNode(node) {
				if verboseLogging {
					fmt.Printf("found structural node: %s\n", node.Type())
					fmt.Printf("starting new group\n")
				}
				if len(latestStructure) > 0 {
					structures = append(structures, latestStructure)
				}
				latestStructure = []*tree_sitter.Node{node}
			} else {
				if verboseLogging {
					fmt.Printf("not structural: %s\n", node.Type())
				}
				latestStructure = append(latestStructure, node)
			}

			if !cursor.GoToNextSibling() {
				if verboseLogging {
					fmt.Println("no next sibling, breaking")
				}
				break
			}
		}
		if len(latestStructure) > 0 {
			if verboseLogging {
				fmt.Println("appending latestStructure to structures")
			}
			structures = append(structures, latestStructure)
		}
	}

	if verboseLogging {
		fmt.Printf("structures:\n")
		log.Println(spew.Sdump(structures))
	}

	numStructural := len(structures)
	baseSize := numStructural / numSections
	remainder := numStructural % numSections

	if verboseLogging {
		fmt.Printf("baseSize: %d, remainder: %d\n", baseSize, remainder)
	}

	startIndex := 0

	for i := 0; i < numSections; i++ {
		size := baseSize
		if i < remainder {
			size++
		}

		endIndex := startIndex + size
		if endIndex > len(structures) {
			endIndex = len(structures)
		}

		var section TreeSitterSection
		group := structures[startIndex:endIndex]

		for _, s := range group {
			section = append(section, s...)
		}
		sections[i] = section
		startIndex = endIndex
	}

	if verboseLogging {
		fmt.Printf("sections:\n")
		log.Println(spew.Sdump(sections))

		fmt.Println("Sections content:")
		for i, section := range sections {
			fmt.Printf("section %d:\n", i)
			for j, node := range section {
				fmt.Printf("node %d:\n", j)
				toLog := node.Content(bytes)
				if len(toLog) > 200 {
					toLog = toLog[:100] + "\n...\n" + toLog[len(toLog)-100:]
				}
				fmt.Println(toLog)
			}
		}
	}

	return sections
}

func isStructuralNode(node *tree_sitter.Node) bool {
	nodeType := node.Type()

	if strings.Contains(nodeType, "comment") {
		return false
	}

	if strings.HasSuffix(nodeType, "space") {
		return false
	}

	switch nodeType {
	case "ws", "newline", "indent", "dedent":
		return false
	}

	if node.IsNamed() {
		return true
	}

	if node.ChildCount() > 0 {
		return true
	}

	return false
}

func BuildNodeIndex(tree *tree_sitter.Tree) *NodeIndex {
	nodesByLine := make(map[int]*tree_sitter.Node)
	parentsByLine := make(map[int]*tree_sitter.Node)

	root := tree.RootNode()

	// First pass - index direct nodes
	var indexNodes func(node *tree_sitter.Node, depth int)
	indexNodes = func(node *tree_sitter.Node, depth int) {
		// if verboseLogging {
		// 	fmt.Printf("node: %s, depth: %d, childCount: %d\n", node.Type(), depth, node.ChildCount())
		// 	// spew.Dump(node.StartPoint())
		// }

		if node.Type() != root.Type() {
			line := int(node.StartPoint().Row)
			existing, exists := nodesByLine[line]
			if !exists ||
				node.StartPoint().Column < existing.StartPoint().Column ||
				(node.StartPoint().Column == existing.StartPoint().Column && depth < getNodeDepth(existing)) {
				nodesByLine[line] = node
				parentsByLine[line] = node.Parent()
			}
		}

		for i := 0; i < int(node.ChildCount()); i++ {
			child := node.Child(i)
			indexNodes(child, depth+1)
		}
	}

	indexNodes(root, 0)

	// Second pass - fill in missing lines with parent nodes
	endLine := int(root.EndPoint().Row)
	for line := 0; line <= endLine; line++ {
		if _, exists := nodesByLine[line]; !exists {
			// Find containing parent node
			var findParent func(node *tree_sitter.Node) *tree_sitter.Node
			findParent = func(node *tree_sitter.Node) *tree_sitter.Node {
				nodeStart := int(node.StartPoint().Row)
				nodeEnd := int(node.EndPoint().Row)

				if nodeStart <= line && line <= nodeEnd {
					// Check children first for more specific containment
					for i := 0; i < int(node.ChildCount()); i++ {
						child := node.Child(i)
						if found := findParent(child); found != nil {
							return found
						}
					}
					return node
				}
				return nil
			}

			parent := findParent(root)

			if parent == nil {
				nodesByLine[line] = root
			} else {
				nodesByLine[line] = parent
				parentsByLine[line] = parent
			}
		}
	}

	// spew.Dump(nodesByLine)
	return &NodeIndex{
		nodesByLine:   nodesByLine,
		parentsByLine: parentsByLine,
	}
}

func getNodeDepth(node *tree_sitter.Node) int {
	depth := 0
	current := node
	for current.Parent() != nil {
		depth++
		current = current.Parent()
	}
	return depth
}

func (s TreeSitterSection) String(sourceLines []string, bytes []byte) string {
	if len(s) == 0 {
		return ""
	}

	// Find first structural node
	var firstNode *tree_sitter.Node
	for _, n := range s {
		if isStructuralNode(n) {
			firstNode = n
			break
		}
	}

	// Find last structural node
	var lastNode *tree_sitter.Node
	for i := len(s) - 1; i >= 0; i-- {
		if isStructuralNode(s[i]) {
			lastNode = s[i]
			break
		}
	}

	if firstNode == nil || lastNode == nil {
		return ""
	}

	startIdx := int(firstNode.StartPoint().Row)
	endIdx := int(lastNode.EndPoint().Row)

	if verboseLogging {
		for _, node := range s {
			fmt.Printf("node.Type(): %s\n", node.Type())
			fmt.Printf("StartPoint().Row: %d\n", node.StartPoint().Row)
			fmt.Printf("EndPoint().Row: %d\n", node.EndPoint().Row)
		}

		fmt.Printf("section.String startIdx: %d, endIdx: %d\n", startIdx, endIdx)
	}

	parent := lastNode.Parent()
	parentEndNode := parent.Child(int(parent.ChildCount()) - 1)
	lastLine := sourceLines[endIdx]
	if lastLine == parentEndNode.Content(bytes) {
		endIdx--
	}

	result := strings.Join(sourceLines[startIdx:endIdx+1], "\n") + "\n"

	if verboseLogging {
		toLog := result
		if len(toLog) > 200 {
			toLog = toLog[:100] + "\n...\n" + toLog[len(toLog)-100:]
		}
		fmt.Printf("section.String result: %s\n", toLog)
	}

	return result
}


================================================
FILE: app/server/syntax/structured_edits_test.go
================================================
package syntax

import (
	"context"
	"fmt"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestStructuredReplacements(t *testing.T) {
	tests := []struct {
		only        bool
		name        string
		original    string
		proposed    string
		want        string
		ext         string
		isInsert    bool
		laxNewlines bool
		desc        string
	}{
		{
			name: "single reference in function",
			original: `
    func processUser(id int) error {
        validate(id)
        startTx()
        updateUser(id)
        commit()
        return nil
    }`,
			proposed: `
    func processUser(id int) error {
        // ... existing code ...
        log.Info("processing user")
        return nil
    }`,
			want: `
    func processUser(id int) error {
        validate(id)
        startTx()
        updateUser(id)
        commit()
        log.Info("processing user")
        return nil
    }`,
			ext: "go",
		},
		{
			name: "bad formatting",
			original: `
    func processUser(id int) error {
    validate(id)
    validateAgain(id)
    prepForUpdate(id)
    return update(id)
    }`,
			proposed: `
    func processUser(id int) error {
    // ... existing code ...
    if force {
    log.Warn("will force update")
    }
    return update(id)
    }`,
			want: `
    func processUser(id int) error {
    validate(id)
    validateAgain(id)
    prepForUpdate(id)
    if force {
    log.Warn("will force update")
    }
    return update(id)
    }`,
			ext: "go",
		},
		{
			name:        "multiple refs in class/nested structures",
			laxNewlines: true,
			original: `
		package main

		import "log"

		func init() {
		  log.Println("init")
		}

		type UserService struct {
		    db *DB
		    cache *Cache
		}

		func (s *UserService) Process() {
		    s.validate()
		    s.update()
		    s.notify()
		}

		func (s *UserService) Update() {
		    s.db.begin()
		    s.db.exec()
		    s.db.commit()
		}

		func (s *UserService) Record() {
		  log.Println("record")
		}
		`,
			proposed: `
		// ... existing code ...

		type UserService struct {
		    // ... existing code ...
		    metrics *Metrics
		}

		func (s *UserService) Process() {
		    // ... existing code ...
		    s.metrics.Record()
		    // ... existing code ...
		}

		func (s *UserService) Update() {
		    // ... existing code ...
		}

		// ... existing code ...
		`,
			want: `
		package main

		import "log"

		func init() {
		  log.Println("init")
		}
		type UserService struct {
		    db *DB
		    cache *Cache
		    metrics *Metrics
		}

		func (s *UserService) Process() {
		    s.validate()
		    s.update()
		    s.metrics.Record()
		    s.notify()
		}

		func (s *UserService) Update() {
		    s.db.begin()
		    s.db.exec()
		    s.db.commit()
		}

		func (s *UserService) Record() {
		  log.Println("record")
		}
		`,
			ext: "go",
		},
		{
			name: "code removal comment",
			original: `
    func processUser(id int) error {
        validate(id)
        startTx()
        logTransaction()
        validateAgain(id)
        updateUser(id)
        commit()
        return nil
    }`,
			proposed: `
    func processUser(id int) error {
        validate(id)
        // Plandex: removed code
        validateAgain(id)
        updateUser(id)
        commit()
        return nil
    }`,
			want: `
    func processUser(id int) error {
        validate(id)
        validateAgain(id)
        updateUser(id)
        commit()
        return nil
    }`,
			ext: "go",
		},
		{
			name: "multiple code removal comments",
			original: `
    func processUser(id int) error {
        validate(id)
        startTx()
        logTransaction()
        validateAgain(id)
        logValidation()
        updateUser(id)
        commit()
        return nil
    }`,
			proposed: `
    func processUser(id int) error {
        validate(id)
        // Plandex: removed code
        validateAgain(id)
        // Plandex: removed code
        updateUser(id)
        commit()
        return nil
    }`,
			want: `
    func processUser(id int) error {
        validate(id)
        validateAgain(id)
        updateUser(id)
        commit()
        return nil
    }`,
			ext: "go",
		},
		{
			name: "json update with reference comments",
			original: `{
        "name": "test-app",
        "version": "1.0.0",
        "dependencies": {
            "express": "^4.17.1",
            "body-parser": "^1.19.0",
            "cors": "^2.8.5"
        },
        "scripts": {
            "start": "node index.js",
            "test": "jest",
            "build": "webpack"
        }
    }`,
			proposed: `{
        // ... existing code ...
        "dependencies": {
            "express": "^4.17.1",
            "body-parser": "^1.19.0",
            "cors": "^2.8.5",
            "dotenv": "^16.0.0",
            "mongoose": "^6.0.0"
        },
        // ... existing code ...
    }`,
			want: `{
        "name": "test-app",
        "version": "1.0.0",
        "dependencies": {
            "express": "^4.17.1",
            "body-parser": "^1.19.0",
            "cors": "^2.8.5",
            "dotenv": "^16.0.0",
            "mongoose": "^6.0.0"
        },
        "scripts": {
            "start": "node index.js",
            "test": "jest",
            "build": "webpack"
        }
    }`,
			ext: "json",
		},
		{
			name: "method replacement with context",
			original: `
    class UserService {
        constructor() {
            this.cache = new Cache()
        }

        async getUser(id) {
            const user = await db.find(id)
            return user
        }

        async updateUser(id, data) {
            await db.update(id, data)
            this.cache.clear()
        }

        async deleteUser(id) {
            await db.delete(id)
            this.cache.clear()
        }
    }`,
			proposed: `
    class UserService {
        // ... existing code ...

        async getUser(id) {
            const cached = await this.cache.get(id)
            if (cached) return cached
            
            const user = await db.find(id)
            await this.cache.set(id, user)
            return user
        }

        // ... existing code ...
    }`,
			want: `
    class UserService {
        constructor() {
            this.cache = new Cache()
        }

        async getUser(id) {
            const cached = await this.cache.get(id)
            if (cached) return cached
            
            const user = await db.find(id)
            await this.cache.set(id, user)
            return user
        }

        async updateUser(id, data) {
            await db.update(id, data)
            this.cache.clear()
        }

        async deleteUser(id) {
            await db.delete(id)
            this.cache.clear()
        }
    }`,
			ext: "js",
		},
		{
			name: "nested class methods update",
			original: `
    namespace Database {
        class Transaction {
            begin() {
                log.Info("beginning transaction")
                startTx()
            }

            commit() {
                log.Info("committing transaction")
                commitTx()
            }

            rollback() {
                log.Info("rolling back transaction")
                rollbackTx()
            }
        }
    }`,
			proposed: `
    namespace Database {
        class Transaction {
            begin() {
                // ... existing code ...
            }

            commit() {
                log.Info("committing transaction")
                validateTx()
                commitTx()
                notifyCommit()
            }

            // ... existing code ...
        }
    }`,
			want: `
    namespace Database {
        class Transaction {
            begin() {
                log.Info("beginning transaction")
                startTx()
            }

            commit() {
                log.Info("committing transaction")
                validateTx()
                commitTx()
                notifyCommit()
            }

            rollback() {
                log.Info("rolling back transaction")
                rollbackTx()
            }
        }
    }`,
			ext: "ts",
		},
		{
			name: "update with trailing commas",
			original: `
    const handlers = {
        onStart: () => {
            console.log("starting")
        },
        onProcess: () => {
            console.log("processing")
        },
        onFinish: () => {
            console.log("finishing")
        },
    }`,
			proposed: `
    const handlers = {
        // ... existing code ...
        onProcess: () => {
            console.log("processing")
            emitEvent("process"),
        },
        // ... existing code ...
    }`,
			want: `
    const handlers = {
        onStart: () => {
            console.log("starting")
        },
        onProcess: () => {
            console.log("processing")
            emitEvent("process"),
        },
        onFinish: () => {
            console.log("finishing")
        },
    }`,
			ext: "js",
		},
		{
			name: "multiple structural updates",
			original: `
    class Logger {
        info(msg) {
            console.log("[INFO]", msg)
        }

        warn(msg) {
            console.log("[WARN]", msg)
        }

        error(msg) {
            console.log("[ERROR]", msg)
        }

        debug(msg) {
            console.log("[DEBUG]", msg)
        }
    }`,
			proposed: `
    class Logger {
        constructor(prefix) {
            this.prefix = prefix
        }

        info(msg) {
            console.log(this.prefix, "[INFO]", msg)
        }

        // ... existing code ...

        error(msg) {
            console.error(this.prefix, "[ERROR]", msg)
            notify("error", msg)
        }

        // ... existing code ...

        fatal(msg) {
            console.error(this.prefix, "[FATAL]", msg)
            process.exit(1)
        }
    }`,
			want: `
    class Logger {
        constructor(prefix) {
            this.prefix = prefix
        }

        info(msg) {
            console.log(this.prefix, "[INFO]", msg)
        }

        warn(msg) {
            console.log("[WARN]", msg)
        }

        error(msg) {
            console.error(this.prefix, "[ERROR]", msg)
            notify("error", msg)
        }

        debug(msg) {
            console.log("[DEBUG]", msg)
        }

        fatal(msg) {
            console.error(this.prefix, "[FATAL]", msg)
            process.exit(1)
        }
    }`,
			ext: "js",
		},
		{
			name: "json multi-level update",
			original: `
{
  "name": "vscode-plandex",
  "displayName": "Plandex",
  "description": "VSCode extension for Plandex integration",
  "version": "0.1.0",
  "engines": {
    "vscode": "^1.80.0"
  },
  "categories": [
    "Other"
  ],
  "activationEvents": [
    "onLanguage:plandex"
  ],
  "main": "./dist/extension.js",
  "contributes": {
    "languages": [{
      "id": "plandex",
      "aliases": ["Plandex", "plandex"],
      "extensions": [".pd"]
    }],
    "commands": [
      {
        "command": "plandex.tellPlandex",
        "title": "Tell Plandex"
      }
    ],
    "keybindings": [{
      "command": "plandex.showFilePicker",
      "key": "@",
      "when": "editorTextFocus && editorLangId == plandex"
    }]
  },
  "scripts": {
    "vscode:prepublish": "npm run package",
    "compile": "webpack",
    "watch": "webpack --watch",
    "package": "webpack --mode production --devtool hidden-source-map",
    "compile-tests": "tsc -p . --outDir out",
    "watch-tests": "tsc -p . -w --outDir out",
    "test": "node ./out/test/runTest.js"
  },
  "devDependencies": {
    "@types/vscode": "^1.80.0",
    "@types/glob": "^8.1.0",
    "@types/mocha": "^10.0.1",
    "@types/node": "20.2.5",
    "@typescript-eslint/eslint-plugin": "^5.59.8",
    "@typescript-eslint/parser": "^5.59.8",
    "eslint": "^8.41.0",
    "glob": "^8.1.0",
    "mocha": "^10.2.0",
    "ts-loader": "^9.4.3",
    "typescript": "^5.1.3",
    "webpack": "^5.85.0",
    "webpack-cli": "^5.1.1",
    "@vscode/test-electron": "^2.3.2"
  }
}
`,
			proposed: `
{
  // ... existing code ...  
  "contributes": {
    "languages": [{
      "id": "plandex",
      "aliases": ["Plandex", "plandex"],
      "extensions": [".pd"],
      "configuration": "./language-configuration.json",
      "icon": {
          "light": "./icons/plandex-light.png",
          "dark": "./icons/plandex-dark.png"
      }
    }],
    "grammars": [{
      "language": "plandex",
      "scopeName": "text.plandex",
      "path": "./syntaxes/plandex.tmLanguage.json",
      "embeddedLanguages": {
          "meta.embedded.block.yaml": "yaml",
          "text.html.markdown": "markdown"
      }
    }],
    // ... existing code ...
  },
  // ... existing code ...
}
`,
			want: `
{
  "name": "vscode-plandex",
  "displayName": "Plandex",
  "description": "VSCode extension for Plandex integration",
  "version": "0.1.0",
  "engines": {
    "vscode": "^1.80.0"
  },
  "categories": [
    "Other"
  ],
  "activationEvents": [
    "onLanguage:plandex"
  ],
  "main": "./dist/extension.js",
  "contributes": {
    "languages": [{
      "id": "plandex",
      "aliases": ["Plandex", "plandex"],
      "extensions": [".pd"],
      "configuration": "./language-configuration.json",
      "icon": {
          "light": "./icons/plandex-light.png",
          "dark": "./icons/plandex-dark.png"
      }
    }],
    "grammars": [{
      "language": "plandex",
      "scopeName": "text.plandex",
      "path": "./syntaxes/plandex.tmLanguage.json",
      "embeddedLanguages": {
          "meta.embedded.block.yaml": "yaml",
          "text.html.markdown": "markdown"
      }
    }],
    "commands": [
      {
        "command": "plandex.tellPlandex",
        "title": "Tell Plandex"
      }
    ],
    "keybindings": [{
      "command": "plandex.showFilePicker",
      "key": "@",
      "when": "editorTextFocus && editorLangId == plandex"
    }]
  },
  "scripts": {
    "vscode:prepublish": "npm run package",
    "compile": "webpack",
    "watch": "webpack --watch",
    "package": "webpack --mode production --devtool hidden-source-map",
    "compile-tests": "tsc -p . --outDir out",
    "watch-tests": "tsc -p . -w --outDir out",
    "test": "node ./out/test/runTest.js"
  },
  "devDependencies": {
    "@types/vscode": "^1.80.0",
    "@types/glob": "^8.1.0",
    "@types/mocha": "^10.0.1",
    "@types/node": "20.2.5",
    "@typescript-eslint/eslint-plugin": "^5.59.8",
    "@typescript-eslint/parser": "^5.59.8",
    "eslint": "^8.41.0",
    "glob": "^8.1.0",
    "mocha": "^10.2.0",
    "ts-loader": "^9.4.3",
    "typescript": "^5.1.3",
    "webpack": "^5.85.0",
    "webpack-cli": "^5.1.1",
    "@vscode/test-electron": "^2.3.2"
  }
}
`,
			ext: "json",
		},
		{
			name: "json multi-level update 2",
			original: `
{
  "name": "vscode-plandex",
  "displayName": "Plandex",
  "description": "VSCode extension for Plandex integration",
  "version": "0.1.0",
  "publisher": "plandex",
  "engines": {
    "vscode": "^1.80.0"
  },
  "categories": [
    "Other"
  ],
  "activationEvents": [
    "onLanguage:pdx"
  ],
  "main": "./dist/extension.js",
  "contributes": {
    "languages": [
      {
        "id": "pdx",
        "aliases": ["Plandex", "pdx"],
        "extensions": [".pdx"],
        "configuration": "./language-configuration.json"
      }
    ],
    "grammars": [
      {
        "language": "pdx",
        "scopeName": "source.mdx",
        "path": "./syntaxes/mdx.tmLanguage.json",
        "embeddedLanguages": {
          "meta.embedded.block.yaml": "yaml",
          "meta.embedded.block.markdown": "markdown"
        }
      }
    ],
    "commands": [
      {
        "command": "plandex.tellPlandex",
        "title": "Tell Plandex",
        "icon": "$(play)"
      }
    ],
    "keybindings": [
      {
        "command": "plandex.showFilePicker",
        "key": "@",
        "when": "editorTextFocus && editorLangId == pdx"
      }
    ],
    "menus": {
      "editor/title": [
        {
          "command": "plandex.tellPlandex",
          "group": "navigation",
          "when": "editorLangId == pdx"
        }
      ]
    }
  },
  "scripts": {
    "vscode:prepublish": "npm run package",
    "compile": "webpack",
    "watch": "webpack --watch",
    "package": "webpack --mode production --devtool hidden-source-map",
    "compile-tests": "tsc -p . --outDir out",
    "watch-tests": "tsc -p . -w --outDir out",
    "pretest": "npm run compile-tests && npm run compile && npm run lint",
    "lint": "eslint src --ext ts",
    "test": "node ./out/test/runTest.js"
  },
  "devDependencies": {
    "@types/glob": "^8.1.0",
    "@types/mocha": "^10.0.1",
    "@types/node": "^20.2.5",
    "@types/vscode": "^1.80.0",
    "@typescript-eslint/eslint-plugin": "^5.59.8",
    "@typescript-eslint/parser": "^5.59.8",
    "eslint": "^8.41.0",
    "glob": "^8.1.0",
    "mocha": "^10.2.0",
    "ts-loader": "^9.4.3",
    "typescript": "^5.1.3",
    "webpack": "^5.85.0",
    "webpack-cli": "^5.1.1"
  },
  "dependencies": {
    "yaml": "^2.3.1"
  }
}
`,
			proposed: `
{
  // ... existing code ...

  "contributes": {
    // ... existing code ...

    "commands": [
      {
        "command": "plandex.tellPlandex",
        "title": "Tell Plandex",
        "icon": {
          "light": "resources/light/play.svg",
          "dark": "resources/dark/play.svg"
        }
      }
    ],

    // ... existing code ...
  },

  // ... existing code ...
}
`,
			want: `
{
  "name": "vscode-plandex",
  "displayName": "Plandex",
  "description": "VSCode extension for Plandex integration",
  "version": "0.1.0",
  "publisher": "plandex",
  "engines": {
    "vscode": "^1.80.0"
  },
  "categories": [
    "Other"
  ],
  "activationEvents": [
    "onLanguage:pdx"
  ],
  "main": "./dist/extension.js",
  "contributes": {
    "languages": [
      {
        "id": "pdx",
        "aliases": ["Plandex", "pdx"],
        "extensions": [".pdx"],
        "configuration": "./language-configuration.json"
      }
    ],
    "grammars": [
      {
        "language": "pdx",
        "scopeName": "source.mdx",
        "path": "./syntaxes/mdx.tmLanguage.json",
        "embeddedLanguages": {
          "meta.embedded.block.yaml": "yaml",
          "meta.embedded.block.markdown": "markdown"
        }
      }
    ],
    "commands": [
      {
        "command": "plandex.tellPlandex",
        "title": "Tell Plandex",
        "icon": {
          "light": "resources/light/play.svg",
          "dark": "resources/dark/play.svg"
        }
      }
    ],
    "keybindings": [
      {
        "command": "plandex.showFilePicker",
        "key": "@",
        "when": "editorTextFocus && editorLangId == pdx"
      }
    ],
    "menus": {
      "editor/title": [
        {
          "command": "plandex.tellPlandex",
          "group": "navigation",
          "when": "editorLangId == pdx"
        }
      ]
    }
  },
  "scripts": {
    "vscode:prepublish": "npm run package",
    "compile": "webpack",
    "watch": "webpack --watch",
    "package": "webpack --mode production --devtool hidden-source-map",
    "compile-tests": "tsc -p . --outDir out",
    "watch-tests": "tsc -p . -w --outDir out",
    "pretest": "npm run compile-tests && npm run compile && npm run lint",
    "lint": "eslint src --ext ts",
    "test": "node ./out/test/runTest.js"
  },
  "devDependencies": {
    "@types/glob": "^8.1.0",
    "@types/mocha": "^10.0.1",
    "@types/node": "^20.2.5",
    "@types/vscode": "^1.80.0",
    "@typescript-eslint/eslint-plugin": "^5.59.8",
    "@typescript-eslint/parser": "^5.59.8",
    "eslint": "^8.41.0",
    "glob": "^8.1.0",
    "mocha": "^10.2.0",
    "ts-loader": "^9.4.3",
    "typescript": "^5.1.3",
    "webpack": "^5.85.0",
    "webpack-cli": "^5.1.1"
  },
  "dependencies": {
    "yaml": "^2.3.1"
  }
}
`,
			ext: "json",
		},
		{
			name:        "scala complex structures",
			laxNewlines: true,
			original: `
		package domain.service

		import java.time.format.DateTimeFormatter

		class MetricsService(
		    client: Client,
		    service: Service,
		    automation: Automation
		)(
		    implicit context: Context
		) extends LazyLogging
		  with BaseImplicits {

		    def metrics(
		        ids: Seq[Id],
		        channels: Option[Seq[Channel]>,
		    ): Future[Metrics] = {

		      getMetrics(
		        ids,
		        channels,
		        Endpoint.Metrics
		      )
		    }

		    def metrics2(
		        ids: Seq[Id],
		        channels: Option[Seq[Channel]>,
		    ): Future[Metrics] = {

		      getMetrics2(
		        ids,
		        channels,
		        Endpoint.Metrics
		      )
		    }
		  }
		`,
			proposed: `
		package domain.service

		// ... existing code ...

		class MetricsService(
		  // ... existing code ...
		)(
		    implicit context: Context
		) extends LazyLogging
		  with BaseImplicits {

		    // ... existing code ...

		    def update(authContext: AuthContext, id: String): Future[Done] = {
		      fallbacks.stub
		        .update(
		          updateRequest(
		            authContext = Some(authContext),
		            id = id
		          )
		        )
		        .map(_ => Done)
		    }

		    // ... existing code ...
		  }
		`,
			want: `
		package domain.service

		import java.time.format.DateTimeFormatter

		class MetricsService(
		    client: Client,
		    service: Service,
		    automation: Automation
		)(
		    implicit context: Context
		) extends LazyLogging
		  with BaseImplicits {

		    def metrics(
		        ids: Seq[Id],
		        channels: Option[Seq[Channel]>,
		    ): Future[Metrics] = {

		      getMetrics(
		        ids,
		        channels,
		        Endpoint.Metrics
		      )
		    }

		    def update(authContext: AuthContext, id: String): Future[Done] = {
		      fallbacks.stub
		        .update(
		          updateRequest(
		            authContext = Some(authContext),
		            id = id
		          )
		        )
		        .map(_ => Done)
		    }

		    def metrics2(
		        ids: Seq[Id],
		        channels: Option[Seq[Channel]>,
		    ): Future[Metrics] = {

		      getMetrics2(
		        ids,
		        channels,
		        Endpoint.Metrics
		      )
		    }
		  }
		`,
			ext: "scala",
		},
		{
			name:        "top-level ambiguous",
			laxNewlines: true,
			original: `
		function someFunction() {
		  console.log("someFunction")
		  const res = await fetch("https://example.com")
		  processResponse(res)
		  return res
		}

		function processResponse(res) {
		  console.log("processing response")
		  callSomeOtherFunction(res)
		  return res
		}

		function yetAnotherFunction() {
		  console.log("yetAnotherFunction")
		}

		function callSomething() {
		  console.log("callSomething")
		  await logSomething()
		  return "something"
		}
		`,
			proposed: `
		// ... existing code ...

		function newFunction() {
		  console.log("newFunction")
		  const res = await callSomething()
		  return res
		}

		// ... existing code ...
		`,
			want: `
		function someFunction() {
		  console.log("someFunction")
		  const res = await fetch("https://example.com")
		  processResponse(res)
		  return res
		}

		function processResponse(res) {
		  console.log("processing response")
		  callSomeOtherFunction(res)
		  return res
		}

		function newFunction() {
		  console.log("newFunction")
		  const res = await callSomething()
		  return res
		}

		function yetAnotherFunction() {
		  console.log("yetAnotherFunction")
		}

		function callSomething() {
		  console.log("callSomething")
		  await logSomething()
		  return "something"
		}
		`,
			ext: "js",
		},
		{
			name: "top-level with anchors",
			original: `
    function someFunction() {
      console.log("someFunction")
      const res = await fetch("https://example.com")
      processResponse(res)
      return res
    }

    function processResponse(res) {
      console.log("processing response")
      callSomeOtherFunction(res)
      return res
    }

    function yetAnotherFunction() {
      console.log("yetAnotherFunction")
      doStuff()
    }

    function callSomething() {
      console.log("callSomething")
      await logSomething()
      return "something"
    }
    `,
			proposed: `
    // ... existing code ...

    function processResponse(res) {
      // ... existing code ...
    }

    function newFunction() {
      console.log("newFunction")
      const res = await callSomething()
      return res
    }

    function yetAnotherFunction() {
      // ... existing code ...
    }

    // ... existing code ...
    `,
			want: `
    function someFunction() {
      console.log("someFunction")
      const res = await fetch("https://example.com")
      processResponse(res)
      return res
    }

    function processResponse(res) {
      console.log("processing response")
      callSomeOtherFunction(res)
      return res
    }

    function newFunction() {
      console.log("newFunction")
      const res = await callSomething()
      return res
    }

    function yetAnotherFunction() {
      console.log("yetAnotherFunction")
      doStuff()
    }

    function callSomething() {
      console.log("callSomething")
      await logSomething()
      return "something"
    }
    `,
			ext: "js",
		},
		{
			name: "clean up extraneous newlines",
			original: `
      func func1 () {
        fmt.Println("func1")
      }

      func func2 () {
        fmt.Println("log something")
        fmt.Println("func2")
      }

      func func3 () {
        fmt.Println("func3")

        fmt.Println("func3")
      }
      `,
			proposed: `
      // ... existing code ...

      func func2 () {
        // ... existing code ...
      }

      func newFunc () {
        console.log("newFunc")
      }

      func func3 () {

      // ... existing code ...
      `,
			want: `
      func func1 () {
        fmt.Println("func1")
      }

      func func2 () {
        fmt.Println("log something")
        fmt.Println("func2")
      }

      func newFunc () {
        console.log("newFunc")
      }

      func func3 () {
        fmt.Println("func3")

        fmt.Println("func3")
      }
      `,
			ext: "go",
		},
		{
			name: "insert between non-adjacent anchors",
			original: `func main() {
  fmt.Println("start")
  doSomething()
  fmt.Println("middle")
  someOtherThing()
  fmt.Println("end")
}`,
			proposed: `func main() {
  fmt.Println("start")
  doSomething()
  log.Info("new log")
  fmt.Println("end")
}`,
			want: `func main() {
  fmt.Println("start")
  doSomething()
  log.Info("new log")
  fmt.Println("middle")
  someOtherThing()
  fmt.Println("end")
}`,
			isInsert: true,
		},
		{
			name: "insert with reference and non-adjacent anchors",
			original: `func processRequest(req *Request) error {
  validateRequest(req)
  startTransaction()

  err := updateData(req)
  if err != nil {
      return err
  }

  notifyUpdate()
  commitTransaction()
  return nil
}`,
			proposed: `func processRequest(req *Request) error {
  // ... existing code ...
  startTransaction()

  log.Info("processing request", req.ID)

  commitTransaction()
  return nil
}`,
			want: `func processRequest(req *Request) error {
  validateRequest(req)
  startTransaction()

  log.Info("processing request", req.ID)

  err := updateData(req)
  if err != nil {
      return err
  }

  notifyUpdate()
  commitTransaction()
  return nil
}`,
			isInsert: true,
		},

		{
			name: "replacement with removal outside of single line range",
			desc: `
		      Type: replace
		      Replace: line 11
		      `,
			original: `func processRequest(req *Request) error {
		  validateRequest(req)
		  someOtherThing()
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  notifyUpdate()
		  commitTransaction()
		  return nil
		}`,
			proposed: `func processRequest(req *Request) error {
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  commitTransaction()
		  log.Info("processed request", req.ID)
		  return nil
		}`,
			want: `func processRequest(req *Request) error {
		  validateRequest(req)
		  someOtherThing()
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  commitTransaction()
		  log.Info("processed request", req.ID)
		  return nil
		}`,
		},

		{
			name: "replacement with removal inside of multi line range",
			desc: `
		      Type: replace
		      Replace: lines 2-3, line 11
		      `,
			original: `func processRequest(req *Request) error {
		  validateRequest(req)
		  someOtherThing()
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  notifyUpdate()
		  commitTransaction()
		  return nil
		}`,
			proposed: `func processRequest(req *Request) error {
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  commitTransaction()
		  log.Info("processed request", req.ID)
		  return nil
		}`,
			want: `func processRequest(req *Request) error {
		  startTransaction()

		  err := updateData(req)
		  if err != nil {
		      return err
		  }

		  commitTransaction()
		  log.Info("processed request", req.ID)
		  return nil
		}`,
		},

		{
			name: "add to end with full file included",
			desc: `
      Type: add
      Summary: Add Tailwind CSS typography plugin
      `,
			isInsert: true,
			original: `# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"`,
			proposed: `# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"

# Install Tailwind CSS typography plugin                                  
echo "Installing Tailwind CSS typography plugin..."                       
npm install @tailwindcss/typography --save-dev                            
echo "Tailwind CSS typography plugin installed successfully!"`,

			want: `# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"

# Install Tailwind CSS typography plugin                                  
echo "Installing Tailwind CSS typography plugin..."                       
npm install @tailwindcss/typography --save-dev                            
echo "Tailwind CSS typography plugin installed successfully!"`,
		},

		{
			name: "add to beginning with full file included",
			desc: `
      Type: add
      Summary: Add Tailwind CSS typography plugin
      `,
			isInsert: true,
			original: `# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"`,
			proposed: `# Install Tailwind CSS typography plugin                                  
echo "Installing Tailwind CSS typography plugin..."                       
npm install @tailwindcss/typography --save-dev                            
echo "Tailwind CSS typography plugin installed successfully!"
      
# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"`,

			want: `# Install Tailwind CSS typography plugin                                  
echo "Installing Tailwind CSS typography plugin..."                       
npm install @tailwindcss/typography --save-dev                            
echo "Tailwind CSS typography plugin installed successfully!"
      
# Install dependencies for markdown processing                            
echo "Installing dependencies for markdown processing..."                 
npm install next-mdx-remote gray-matter --save                            
echo "Dependencies installed successfully!"`,
		},
	}

	onlyTests := map[int]bool{}

	for i, tt := range tests {
		if tt.only {
			onlyTests[i] = true
		}
	}

	for i, tt := range tests {
		if len(onlyTests) > 0 {
			if _, ok := onlyTests[i]; !ok {
				continue
			}
		}

		t.Run(tt.name, func(t *testing.T) {
			// got, err := ApplyChanges(
			// 	context.Background(),
			// 	tt.language,
			// 	tt.parser,
			// 	tt.original,
			// 	tt.proposed,
			// 	tt.references,
			// 	tt.removals,
			// 	anchorLines,
			// )

			// originalLines := strings.Split(tt.original, "\n")
			// proposedLines := strings.Split(tt.proposed, "\n")

			desc := ""
			if tt.desc != "" {
				desc = tt.desc
			} else if tt.isInsert {
				desc = "Type: add"
			} else {
				desc = "Type: replace"
			}

			parser, lang, _, _ := GetParserForPath("file." + tt.ext)

			res := ApplyChanges(
				context.Background(),
				ApplyChangesParams{
					Original:               tt.original,
					Proposed:               tt.proposed,
					Desc:                   desc,
					AddMissingStartEndRefs: false,
					Parser:                 parser,
					Language:               lang,
				},
			)

			fmt.Println()
			fmt.Println("NAME:", tt.name)
			fmt.Println(res.NewFile)
			fmt.Println()

			// assert.Empty(t, res.NeedsVerifyReasons)

			if tt.laxNewlines {
				assert.Equal(t, strings.ReplaceAll(tt.want, "\n", ""), strings.ReplaceAll(res.NewFile, "\n", ""))
			} else {
				assert.Equal(t, tt.want, res.NewFile)
			}

		})
	}
}


================================================
FILE: app/server/syntax/structured_edits_tree_sitter.go
================================================
package syntax

import (
	"context"
	"fmt"
	"strings"

	shared "plandex-shared"

	tree_sitter "github.com/smacker/go-tree-sitter"
)

type tsAnchor struct {
	open  int
	close int
}

type execApplyTreeSitterParams struct {
	original,
	proposed string
	references  []Reference
	removals    []Removal
	anchorLines map[int]int
	language    shared.Language
	parser      *tree_sitter.Parser
	ctx         context.Context
}

func ExecApplyTreeSitter(
	params execApplyTreeSitterParams,
) (*ApplyChangesResult, error) {
	original := params.original
	proposed := params.proposed
	references := params.references
	removals := params.removals
	anchorLines := params.anchorLines
	language := params.language
	parser := params.parser
	ctx := params.ctx
	res := &ApplyChangesResult{}

	var b strings.Builder

	write := func(s string, newline bool) {
		if verboseLogging {
			toLog := s

			if len(toLog) > 200 {
				toLog = toLog[:100] + "\n...\n" + toLog[len(toLog)-100:]
			}

			fmt.Printf("writing: %s\n", toLog)
			fmt.Printf("newline: %v\n", newline)
		}

		b.WriteString(s)
		if newline {
			b.WriteByte('\n')
		}
	}

	refsByLine := map[Reference]bool{}
	removalsByLine := map[Removal]bool{}

	for _, ref := range references {
		refsByLine[ref] = true
	}

	for _, removal := range removals {
		removalsByLine[removal] = true
	}

	originalLines := strings.Split(original, "\n")
	proposedLines := strings.Split(proposed, "\n")

	// normalize comments in case the wrong comment symbols were used
	openingCommentSymbol, closingCommentSymbol := GetCommentSymbols(language)
	if openingCommentSymbol != "" {
		for i, line := range proposedLines {
			// keep indentation for syntax parsing
			content := strings.TrimSpace(line)

			if removalsByLine[Removal(i+1)] || refsByLine[Reference(i+1)] {
				comment := openingCommentSymbol + " ref " + closingCommentSymbol
				proposedLines[i] = strings.Replace(line, content, comment, 1)
			}
		}
	}

	proposedWithNormalizedComments := strings.Join(proposedLines, "\n")
	res.Proposed = proposedWithNormalizedComments

	originalBytes := []byte(original)
	proposedBytes := []byte(proposedWithNormalizedComments)

	originalTree, err := parser.ParseCtx(ctx, nil, originalBytes)
	if err != nil {
		return nil, fmt.Errorf("failed to parse the original content: %v", err)
	}
	defer originalTree.Close()

	proposedTree, err := parser.ParseCtx(ctx, nil, proposedBytes)
	if err != nil {
		return nil, fmt.Errorf("failed to parse the proposed content: %v", err)
	}
	defer proposedTree.Close()

	if verboseLogging {
		fmt.Printf("anchorLines: %v\n", anchorLines)
	}

	oRes := BuildNodeIndex(originalTree)
	pRes := BuildNodeIndex(proposedTree)

	originalNodesByLineIndex := oRes.nodesByLine
	proposedNodesByLineIndex := pRes.nodesByLine
	originalParentsByLineIndex := oRes.parentsByLine

	findNextAnchor := func(s string, pLineNum int, pNode *tree_sitter.Node, fromLine int) *tsAnchor {
		oLineNum, ok := anchorLines[pLineNum]
		if ok {
			if verboseLogging {
				fmt.Printf("found anchor in anchorLines: oLineNum: %d, pLineNum: %d\n", oLineNum, pLineNum)
			}

			oNode := originalNodesByLineIndex[oLineNum-1]

			if verboseLogging {
				fmt.Printf("oNode.Type(): %s\n", oNode.Type())
			}

			anchor := &tsAnchor{open: oLineNum, close: int(oNode.EndPoint().Row) + 1}
			if verboseLogging {
				fmt.Printf("found anchor: %v\n", anchor)
			}
			return anchor
		} else {
			if verboseLogging {
				fmt.Printf("no anchor found in anchorLines: pLineNum: %d\n", pLineNum)
			}
		}

		for idx, line := range originalLines {
			if idx < fromLine {
				continue
			}

			if strings.TrimSpace(line) == "" {
				continue
			}

			// if verboseLogging {
			// 	fmt.Printf("line: %s, idx: %d\n", line, idx)
			// }

			oNode := originalNodesByLineIndex[idx]

			if verboseLogging {
				// fmt.Println("node:")
				// fmt.Println(oNode.Type())
				// fmt.Println(oNode)
				// fmt.Println(oNode.Content(originalBytes))
			}

			// just using string matching for now since there's too much ambiguity in node-based matching
			stringMatch := line == s
			// nodeMatch := oNode != nil && oNode.IsNamed() && nodesMatch(oNode, pNode, originalBytes, proposedBytes)

			if stringMatch {
				var endLineNum int
				if oNode != nil {
					if verboseLogging {
						fmt.Printf("oNode.Type(): %s\n", oNode.Type())
						fmt.Printf("oNode.EndPoint().Row: %d\n", oNode.EndPoint().Row)
						// fmt.Printf("%v\n", oNode)
						// fmt.Printf("oNode.Content(originalBytes):\n%q\n", oNode.Content(originalBytes))
					}
					endLineNum = int(oNode.EndPoint().Row) + 1
				}
				if verboseLogging {
					fmt.Printf("found match: num: %d, endLineNum: %d\n", idx+1, endLineNum)
					//   fmt.Println(oNode.Content(originalBytes))
				}

				return &tsAnchor{open: idx + 1, close: endLineNum}
			}
		}
		return nil
	}

	proposedUpdatesHaveLine := func(line string, afterLine int) bool {
		for idx, pLine := range proposedLines {
			pLineNum := idx + 1

			// if verboseLogging {
			// 	fmt.Printf("proposedUpdatesHaveLine - lineNum: %d, line: %s, pLine: %s, afterLine: %d\n", pLineNum, line, pLine, afterLine)
			// }

			if pLineNum > afterLine && pLine == line {
				return true
			}
		}
		return false
	}

	var oLineNum int = 0
	var refOpen bool
	var refStart int
	var refOriginalParent *tree_sitter.Node
	var postRefBuffers []strings.Builder

	closingLinesByPLineNum := map[int]int{}
	var noMatchUntilStructureClose string
	depth := 0

	var currentPNode *tree_sitter.Node
	var currentPNodeEndsAtIdx int
	var currentPNodeMatches bool

	lastLineMatched := true
	foundAnyAnchor := false

	setOLineNum := func(n int) {
		oLineNum = n
		if verboseLogging {
			fmt.Printf("setting oLineNum: %d\n", oLineNum)
		}
	}

	writeToLatestPostRefBuffer := func(s string) {
		latestBuffer := &postRefBuffers[len(postRefBuffers)-1]
		latestBuffer.WriteString(s)
		latestBuffer.WriteByte('\n')

		if verboseLogging {
			fmt.Printf("writing to latest postRefBuffer: %q\n", s)
		}
	}

	addNewPostRefBuffer := func() {
		postRefBuffers = append(postRefBuffers, strings.Builder{})

		if verboseLogging {
			fmt.Printf("adding new postRefBuffer\n")
		}
	}

	resetPostRefBuffers := func() {
		postRefBuffers = []strings.Builder{}

		if verboseLogging {
			fmt.Printf("resetting postRefBuffers\n")
		}
	}

	incDepth := func() {
		depth++
		if verboseLogging {
			fmt.Printf("incrementing depth: %d\n", depth)
		}
	}

	decDepth := func() {
		depth--
		if verboseLogging {
			fmt.Printf("decrementing depth: %d\n", depth)
		}
	}

	writeRefs := func(eof bool) bool {
		numRefs := len(postRefBuffers)
		if numRefs == 1 {
			if verboseLogging {
				fmt.Println("writeRefs")
				fmt.Printf("numRefs == 1, refStart: %d, oLineNum: %d\n", refStart, oLineNum)
			}

			var fullRef []string
			if eof {
				start := refStart - 1
				fullRef = originalLines[start:]
				if verboseLogging {
					fmt.Println("eof")
					fmt.Printf("fullRef refStart: %d\n", refStart)
					fmt.Printf("originalLines[refStart]: %q\n", originalLines[refStart])
					fmt.Printf("writing eof fullRef: %q\n", strings.Join(fullRef, "\n"))
					fmt.Printf("depth: %d\n", depth)
				}
			} else {
				start := refStart - 1
				if start < 0 {
					start = 0
				}
				end := oLineNum - 1
				if end < 1 {
					end = 0
				}

				// Add detailed diagnostic logging for invalid slice bounds
				if start > end {
					fmt.Printf("\n=== INVALID SLICE BOUNDS DIAGNOSTIC INFO ===\n")
					fmt.Printf("start: %d, end: %d\n", start, end)
					fmt.Printf("refStart: %d, oLineNum: %d\n", refStart, oLineNum)
					fmt.Printf("depth: %d, refOpen: %v\n", depth, refOpen)

					// Log relevant lines for context
					fmt.Printf("\nOriginal lines context:\n")
					startContext := max(0, start-2)
					endContext := min(len(originalLines), end+3)
					for i := startContext; i < endContext; i++ {
						fmt.Printf("line %d: %q\n", i+1, originalLines[i])
					}

					fmt.Printf("\nProposed lines context:\n")
					fmt.Printf("=====================================\n\n")

					res.NeedsVerifyReasons = append(res.NeedsVerifyReasons, NeedsVerifyReasonAmbiguousLocation)

					return false
				}

				if verboseLogging {
					fmt.Printf("writing fullRef\n")
					fmt.Printf("refStart: %d, oLineNum: %d\n", refStart, oLineNum)
					fmt.Printf("start: %d, end: %d\n", start, end)
				}
				fullRef = originalLines[start:end]
				if verboseLogging {
					fmt.Printf("fullRef refStart: %d, oLineNum-1: %d\n", refStart, oLineNum-1)
					fmt.Printf("originalLines[start]: %q\n", originalLines[start])
					fmt.Printf("originalLines[end]: %q\n", originalLines[end])
					fmt.Printf("depth: %d\n", depth)
				}
			}

			write(strings.Join(fullRef, "\n"), !eof)

			postRefContent := postRefBuffers[0].String()

			if strings.TrimSpace(postRefContent) != "" {
				if verboseLogging {
					fmt.Println("writing postRefBuffer")
				}
				write(postRefBuffers[0].String(), false)
			}
		} else {
			if verboseLogging {
				fmt.Printf("numRefs > 1, refOriginalParent: %s, eof: %v\n", refOriginalParent.Type(), eof)
				fmt.Printf("refOriginalParent.Content(originalBytes):\n%q\n", refOriginalParent.Content(originalBytes))
				fmt.Printf("numRefs: %d, oLineNum: %d\n", numRefs, oLineNum)
			}

			var upToLine int
			if eof {
				upToLine = len(originalLines)
			} else {
				upToLine = oLineNum
			}

			sections := getSections(
				refOriginalParent,
				originalBytes,
				numRefs,
				refStart,
				upToLine,
				foundAnyAnchor,
			)

			for i, section := range sections {
				if verboseLogging {
					fmt.Printf("writing section i: %d\n", i)
					// fmt.Printf("writing i: %d, section:\n%q\n	", i, section.String(originalLines, originalBytes))
				}
				write(section.String(originalLines, originalBytes), false)
				if verboseLogging {
					fmt.Println("writing postRefBuffer")
				}
				write(postRefBuffers[i].String(), false)
			}
		}

		return true
	}

	for idx, pLine := range proposedLines {
		finalLine := idx == len(proposedLines)-1
		pLineNum := idx + 1

		if verboseLogging {
			fmt.Printf("\n\ni: %d, num: %d, pLine: %q, refOpen: %v\n", idx, pLineNum, pLine, refOpen)
		}

		isRef := refsByLine[Reference(pLineNum)]
		isRemoval := removalsByLine[Removal(pLineNum)]

		if verboseLogging {
			fmt.Printf("isRef: %v\n", isRef)
			fmt.Printf("isRemoval: %v\n", isRemoval)
			fmt.Printf("oLineNum: %d\n", oLineNum)
			fmt.Printf("currentPNode set: %v\n", currentPNode != nil)
			fmt.Printf("currentPNodeEndsAtIdx: %d\n", currentPNodeEndsAtIdx)
			fmt.Printf("currentPNodeMatches: %v\n", currentPNodeMatches)
			fmt.Printf("lastLineMatched: %v\n", lastLineMatched)
			fmt.Printf("depth: %d\n", depth)
		}

		if isRemoval {
			if verboseLogging {
				fmt.Println("isRemoval - skip line")
			}
			continue
		}

		if isRef {
			if !refOpen {
				if verboseLogging {
					fmt.Println("isRef - opening ref")
					pnode := proposedNodesByLineIndex[idx]
					fmt.Printf("pnode.Type(): %s\n", pnode.Type())
					// fmt.Printf("pnode.Content(proposedBytes):\n%q\n", pnode.Content(proposedBytes))
				}

				refOpen = true
				setOLineNum(oLineNum + 1)
				refStart = oLineNum

				if verboseLogging {
					fmt.Printf("setting refStart: %d\n", refStart)
				}

				if depth > 0 {
					refNode := originalNodesByLineIndex[refStart-1]

					if verboseLogging {
						fmt.Printf("refNode.Type(): %s\n", refNode.Type())
						// fmt.Printf("refNode.Content(originalBytes): %q\n", refNode.Content(originalBytes))

						current := refNode
						depth := 0
						for current != nil {
							fmt.Printf("parent depth %d type: %s content: %q\n",
								depth,
								current.Type(),
								current.Content(originalBytes))
							current = current.Parent()
							depth++
						}
					}

					refOriginalParent = originalParentsByLineIndex[refStart-1]

					if verboseLogging {
						fmt.Printf("setting refOriginalParent | refNode.Parent() | Type(): %s\n", refOriginalParent.Type())
					}
				} else {
					refOriginalParent = originalTree.RootNode()

					if verboseLogging {
						fmt.Printf("setting refOriginalParent | originalTree.RootNode() | Type(): %s\n", refOriginalParent.Type())
					}
				}

			}

			addNewPostRefBuffer()

			continue
		}

		if !refOpen && lastLineMatched && !currentPNodeMatches {
			if strings.TrimSpace(pLine) == "" {
				write(pLine, !finalLine)
				// Check if next line in original is also blank
				if oLineNum+1 < len(originalLines) && strings.TrimSpace(originalLines[oLineNum+1]) == "" {
					setOLineNum(oLineNum + 1)
				}
				continue
			}
		}

		pNode := proposedNodesByLineIndex[idx]
		pNodeStartsThisLine := pNode.StartPoint().Row == uint32(idx)
		pNodeEndsAtIdx := int(pNode.EndPoint().Row)
		pNodeMultiline := pNodeEndsAtIdx > idx

		var matching bool
		isClosingAnchor := closingLinesByPLineNum[pLineNum] != 0

		if verboseLogging {
			fmt.Printf("currentPNode != nil: %v\n", currentPNode != nil)
			fmt.Printf("currentPNodeMatches: %v\n", currentPNodeMatches)
		}

		if isClosingAnchor {
			if verboseLogging {
				fmt.Printf("isClosingAnchor: %v\n", isClosingAnchor)
			}
			matching = true
			setOLineNum(closingLinesByPLineNum[pLineNum])
			noMatchUntilStructureClose = ""
		} else if noMatchUntilStructureClose != pLine && !(currentPNode != nil && !currentPNodeMatches) {
			// find next line in original that matches
			anchor := findNextAnchor(pLine, pLineNum, pNode, oLineNum-1)
			if anchor != nil {
				foundAnyAnchor = true
				if verboseLogging {
					fmt.Println("anchor found")
					fmt.Printf("anchor.close: %d, anchor.open: %d\n", anchor.close, anchor.open)
				}
				matching = true
				setOLineNum(anchor.open)

				if pNodeStartsThisLine && pNodeMultiline && currentPNode != nil {
					currentPNodeMatches = true
				}

				if anchor.close != 0 && anchor.close != anchor.open {

					originalClosingLine := originalLines[anchor.close-1]

					if verboseLogging {
						fmt.Printf("originalClosingLine: %s\n", originalClosingLine)
					}

					if proposedUpdatesHaveLine(originalClosingLine, idx) {
						// if verboseLogging {
						// 	fmt.Printf("proposedUpdatesHaveLine: %v\n", proposedUpdatesHaveLine(originalClosingLine, anchor.open))
						// }
						if verboseLogging {
							fmt.Printf("proposedUpdatesHaveLine: %v\n", proposedUpdatesHaveLine(originalClosingLine, anchor.open))
						}
						closingPLineNum := int(pNode.EndPoint().Row) + 1
						closingLinesByPLineNum[closingPLineNum] = anchor.close
						noMatchUntilStructureClose = originalClosingLine
						incDepth()
						if verboseLogging {
							fmt.Printf("anchor.close: %d\n", anchor.close)
							fmt.Printf("closingPLineNum: %d\n", closingPLineNum)
							fmt.Printf("noMatchUntilStructureClose: %s\n", noMatchUntilStructureClose)
						}
					} else {
						if verboseLogging {
							fmt.Println("proposed updates do not have originalClosingLine")
						}
					}
				}
			}
		}

		if pNodeStartsThisLine && pNodeMultiline && (currentPNode == nil || matching != currentPNodeMatches) {
			if verboseLogging {
				fmt.Printf("setting currentPNode: %s\n", pNode.Type())
				fmt.Printf("pNodeEndsAtIdx: %d\n", pNodeEndsAtIdx)
				// fmt.Printf("content: %q\n", pNode.Content(proposedBytes))
				// fmt.Println(pNode)
			}
			currentPNode = pNode
			currentPNodeEndsAtIdx = pNodeEndsAtIdx
			currentPNodeMatches = matching

		}

		wroteRefs := false
		if matching {
			if verboseLogging {
				fmt.Printf("matching line: %s, oLineNum: %d\n", pLine, oLineNum)
			}

			if refOpen {
				// we found the end of the current reference
				if verboseLogging {
					fmt.Printf("closing ref, oLineNum: %d\n", oLineNum)
				}
				refOpen = false
				ok := writeRefs(false)
				if !ok {
					return res, nil
				}
				write(pLine, !finalLine)
				wroteRefs = true
			}
		} else {
			if verboseLogging {
				fmt.Printf("no matching line\n")
			}
		}

		lastLineMatched = matching

		if currentPNodeEndsAtIdx == idx {
			currentPNode = nil
			currentPNodeEndsAtIdx = 0
			currentPNodeMatches = false
		}

		if isClosingAnchor {
			decDepth()
		}

		if wroteRefs {
			// reset buffers
			resetPostRefBuffers()
		} else {
			if refOpen {
				writeToLatestPostRefBuffer(pLine)
			} else {
				if verboseLogging {
					fmt.Printf("writing pLine: %s\n", pLine)
				}
				write(pLine, !finalLine)
			}

		}

	}

	if refOpen {
		ok := writeRefs(true)
		if !ok {
			return res, nil
		}
	}

	if verboseLogging {
		// fmt.Printf("final result:\n%s\n", b.String())
	}

	res.NewFile = b.String()

	return res, nil
}


================================================
FILE: app/server/syntax/unique_replacement.go
================================================
package syntax

import "strings"

func FindUniqueReplacement(originalFile, old string) string {
	oldCount := strings.Count(originalFile, old)

	if oldCount == 1 {
		// perfect match
		return old
	}

	// try to find a unique match. we're forgiving of errors in the middle if we can still identify the block uniquely by checking from both ends
	startMatch := ""
	endMatch := ""
	n := 0
	oldLength := len(old)

	for {
		n++
		if n > oldLength {
			// Prevent slice bounds error
			return ""
		}

		startMatch = old[0:n]
		endMatch = old[oldLength-n : oldLength]

		startOccurrences := strings.Count(originalFile, startMatch)

		if startOccurrences == 0 {
			// lost the match from the start
			return ""
		}

		var endOccurrences int
		var afterStart string
		if startOccurrences == 1 {
			startSplit := strings.Split(originalFile, startMatch)
			afterStart = startSplit[1]

			endOccurrences = strings.Count(afterStart, endMatch)
		} else {
			endOccurrences = strings.Count(originalFile, endMatch)
		}

		if endOccurrences == 0 {
			// lost the match from the end
			return ""
		}

		var beforeEnd string
		if endOccurrences == 1 {
			endSplit := strings.Split(originalFile, endMatch)
			beforeEnd = endSplit[0]
			if startOccurrences > 1 {
				startOccurrences = strings.Count(beforeEnd, startMatch)
			}
		}

		if startOccurrences == 1 && endOccurrences == 1 {
			afterStartIndex := strings.Index(originalFile, afterStart)
			beforeEndIndex := strings.Index(originalFile, beforeEnd)

			startIndex := beforeEndIndex + strings.Index(beforeEnd, startMatch)
			endIndex := afterStartIndex + strings.Index(afterStart, endMatch) + len(endMatch)
			return originalFile[startIndex:endIndex]
		} else {
			// couldn't get a unique match on both ends, keep narrowing down
			continue
		}

	}
}


================================================
FILE: app/server/syntax/unique_replacement_test.go
================================================
package syntax

import (
	"testing"
)

func TestFindUniqueReplacement(t *testing.T) {
	tests := []struct {
		name         string
		originalFile string
		old          string
		want         string
	}{
		{
			name:         "perfect single match",
			originalFile: "prefix ABC123DEF suffix",
			old:          "ABC123DEF",
			want:         "ABC123DEF",
		},
		{
			name:         "match with error in middle",
			originalFile: "prefix ABC999DEF suffix",
			old:          "ABC123DEF",
			want:         "ABC999DEF",
		},
		{
			name:         "multiple instances but unique boundaries",
			originalFile: "ABC123XYZ ABC456XYZ ABC789DEF",
			old:          "ABC789DEF",
			want:         "ABC789DEF",
		},
		{
			name:         "no match at all",
			originalFile: "completely different text",
			old:          "ABC123DEF",
			want:         "",
		},
		{
			name:         "multiple complete matches",
			originalFile: "ABC123DEF ABC123DEF",
			old:          "ABC123DEF",
			want:         "", // should fail because not unique
		},
		{
			name:         "ambiguous boundaries",
			originalFile: "ABC123DEF ABC456DEF",
			old:          "ABC789DEF",
			want:         "", // should fail because multiple possible matches
		},
		{
			name:         "match with very different middle",
			originalFile: "prefix ABCCOMPLETELY_DIFFERENT_TEXTDEF suffix",
			old:          "ABC123DEF",
			want:         "ABCCOMPLETELY_DIFFERENT_TEXTDEF",
		},
		{
			name:         "unique match near identical text",
			originalFile: "ABCDEF ABC123DEF ABCXEF",
			old:          "ABC123DEF",
			want:         "ABC123DEF",
		},
		{
			name:         "identical start/end patterns",
			originalFile: "AAA123AAA AAA456AAA",
			old:          "AAA789AAA",
			want:         "", // should fail because boundaries are ambiguous
		},
		{
			name:         "overlapping patterns",
			originalFile: "ABCABCDEF",
			old:          "ABCDEF",
			want:         "ABCDEF",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := FindUniqueReplacement(tt.originalFile, tt.old)
			if got != tt.want {
				t.Errorf("FindUniqueReplacement(%q, %q) = %q, want %q",
					tt.originalFile, tt.old, got, tt.want)
			}
		})
	}
}


================================================
FILE: app/server/syntax/validate.go
================================================
package syntax

import (
	"strings"
	"time"

	shared "plandex-shared"

	tree_sitter "github.com/smacker/go-tree-sitter"

	"context"
	"fmt"
)

const parserTimeout = 500 * time.Millisecond

type ValidationRes = struct {
	Lang     shared.Language
	Parser   *tree_sitter.Parser
	TimedOut bool
	Valid    bool
	Errors   []string
}

func ValidateFile(ctx context.Context, path string, file string) (*ValidationRes, error) {
	parser, lang, fallbackParser, fallbackLang := GetParserForPath(path)

	if parser == nil {
		return &ValidationRes{Lang: lang, Parser: nil}, nil
	}

	return ValidateWithParsers(ctx, lang, parser, fallbackLang, fallbackParser, file)
}

func ValidateWithParsers(ctx context.Context, lang shared.Language, parser *tree_sitter.Parser, fallbackLang shared.Language, fallbackParser *tree_sitter.Parser, file string) (*ValidationRes, error) {
	if file == "" {
		return &ValidationRes{Lang: lang, Parser: parser, Valid: true}, nil
	}

	// Set a timeout duration for the parsing operations
	ctx, cancel := context.WithTimeout(ctx, parserTimeout)
	defer cancel()

	// Parse the content
	tree, err := parser.ParseCtx(ctx, nil, []byte(file))

	if err != nil || tree == nil {
		if err != nil && err.Error() == "operation limit was hit" {
			return &ValidationRes{Lang: lang, Parser: parser, TimedOut: true}, nil
		}

		return nil, fmt.Errorf("failed to parse the content: %v", err)
	}
	defer tree.Close()

	// Get the root node of the syntax tree and check for errors
	root := tree.RootNode()

	if root.HasError() {
		if fallbackParser != nil {
			fallbackTree, err := fallbackParser.ParseCtx(ctx, nil, []byte(file))
			if err != nil || fallbackTree == nil {

				if err != nil && strings.Contains(err.Error(), "timeout") {
					return &ValidationRes{Lang: lang, Parser: parser, TimedOut: true}, nil
				}

				return nil, fmt.Errorf("failed to parse the content with fallback parser: %v", err)
			}
			defer fallbackTree.Close()

			root = fallbackTree.RootNode()

			if !root.HasError() {
				return &ValidationRes{Lang: fallbackLang, Parser: fallbackParser, Valid: true}, nil
			}
		}

		errorMarkers := insertErrorMarkers(file, root)

		return &ValidationRes{
			Lang:   lang,
			Parser: parser,
			Valid:  false,
			Errors: errorMarkers,
		}, nil

	}

	return &ValidationRes{Lang: lang, Parser: parser, Valid: true}, nil
}

func insertErrorMarkers(source string, node *tree_sitter.Node) []string {
	if source == "" {
		return []string{}
	}

	var markers []string
	var uniqueMarkers = map[string]bool{}

	// Function to calculate line numbers
	calculateLineNumber := func(position int) int {
		return strings.Count(source[:position], "\n") + 1
	}

	hasChildError := func(n *tree_sitter.Node) bool {
		for i := 0; i < int(n.ChildCount()); i++ {
			if n.Child(i).HasError() {
				return true
			}
		}
		return false
	}

	visitNodes(node, func(n *tree_sitter.Node) {
		if n.HasError() && !hasChildError(n) {
			startPosition := int(n.StartByte())
			endPosition := int(n.EndByte())
			startLineNumber := calculateLineNumber(startPosition)
			endLineNumber := calculateLineNumber(endPosition)

			if startLineNumber == endLineNumber {
				uniqueMarkers[fmt.Sprintf("Invalid syntax on line %d", startLineNumber)] = true
			} else {
				uniqueMarkers[fmt.Sprintf("Invalid syntax on lines %d to %d", startLineNumber, endLineNumber)] = true
			}

		}
	})

	for marker := range uniqueMarkers {
		markers = append(markers, marker)
	}

	return markers
}

// visitNodes recursively visits nodes in the syntax tree
func visitNodes(n *tree_sitter.Node, f func(node *tree_sitter.Node)) {
	f(n)
	for i := 0; i < int(n.ChildCount()); i++ {
		child := n.Child(i)
		visitNodes(child, f)
	}
}


================================================
FILE: app/server/types/active_plan.go
================================================
package types

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"plandex-server/db"
	"plandex-server/notify"
	"plandex-server/shutdown"
	"sync"
	"time"

	shared "plandex-shared"

	"github.com/davecgh/go-spew/spew"
	"github.com/google/uuid"
)

const MaxStreamRate = 70 * time.Millisecond
const ActivePlanTimeout = 2 * time.Hour

type ActiveBuild struct {
	ReplyId           string
	FileDescription   string
	FileContent       string
	FileContentTokens int
	CurrentFileTokens int
	Path              string
	Success           bool
	Error             error
	IsMoveOp          bool
	MoveDestination   string
	IsRemoveOp        bool
	IsResetOp         bool
}

type subscription struct {
	ch           chan string
	ctx          context.Context
	cancelFn     context.CancelFunc
	mu           sync.Mutex // Protects the messageQueue
	messageQueue []string
	cond         *sync.Cond // Used to wait for and signal new messages
}

type ActivePlan struct {
	Id                      string
	UserId                  string
	OrgId                   string
	CurrentStreamingReplyId string
	CurrentReplyDoneCh      chan bool
	Branch                  string
	Prompt                  string
	BuildOnly               bool
	Ctx                     context.Context
	CancelFn                context.CancelFunc
	ModelStreamCtx          context.Context
	CancelModelStreamFn     context.CancelFunc
	SummaryCtx              context.Context
	SummaryCancelFn         context.CancelFunc
	// LatestSummaryCh         chan *db.ConvoSummary
	Contexts              []*db.Context
	ContextsByPath        map[string]*db.Context
	Operations            []*shared.Operation
	BuiltFiles            map[string]bool
	IsBuildingByPath      map[string]bool
	CurrentReplyContent   string
	NumTokens             int
	MessageNum            int
	BuildQueuesByPath     map[string][]*ActiveBuild
	RepliesFinished       bool
	StreamDoneCh          chan *shared.ApiError
	ModelStreamId         string
	MissingFilePath       string
	MissingFileResponseCh chan shared.RespondMissingFileChoice
	AutoContext           bool
	AutoLoadContextCh     chan struct{}
	AllowOverwritePaths   map[string]bool
	SkippedPaths          map[string]bool
	StoredReplyIds        []string
	DidEditFiles          bool
	SessionId             string

	subscriptions  map[string]*subscription
	subscriptionMu sync.Mutex

	streamCh              chan string
	streamMu              sync.Mutex
	lastStreamMessageSent time.Time
	streamMessageBuffer   []shared.StreamMessage
}

func NewActivePlan(orgId, userId, planId, branch, prompt string, buildOnly, autoContext bool, sessionId string) *ActivePlan {
	ctx, cancel := context.WithTimeout(shutdown.ShutdownCtx, ActivePlanTimeout)
	// child context for model stream so we can cancel it separately if needed
	modelStreamCtx, cancelModelStream := context.WithCancel(ctx)

	// we don't want to cancel summaries unless the whole plan is stopped or there's an error -- if the active plan finishes, we want summaries to continue -- so they get their own context
	summaryCtx, cancelSummary := context.WithCancel(shutdown.ShutdownCtx)

	active := ActivePlan{
		Id:                    planId,
		OrgId:                 orgId,
		UserId:                userId,
		BuildOnly:             buildOnly,
		Branch:                branch,
		Prompt:                prompt,
		Ctx:                   ctx,
		CancelFn:              cancel,
		ModelStreamCtx:        modelStreamCtx,
		CancelModelStreamFn:   cancelModelStream,
		SummaryCtx:            summaryCtx,
		SummaryCancelFn:       cancelSummary,
		BuildQueuesByPath:     map[string][]*ActiveBuild{},
		Contexts:              []*db.Context{},
		ContextsByPath:        map[string]*db.Context{},
		Operations:            []*shared.Operation{},
		BuiltFiles:            map[string]bool{},
		IsBuildingByPath:      map[string]bool{},
		StreamDoneCh:          make(chan *shared.ApiError),
		MissingFileResponseCh: make(chan shared.RespondMissingFileChoice),
		AutoContext:           autoContext,
		AutoLoadContextCh:     make(chan struct{}),
		AllowOverwritePaths:   map[string]bool{},
		SkippedPaths:          map[string]bool{},
		SessionId:             sessionId,
		streamCh:              make(chan string),
		subscriptions:         map[string]*subscription{},
		subscriptionMu:        sync.Mutex{},
	}

	go func() {
		defer func() {
			log.Println("ActivePlan stream manager returned")
			if r := recover(); r != nil {
				log.Printf("Recovered in send to subscriber: %v\n", r)
			}
		}()
		for {
			select {
			case <-active.Ctx.Done():
				return
			case msg := <-active.streamCh:
				var subscriptions map[string]*subscription
				active.subscriptionMu.Lock()
				subscriptions = active.subscriptions
				active.subscriptionMu.Unlock()
				for _, sub := range subscriptions {
					sub.enqueueMessage(msg)
				}

			}
		}
	}()

	return &active
}

func (ap *ActivePlan) FlushStreamBuffer() {
	ap.streamMu.Lock()
	if len(ap.streamMessageBuffer) == 0 {
		ap.streamMu.Unlock()
		return
	}

	bufferToFlush := ap.streamMessageBuffer
	ap.streamMessageBuffer = []shared.StreamMessage{}
	ap.streamMu.Unlock()

	if len(bufferToFlush) == 1 {
		log.Println("ActivePlan.FlushStreamBuffer: flushing single message")
		ap.Stream(bufferToFlush[0])
	} else {
		log.Println("ActivePlan.FlushStreamBuffer: flushing multi-message")
		ap.Stream(shared.StreamMessage{
			Type:           shared.StreamMessageMulti,
			StreamMessages: bufferToFlush,
		})
	}
}

const verboseStreamLogging = false

func (ap *ActivePlan) Stream(msg shared.StreamMessage) {
	if verboseStreamLogging {
		log.Println("ActivePlan.Stream:")
		log.Println(msg)
	}

	ap.streamMu.Lock()

	skipBuffer := false
	if msg.Type == shared.StreamMessagePromptMissingFile || msg.Type == shared.StreamMessageLoadContext || msg.Type == shared.StreamMessageFinished || msg.Type == shared.StreamMessageError {
		skipBuffer = true

		log.Println("ActivePlan.Stream: skipping buffer for special message")
		log.Println(spew.Sdump(msg))
	}

	// Special messages bypass buffering
	if !skipBuffer {
		if verboseStreamLogging {
			log.Println("ActivePlan.Stream: time since last message sent:", time.Since(ap.lastStreamMessageSent))
		}

		if time.Since(ap.lastStreamMessageSent) < MaxStreamRate {
			if verboseStreamLogging {
				log.Println("ActivePlan.Stream: buffering message")
			}

			// Buffer the message
			ap.streamMessageBuffer = append(ap.streamMessageBuffer, msg)
			ap.streamMu.Unlock()
			return
		} else if len(ap.streamMessageBuffer) > 0 {
			if verboseStreamLogging {
				log.Println("ActivePlan.Stream: flushing buffer")
			}

			// Need to flush buffer first
			ap.streamMessageBuffer = append(ap.streamMessageBuffer, msg)
			bufferToFlush := ap.streamMessageBuffer
			ap.streamMessageBuffer = []shared.StreamMessage{}
			ap.streamMu.Unlock()

			if verboseStreamLogging {
				log.Println("ActivePlan.Stream: sending multi-message:")
				log.Println(bufferToFlush)
			}
			// Send as multi-message
			ap.Stream(shared.StreamMessage{
				Type:           shared.StreamMessageMulti,
				StreamMessages: bufferToFlush,
			})
			return
		}
	}

	// Direct send path
	msgJson, err := json.Marshal(msg)
	if err != nil {
		ap.streamMu.Unlock()
		go notify.NotifyErr(notify.SeverityError, fmt.Errorf("error marshalling stream message: %v", err))

		ap.StreamDoneCh <- &shared.ApiError{
			Type:   shared.ApiErrorTypeOther,
			Status: http.StatusInternalServerError,
			Msg:    "Error marshalling stream message: " + err.Error(),
		}
		return
	}

	if skipBuffer && len(ap.streamMessageBuffer) > 0 {
		// Handle any remaining buffered messages before sending the message
		// log.Println("ActivePlan.Stream: message is a skip buffer type and there are buffered messages")
		// log.Println("ActivePlan.Stream: flushing remaining buffered messages before skip buffer message is sent")
		bufferToFlush := ap.streamMessageBuffer
		ap.streamMessageBuffer = []shared.StreamMessage{}
		ap.streamMu.Unlock()

		log.Println("Flushing buffered messages before finishing")
		// log.Println("ActivePlan.Stream: sending multi-message:")
		// log.Println(bufferToFlush)
		ap.Stream(shared.StreamMessage{
			Type:           shared.StreamMessageMulti,
			StreamMessages: bufferToFlush,
		})
		log.Println("ActivePlan.Stream: finished flushing buffered messages. waiting 50ms before sending skip buffer type message")
		time.Sleep(50 * time.Millisecond)
		log.Println("ActivePlan.Stream: sending finish message")
		ap.Stream(msg) // send the skip buffer type message

		ap.streamMu.Lock()
		now := time.Now()
		if now.After(ap.lastStreamMessageSent) {
			ap.lastStreamMessageSent = now
		}

		if msg.Type == shared.StreamMessageFinished {
			ap.streamMu.Unlock()
			// wait for the finish message to be sent then send the done signal
			log.Println("ActivePlan.Stream: waiting 50ms before sending done signal")
			time.Sleep(50 * time.Millisecond)
			log.Println("ActivePlan.Stream: sending done signal")
			ap.StreamDoneCh <- nil
			return
		}
	}

	if verboseStreamLogging {
		log.Println("ActivePlan.Stream: sending direct message")
		log.Println(string(msgJson))
	}

	ap.streamCh <- string(msgJson)

	now := time.Now()
	if now.After(ap.lastStreamMessageSent) {
		ap.lastStreamMessageSent = now
	}
	ap.streamMu.Unlock()

	if msg.Type == shared.StreamMessageFinished {
		log.Println("ActivePlan.Stream: waiting 50ms before sending done signal")
		time.Sleep(50 * time.Millisecond)
		log.Println("ActivePlan.Stream: sending done signal")
		ap.StreamDoneCh <- nil
	}
}

func (ap *ActivePlan) ResetModelCtx() {
	ap.ModelStreamCtx, ap.CancelModelStreamFn = context.WithCancel(ap.Ctx)
}

func (ap *ActivePlan) BuildFinished() bool {
	for path := range ap.BuildQueuesByPath {
		if ap.IsBuildingByPath[path] || !ap.PathQueueEmpty(path) {
			log.Printf("BuildFinished - %s - is building %t - path queue not empty %t\n", path, ap.IsBuildingByPath[path], !ap.PathQueueEmpty(path))
			return false
		}
	}
	return true
}

func (ap *ActivePlan) PathQueueEmpty(path string) bool {
	// log.Printf("PathQueueEmpty - %s\n", path)
	// log.Println(spew.Sdump(ap.BuildQueuesByPath[path]))
	for _, build := range ap.BuildQueuesByPath[path] {
		if !build.BuildFinished() {
			// log.Printf("PathQueueEmpty - %s - build not finished\n", path)
			return false
		}
	}
	return true
}

func (ap *ActivePlan) Subscribe(reqCtx context.Context) (string, chan string) {
	ap.subscriptionMu.Lock()
	defer ap.subscriptionMu.Unlock()
	id := uuid.New().String()

	planCtx := ap.Ctx // from the plan

	// Make a subscription context that will end if EITHER the request ends
	// OR the plan’s context ends:
	subCtx, subCancel := context.WithCancel(shutdown.ShutdownCtx)

	// Use a small goroutine to combine the two cancels:
	go func() {
		select {
		case <-reqCtx.Done():
			// client disconnected
		case <-planCtx.Done():
			// plan ended
		}
		subCancel()
	}()

	sub := newSubscription(subCtx)

	ap.subscriptions[id] = sub
	return id, sub.ch
}

func (ap *ActivePlan) Unsubscribe(id string) {
	ap.subscriptionMu.Lock()
	defer ap.subscriptionMu.Unlock()

	sub, ok := ap.subscriptions[id]

	if ok {
		sub.cancelFn()
		sub.cond.Signal()
		delete(ap.subscriptions, id)
	}
}

func (ap *ActivePlan) NumSubscribers() int {
	ap.subscriptionMu.Lock()
	defer ap.subscriptionMu.Unlock()
	return len(ap.subscriptions)
}

func (b *ActiveBuild) BuildFinished() bool {
	return b.Success || b.Error != nil
}

func newSubscription(ctx context.Context) *subscription {
	ctx, cancel := context.WithCancel(ctx)
	sub := &subscription{
		ch:           make(chan string),
		ctx:          ctx,
		cancelFn:     cancel,
		messageQueue: make([]string, 0),
	}
	sub.mu = sync.Mutex{}
	sub.cond = sync.NewCond(&sub.mu)
	go sub.processMessages()
	return sub
}

func (sub *subscription) processMessages() {
	for {
		sub.mu.Lock()
		for len(sub.messageQueue) == 0 {
			sub.cond.Wait()           // Automatically unlocks sub.mu and waits; re-locks sub.mu upon waking.
			if sub.ctx.Err() != nil { // Check if context is cancelled after waking up.
				sub.mu.Unlock()
				return
			}
		}
		// At this point, there is at least one message in the queue
		msg := sub.messageQueue[0]
		sub.messageQueue = sub.messageQueue[1:]
		sub.mu.Unlock()

		select {
		case <-sub.ctx.Done():
			log.Println("ActivePlan: subscription context done, aborting send")
			return
		case sub.ch <- msg:
			// Message sent, proceed to next
		}
	}
}

// Adding a message to the subscription's queue
func (sub *subscription) enqueueMessage(msg string) {
	// log.Printf("ActivePlan: enqueueing message: %s\n", msg)
	sub.mu.Lock()
	sub.messageQueue = append(sub.messageQueue, msg)
	sub.mu.Unlock()
	sub.cond.Signal() // Signal the waiting goroutine that a new message is available
}

func (ap *ActivePlan) Finish() {
	ap.Stream(shared.StreamMessage{
		Type: shared.StreamMessageFinished,
	})
}

func (ab *ActiveBuild) IsFileOperation() bool {
	return ab.IsMoveOp || ab.IsRemoveOp || ab.IsResetOp
}


================================================
FILE: app/server/types/active_plan_pending_builds.go
================================================
package types

import (
	"fmt"
	"log"
	"plandex-server/db"

	shared "plandex-shared"
)

func (ap *ActivePlan) PendingBuildsByPath(orgId, userId string, convoMessagesArg []*db.ConvoMessage) (map[string][]*ActiveBuild, error) {
	planDescs, err := db.GetConvoMessageDescriptions(orgId, ap.Id)
	if err != nil {
		return nil, fmt.Errorf("error getting pending build descriptions: %v", err)
	}

	if !HasPendingBuilds(planDescs) {
		return map[string][]*ActiveBuild{}, nil
	}

	var convoMessages []*db.ConvoMessage
	if convoMessagesArg == nil {
		var err error
		convoMessages, err = db.GetPlanConvo(orgId, ap.Id)

		if err != nil {
			return nil, fmt.Errorf("error getting plan convo: %v", err)
		}
	} else {
		convoMessages = convoMessagesArg
	}

	convoMessagesById := map[string]*db.ConvoMessage{}
	for _, msg := range convoMessages {
		convoMessagesById[msg.Id] = msg
	}

	activeBuildsByPath := map[string][]*ActiveBuild{}

	for _, desc := range planDescs {
		if (!desc.DidBuild && len(desc.Operations) > 0) || len(desc.BuildPathsInvalidated) > 0 {
			if desc.ConvoMessageId == "" {
				log.Printf("No convo message ID for description: %v\n", desc)
				return nil, fmt.Errorf("no convo message ID for description: %v", desc)
			}

			if convoMessagesById[desc.ConvoMessageId] == nil {
				log.Printf("No convo message for ID: %s\n", desc.ConvoMessageId)
				return nil, fmt.Errorf("no convo message for ID: %s", desc.ConvoMessageId)
			}

			// convoMessage := convoMessagesById[desc.ConvoMessageId]

			// replyParser := NewReplyParser()
			// replyParser.AddChunk(convoMessage.Message, false)
			// parserRes := replyParser.FinishAndRead()

			numAdded := 0
			for _, op := range desc.Operations {

				if desc.DidBuild && !desc.BuildPathsInvalidated[op.Path] {
					continue
				}

				if activeBuildsByPath[op.Path] == nil {
					activeBuildsByPath[op.Path] = []*ActiveBuild{}
				}

				numTokens := shared.GetNumTokensEstimate(op.Content)

				activeBuildsByPath[op.Path] = append(activeBuildsByPath[op.Path], &ActiveBuild{
					ReplyId:           desc.ConvoMessageId,
					FileContent:       op.Content,
					FileContentTokens: numTokens,
					Path:              op.Path,
					FileDescription:   op.Description,
				})
				numAdded++
			}

		}
	}

	// log.Println("activeBuildsByPath:")
	// spew.Dump(activeBuildsByPath)

	return activeBuildsByPath, nil
}


================================================
FILE: app/server/types/auth.go
================================================
package types

import (
	"plandex-server/db"

	shared "plandex-shared"
)

type ServerAuth struct {
	AuthToken   *db.AuthToken
	User        *db.User
	OrgId       string
	Permissions shared.Permissions
}

func (a *ServerAuth) HasPermission(permission shared.Permission) bool {
	return a.Permissions.HasPermission(permission)
}

func (a *ServerAuth) HasPermissionForResource(permission shared.Permission, resourceId string) bool {
	return a.Permissions.HasPermissionForResource(permission, resourceId)
}


================================================
FILE: app/server/types/convo_message_desc.go
================================================
package types

import (
	"plandex-server/db"

	shared "plandex-shared"
)

func HasPendingBuilds(planDescs []*db.ConvoMessageDescription) bool {
	apiDescs := make([]*shared.ConvoMessageDescription, len(planDescs))
	for i, desc := range planDescs {
		apiDescs[i] = desc.ToApi()
	}

	return shared.HasPendingBuilds(apiDescs)
}


================================================
FILE: app/server/types/exec_status.go
================================================
package types

type ExecStatusResponse struct {
	Reasoning       string `json:"reasoning"`
	SubtaskFinished bool   `json:"subtaskFinished"`
}


================================================
FILE: app/server/types/message.go
================================================
package types

import (
	shared "plandex-shared"
	"time"

	"strings"

	"github.com/sashabaranov/go-openai"
)

type CacheControlType string

const (
	CacheControlTypeEphemeral CacheControlType = "ephemeral"
)

type CacheControlSpec struct {
	Type CacheControlType `json:"type"`
}

type ExtendedChatMessagePart struct {
	Type         openai.ChatMessagePartType  `json:"type"`
	Text         string                      `json:"text,omitempty"`
	ImageURL     *openai.ChatMessageImageURL `json:"image_url,omitempty"`
	CacheControl *CacheControlSpec           `json:"cache_control,omitempty"`
}

type ExtendedChatMessage struct {
	Role    string                    `json:"role"`
	Content []ExtendedChatMessagePart `json:"content"`
}

func (msg *ExtendedChatMessage) ToOpenAI() *openai.ChatCompletionMessage {
	// If there's only one part and it's text, use simple Content field
	if len(msg.Content) == 1 && msg.Content[0].Type == "text" {
		return &openai.ChatCompletionMessage{
			Role:    msg.Role,
			Content: msg.Content[0].Text,
		}
	}

	// Otherwise, use MultiContent for multiple parts or non-text content
	parts := make([]openai.ChatMessagePart, len(msg.Content))
	for i, part := range msg.Content {
		parts[i] = openai.ChatMessagePart{
			Type:     part.Type,
			Text:     part.Text,
			ImageURL: part.ImageURL,
		}
	}

	return &openai.ChatCompletionMessage{
		Role:         msg.Role,
		MultiContent: parts,
	}
}

type OpenAIPrediction struct {
	Type    string `json:"type"`
	Content string `json:"content"`
}

type ReasoningConfig struct {
	Effort    shared.ReasoningEffort `json:"effort,omitempty"`     // "high" | "medium" | "low"
	MaxTokens int                    `json:"max_tokens,omitempty"` // Anthropic-style budget
	Exclude   bool                   `json:"exclude,omitempty"`    // don’t echo reasoning in the response
}

type OpenRouterProviderConfig struct {
	Order            []string `json:"order"`
	AllowFallbacks   bool     `json:"allow_fallbacks"`
	RequireParamters bool     `json:"require_paramters"`
	DataCollection   bool     `json:"data_collection"`
	Only             []string `json:"only"`
	Ignore           []string `json:"ignore"`
}

type ExtendedChatCompletionRequest struct {
	// copied from openai.ChatCompletionRequest
	Model    shared.ModelName      `json:"model"`
	Messages []ExtendedChatMessage `json:"messages"`
	// MaxTokens The maximum number of tokens that can be generated in the chat completion.
	// This value can be used to control costs for text generated via API.
	// This value is now deprecated in favor of max_completion_tokens, and is not compatible with o1 series models.
	// refs: https://platform.openai.com/docs/api-reference/chat/create#chat-create-max_tokens
	MaxTokens int `json:"max_tokens,omitempty"`
	// MaxCompletionTokens An upper bound for the number of tokens that can be generated for a completion,
	// including visible output tokens and reasoning tokens https://platform.openai.com/docs/guides/reasoning
	MaxCompletionTokens int                                  `json:"max_completion_tokens,omitempty"`
	Temperature         float32                              `json:"temperature,omitempty"`
	TopP                float32                              `json:"top_p,omitempty"`
	N                   int                                  `json:"n,omitempty"`
	Stream              bool                                 `json:"stream,omitempty"`
	Stop                []string                             `json:"stop,omitempty"`
	PresencePenalty     float32                              `json:"presence_penalty,omitempty"`
	ResponseFormat      *openai.ChatCompletionResponseFormat `json:"response_format,omitempty"`
	Seed                *int                                 `json:"seed,omitempty"`
	FrequencyPenalty    float32                              `json:"frequency_penalty,omitempty"`
	// LogitBias is must be a token id string (specified by their token ID in the tokenizer), not a word string.
	// incorrect: `"logit_bias":{"You": 6}`, correct: `"logit_bias":{"1639": 6}`
	// refs: https://platform.openai.com/docs/api-reference/chat/create#chat/create-logit_bias
	LogitBias map[string]int `json:"logit_bias,omitempty"`
	// LogProbs indicates whether to return log probabilities of the output tokens or not.
	// If true, returns the log probabilities of each output token returned in the content of message.
	// This option is currently not available on the gpt-4-vision-preview model.
	LogProbs bool `json:"logprobs,omitempty"`
	// TopLogProbs is an integer between 0 and 5 specifying the number of most likely tokens to return at each
	// token position, each with an associated log probability.
	// logprobs must be set to true if this parameter is used.
	TopLogProbs int    `json:"top_logprobs,omitempty"`
	User        string `json:"user,omitempty"`
	// Deprecated: use Tools instead.
	Functions []openai.FunctionDefinition `json:"functions,omitempty"`
	// Deprecated: use ToolChoice instead.
	FunctionCall any           `json:"function_call,omitempty"`
	Tools        []openai.Tool `json:"tools,omitempty"`
	// This can be either a string or an ToolChoice object.
	ToolChoice any `json:"tool_choice,omitempty"`
	// Options for streaming response. Only set this when you set stream: true.
	StreamOptions *openai.StreamOptions `json:"stream_options,omitempty"`
	// Disable the default behavior of parallel tool calls by setting it: false.
	ParallelToolCalls any `json:"parallel_tool_calls,omitempty"`
	// Store can be set to true to store the output of this completion request for use in distillations and evals.
	// https://platform.openai.com/docs/api-reference/chat/create#chat-create-store
	Store bool `json:"store,omitempty"`
	// Metadata to store with the completion.
	Metadata map[string]string `json:"metadata,omitempty"`

	Prediction *OpenAIPrediction         `json:"prediction,omitempty"`
	Provider   *OpenRouterProviderConfig `json:"provider,omitempty"`

	// LiteLLM api base
	LiteLLMApiBase           string `json:"api_base,omitempty"`
	LiteLLMBaseUrl           string `json:"base_url,omitempty"`
	LiteLLMCustomLLMProvider string `json:"custom_llm_provider,omitempty"`

	// Openrouter/LiteLLM reasoning
	ReasoningConfig *ReasoningConfig `json:"reasoning,omitempty"`

	// Headers that pass through to LiteLLM proxy
	ExtraHeaders map[string]string `json:"extra_headers,omitempty"`

	// Vertex request vars
	VertexProject     string `json:"vertex_project,omitempty"`
	VertexLocation    string `json:"vertex_location,omitempty"`
	VertexCredentials string `json:"vertex_credentials,omitempty"`

	// Azure OpenAI request vars
	AzureApiVersion      string                 `json:"api_version,omitempty"`
	AzureReasoningEffort shared.ReasoningEffort `json:"reasoning_effort,omitempty"`

	// AWS Bedrock request vars
	BedrockAccessKeyId         string `json:"aws_access_key_id,omitempty"`
	BedrockSecretAccessKey     string `json:"aws_secret_access_key,omitempty"`
	BedrockSessionToken        string `json:"aws_session_token,omitempty"`
	BedrockRegion              string `json:"aws_region_name,omitempty"`
	BedrockInferenceProfileArn string `json:"aws_inference_profile_arn,omitempty"`
}

// for properties that OpenAI direct api calls support but aren't included in https://github.com/sashabaranov/go-openai
type ExtendedOpenAIChatCompletionRequest struct {
	openai.ChatCompletionRequest
	Prediction      *OpenAIPrediction       `json:"prediction,omitempty"`
	ReasoningEffort *shared.ReasoningEffort `json:"reasoning_effort,omitempty"`
}

// strips out properties that direct OpenAI api calls don't support
func (req *ExtendedChatCompletionRequest) ToOpenAI() *ExtendedOpenAIChatCompletionRequest {
	openaiMessages := make([]openai.ChatCompletionMessage, len(req.Messages))
	for i, msg := range req.Messages {
		openaiMessages[i] = *msg.ToOpenAI()
	}

	var reasoningEffort *shared.ReasoningEffort
	if req.ReasoningConfig != nil && req.ReasoningConfig.Effort != "" {
		reasoningEffort = &req.ReasoningConfig.Effort
	}

	return &ExtendedOpenAIChatCompletionRequest{
		ChatCompletionRequest: openai.ChatCompletionRequest{
			Model:               string(req.Model),
			Messages:            openaiMessages,
			MaxTokens:           req.MaxTokens,
			MaxCompletionTokens: req.MaxCompletionTokens,
			Temperature:         req.Temperature,
			TopP:                req.TopP,
			N:                   req.N,
			Stream:              req.Stream,
			Stop:                req.Stop,
			PresencePenalty:     req.PresencePenalty,
			ResponseFormat:      req.ResponseFormat,
			Seed:                req.Seed,
			FrequencyPenalty:    req.FrequencyPenalty,
			LogitBias:           req.LogitBias,
			LogProbs:            req.LogProbs,
			TopLogProbs:         req.TopLogProbs,
			User:                req.User,
			Functions:           req.Functions,
			FunctionCall:        req.FunctionCall,
			Tools:               req.Tools,
			ToolChoice:          req.ToolChoice,
			StreamOptions:       req.StreamOptions,
			ParallelToolCalls:   req.ParallelToolCalls,
			Store:               req.Store,
			Metadata:            req.Metadata,
		},
		Prediction:      req.Prediction,
		ReasoningEffort: reasoningEffort,
	}
}

type ExtendedChatCompletionStreamChoiceDelta struct {
	Content      string               `json:"content,omitempty"`
	Reasoning    string               `json:"reasoning,omitempty"`
	Role         string               `json:"role,omitempty"`
	FunctionCall *openai.FunctionCall `json:"function_call,omitempty"`
	ToolCalls    []openai.ToolCall    `json:"tool_calls,omitempty"`
	Refusal      string               `json:"refusal,omitempty"`
}

type ExtendedChatCompletionStreamChoice struct {
	Index                int                                        `json:"index"`
	Delta                ExtendedChatCompletionStreamChoiceDelta    `json:"delta"`
	Logprobs             *openai.ChatCompletionStreamChoiceLogprobs `json:"logprobs,omitempty"`
	FinishReason         openai.FinishReason                        `json:"finish_reason"`
	ContentFilterResults openai.ContentFilterResults                `json:"content_filter_results,omitempty"`
}

type ExtendedChatCompletionStreamError struct {
	Message  string `json:"message"`
	Code     int    `json:"code"`
	Metadata struct {
		Headers      map[string]string `json:"headers,omitempty"`
		ProviderName string            `json:"provider_name,omitempty"`
	} `json:"metadata,omitempty"`
	UserId string `json:"user_id,omitempty"`
}
type ExtendedChatCompletionStreamResponse struct {
	ID                  string                               `json:"id"`
	Object              string                               `json:"object"`
	Created             int64                                `json:"created"`
	Model               string                               `json:"model"`
	Choices             []ExtendedChatCompletionStreamChoice `json:"choices"`
	SystemFingerprint   string                               `json:"system_fingerprint"`
	PromptAnnotations   []openai.PromptAnnotation            `json:"prompt_annotations,omitempty"`
	PromptFilterResults []openai.PromptFilterResult          `json:"prompt_filter_results,omitempty"`
	// An optional field that will only be present when you set stream_options: {"include_usage": true} in your request.
	// When present, it contains a null value except for the last chunk which contains the token usage statistics
	// for the entire request.
	Usage *openai.Usage                      `json:"usage,omitempty"`
	Error *ExtendedChatCompletionStreamError `json:"error,omitempty"`
}

// ModelResponse holds both the accumulated content and final usage information from a streaming completion request
type ModelResponse struct {
	Content      string        `json:"content"`
	Usage        *openai.Usage `json:"usage,omitempty"`
	Stopped      bool          `json:"stopped,omitempty"`
	Error        string        `json:"error,omitempty"`
	GenerationId string        `json:"generation_id,omitempty"`
	FirstTokenAt time.Time     `json:"first_token_at,omitempty"`
}

// StreamCompletionAccumulator accumulates content and tracks usage from streaming chunks
type StreamCompletionAccumulator struct {
	content      strings.Builder
	usage        *openai.Usage
	generationId string
	firstTokenAt time.Time
}

// NewStreamCompletionAccumulator creates a new StreamCompletionAccumulator
func NewStreamCompletionAccumulator() *StreamCompletionAccumulator {
	return &StreamCompletionAccumulator{
		content: strings.Builder{},
		usage:   nil,
	}
}

// AddContent appends new content from a streaming chunk
func (a *StreamCompletionAccumulator) AddContent(content string) {
	a.content.WriteString(content)
}

// SetUsage sets the usage information, typically from the final chunk
func (a *StreamCompletionAccumulator) SetUsage(usage *openai.Usage) {
	a.usage = usage
}

func (a *StreamCompletionAccumulator) SetGenerationId(generationId string) {
	a.generationId = generationId
}

func (a *StreamCompletionAccumulator) SetFirstTokenAt(firstTokenAt time.Time) {
	a.firstTokenAt = firstTokenAt
}

func (a *StreamCompletionAccumulator) Content() string {
	return a.content.String()
}

// Result creates a StreamCompletionResult from the accumulated content and usage
func (a *StreamCompletionAccumulator) Result(stopped bool, err error) *ModelResponse {
	errStr := ""
	if err != nil {
		errStr = err.Error()
	}

	return &ModelResponse{
		Content:      a.content.String(),
		Usage:        a.usage,
		Stopped:      stopped,
		Error:        errStr,
		GenerationId: a.generationId,
		FirstTokenAt: a.firstTokenAt,
	}
}


================================================
FILE: app/server/types/model.go
================================================
package types

import (
	shared "plandex-shared"
)

type ChangesWithLineNums struct {
	Comments []struct {
		Txt       string `json:"txt"`
		Reference bool   `json:"reference"`
	}
	Changes []*shared.StreamedChangeWithLineNums `json:"changes"`
}


================================================
FILE: app/server/types/reply.go
================================================
package types

import (
	"log"
	"os"
	"regexp"
	"strconv"
	"strings"

	shared "plandex-shared"
)

const verboseLogging = false

type ReplyParserRes struct {
	MaybeFilePath   string
	CurrentFilePath string
	IsInMoveBlock   bool
	IsInRemoveBlock bool
	IsInResetBlock  bool
	Operations      []*shared.Operation
	TotalTokens     int
}

type ReplyParser struct {
	lines                     []string
	currentFileLines          []string
	lineIndex                 int
	maybeFilePath             string
	currentFilePath           string
	currentDescriptionLines   []string
	currentDescriptionLineIdx int
	numTokens                 int
	operations                []*shared.Operation
	currentFileOperation      *shared.Operation
	pendingOperations         []*shared.Operation
	pendingPaths              map[string]bool
	isInMoveBlock             bool
	isInRemoveBlock           bool
	isInResetBlock            bool
}

func NewReplyParser() *ReplyParser {
	info := &ReplyParser{
		lines:                   []string{""},
		currentFileLines:        []string{},
		currentDescriptionLines: []string{""},
		operations:              []*shared.Operation{},
		pendingPaths:            map[string]bool{},
	}
	return info
}

func (r *ReplyParser) AddChunk(chunk string, addToTotal bool) {
	if verboseLogging {
		log.Println("Adding chunk:", strconv.Quote(chunk)) // Logging the chunk that's being processed
	}

	hasNewLine := false
	nextChunk := ""

	if addToTotal {
		r.numTokens++
		// log.Println("Total tokens:", r.numTokens)
		// log.Println("Tokens by file path:", r.numTokensByFile)
	}

	if r.currentFilePath != "" && r.currentFileOperation != nil {
		r.currentFileOperation.NumTokens++
	}

	if chunk == "\n" {
		if verboseLogging {
			log.Println("Chunk is \\n, adding new line")
		}
		r.lines = append(r.lines, "")
		hasNewLine = true
		r.lineIndex++

		if r.currentFileOperation == nil {
			if verboseLogging {
				log.Println("Current file operation is empty--adding new description line...")
			}
			r.currentDescriptionLines = append(r.currentDescriptionLines, "")
			r.currentDescriptionLineIdx++
		}

	} else {
		chunkLines := strings.Split(chunk, "\n")

		if verboseLogging {
			log.Println("Chunk lines:", len(chunkLines))
		}

		currentLine := r.lines[r.lineIndex]
		currentLine += chunkLines[0]
		if verboseLogging {
			log.Println("Current line:", strconv.Quote(currentLine))
		}
		r.lines[r.lineIndex] = currentLine

		if r.currentFileOperation == nil {
			if verboseLogging {
				log.Println("Current file operation is empty--adding to current description...")
				log.Println("Current description lines:", r.currentDescriptionLines)
				log.Printf("Current description line index: %d\n", r.currentDescriptionLineIdx)
			}

			currentDescLine := r.currentDescriptionLines[r.currentDescriptionLineIdx]
			currentDescLine += chunkLines[0]
			r.currentDescriptionLines[r.currentDescriptionLineIdx] = currentDescLine
		}

		if len(chunkLines) > 1 {
			r.lines = append(r.lines, chunkLines[1])
			r.lineIndex++

			if r.currentFileOperation == nil {
				if verboseLogging {
					log.Println("Current file operation is empty--adding to current description...")
					log.Println("Current description lines:", r.currentDescriptionLines)
					log.Printf("Current description line index: %d\n", r.currentDescriptionLineIdx)
				}

				r.currentDescriptionLines = append(r.currentDescriptionLines, chunkLines[1])
				r.currentDescriptionLineIdx++
			}

			hasNewLine = true

			if len(chunkLines) > 2 {
				tail := chunkLines[2:]
				nextChunk = "\n" + strings.Join(tail, "\n")
				defer func() {
					if verboseLogging {
						log.Println("Recursive add next queued chunk:", strconv.Quote(nextChunk))
					}
					r.AddChunk(nextChunk, false)
				}()
			}
		}
	}

	if r.lineIndex == 0 || !hasNewLine {
		if verboseLogging {
			log.Println("No new line detected--returning")
		}
		return
	}

	prevFullLine := r.lines[r.lineIndex-1]
	if verboseLogging {
		log.Println("Previous full line:", strconv.Quote(prevFullLine)) // Logging the full line that's being checked
	}

	prevFullLineTrimmed := strings.TrimSpace(prevFullLine)

	setCurrentFile := func(path string, noLabel bool) {
		r.currentFilePath = path
		r.currentFileOperation = &shared.Operation{
			Type: shared.OperationTypeFile,
			Path: path,
		}
		r.maybeFilePath = ""
		r.currentFileLines = []string{}

		var fileDescription string
		skipNumLines := 4
		if noLabel {
			skipNumLines = 2
		}
		if len(r.currentDescriptionLines) > skipNumLines {
			fileDescription = strings.TrimSpace(strings.Join(r.currentDescriptionLines[0:len(r.currentDescriptionLines)-skipNumLines], "\n"))
			if verboseLogging {
				log.Println("File description:", fileDescription)
			}
			if fileDescription != "" {
				r.currentFileOperation.Description = fileDescription
			}
		} else {
			r.currentFileOperation.Description = ""
		}

		r.currentDescriptionLines = []string{""}
		r.currentDescriptionLineIdx = 0

		if verboseLogging {
			log.Println("Confirmed file path:", r.currentFilePath) // Logging the confirmed file path
		}

	}

	if r.maybeFilePath != "" && !r.isInMoveBlock && !r.isInRemoveBlock && !r.isInResetBlock {
		if verboseLogging {
			log.Println("Maybe file path is:", r.maybeFilePath) // Logging the maybeFilePath
		}
		if strings.HasPrefix(prevFullLineTrimmed, "<PlandexBlock") {
			if verboseLogging {
				log.Println("Found opening tag--confirming file path...") // Logging the confirmed file path
			}

			setCurrentFile(r.maybeFilePath, false)
			return
		} else if prevFullLineTrimmed != "" {
			// turns out previous maybeFilePath was not a file path since there's a non-empty line before finding opening ticks

			if verboseLogging {
				log.Println("Previous maybeFilePath was not a file path--resetting maybeFilePath")
			}

			r.maybeFilePath = ""
		}
	}

	if r.currentFilePath == "" && !r.isInMoveBlock && !r.isInRemoveBlock && !r.isInResetBlock {
		if verboseLogging {
			log.Println("Current file path is empty--checking for possible file path...")
		}

		if LineHasXmlPath(prevFullLineTrimmed) {
			if verboseLogging {
				log.Println("Line has XML-style PlandexBlock tag")
			}
			path := extractFilePath(prevFullLineTrimmed)
			if path != "" {
				setCurrentFile(path, true)
			}
		}

		var gotPath string
		if LineMaybeHasFilePath(prevFullLineTrimmed) {
			gotPath = extractFilePath(prevFullLineTrimmed)
		} else if prevFullLineTrimmed == "### Move Files" {
			if verboseLogging {
				log.Println("Found move block")
			}
			r.isInMoveBlock = true
		} else if prevFullLineTrimmed == "### Remove Files" {
			if verboseLogging {
				log.Println("Found remove block")
			}
			r.isInRemoveBlock = true
		} else if prevFullLineTrimmed == "### Reset Changes" {
			if verboseLogging {
				log.Println("Found reset block")
			}
			r.isInResetBlock = true
		}

		if gotPath != "" {
			if verboseLogging {
				log.Println("Detected possible file path:", gotPath) // Logging the possible file path
			}
			r.maybeFilePath = gotPath
		}
	} else if r.currentFilePath != "" {
		if verboseLogging {
			log.Println("Current file path is not empty--adding to current file...")
		}
		if prevFullLineTrimmed == "</PlandexBlock>" {
			if verboseLogging {
				log.Println("Found closing tag--adding file to files and resetting current file...")
			}
			r.operations = append(r.operations, r.currentFileOperation)
			r.currentFilePath = ""
			r.currentFileOperation = nil

		} else {
			if verboseLogging {
				log.Println("Adding tokens to current file...") // Logging token addition
			}

			r.currentFileOperation.Content += prevFullLine + "\n"
			r.currentFileLines = append(r.currentFileLines, prevFullLine)

		}
	} else if r.isInMoveBlock || r.isInRemoveBlock || r.isInResetBlock {
		if verboseLogging {
			log.Println("In move, remove, or reset block")
		}
		if prevFullLineTrimmed == "<EndPlandexFileOps/>" {
			if verboseLogging {
				log.Println("Found closing tag--adding operations to operations and resetting pending operations...")
			}
			r.isInMoveBlock = false
			r.isInRemoveBlock = false
			r.isInResetBlock = false
			r.operations = append(r.operations, r.pendingOperations...)
			r.pendingOperations = []*shared.Operation{}
			r.pendingPaths = map[string]bool{}
		} else if r.isInMoveBlock {
			op := extractMoveFile(prevFullLineTrimmed)
			if op != nil && !r.pendingPaths[op.Path] {
				if verboseLogging {
					log.Println("Found move operation")
				}
				r.pendingOperations = append(r.pendingOperations, op)
				r.pendingPaths[op.Path] = true
			}
		} else if r.isInRemoveBlock {
			op := extractRemoveOrResetFile(shared.OperationTypeRemove, prevFullLineTrimmed)
			if op != nil && !r.pendingPaths[op.Path] {
				if verboseLogging {
					log.Println("Found remove operation")
				}
				r.pendingOperations = append(r.pendingOperations, op)
				r.pendingPaths[op.Path] = true
			}
		} else if r.isInResetBlock {
			op := extractRemoveOrResetFile(shared.OperationTypeReset, prevFullLineTrimmed)
			if op != nil && !r.pendingPaths[op.Path] {
				if verboseLogging {
					log.Println("Found reset operation")
				}
				r.pendingOperations = append(r.pendingOperations, op)
				r.pendingPaths[op.Path] = true
			}
		}
	}
}

func (r *ReplyParser) Read() ReplyParserRes {
	return ReplyParserRes{
		MaybeFilePath:   r.maybeFilePath,
		CurrentFilePath: r.currentFilePath,
		Operations:      r.operations,
		IsInMoveBlock:   r.isInMoveBlock,
		IsInRemoveBlock: r.isInRemoveBlock,
		IsInResetBlock:  r.isInResetBlock,
		TotalTokens:     r.numTokens,
	}
}

func (r *ReplyParser) FinishAndRead() ReplyParserRes {
	r.AddChunk("\n", false)
	return r.Read()
}

func (r *ReplyParser) GetReplyBeforeCurrentPath() string {
	return r.GetReplyBeforePath(r.currentFilePath)
}

func (r *ReplyParser) GetReplyBeforePath(path string) string {
	if path == "" {
		return strings.Join(r.lines, "\n")
	}

	var idx int
	for i := len(r.lines) - 1; i >= 0; i-- {
		line := r.lines[i]
		if LineMaybeHasFilePath(line) && path == extractFilePath(line) {
			idx = i
			break
		}
	}

	return strings.Join(r.lines[:idx], "\n")
}

func (r *ReplyParser) GetReplyForMissingFile() string {
	path := r.currentFilePath

	var idx int
	for i := len(r.lines) - 1; i >= 0; i-- {
		line := r.lines[i]
		if LineMaybeHasFilePath(line) && path == extractFilePath(line) {
			idx = i
			break
		}
	}

	if idx == -1 {
		return strings.Join(r.lines, "\n")
	}

	idx = idx + 2

	if idx > len(r.lines)-1 {
		return strings.Join(r.lines, "\n")
	}

	return strings.Join(r.lines[:idx], "\n") + "\n"
}

func (r *ReplyParserRes) FileOperationBlockOpen() bool {
	return r.IsInMoveBlock || r.IsInRemoveBlock || r.IsInResetBlock
}

func LineHasXmlPath(line string) bool {
	return strings.HasPrefix(line, "<PlandexBlock") && strings.Contains(line, `path="`)
}

func LineMaybeHasFilePath(line string) bool {
	couldBe := (strings.HasPrefix(line, "-")) || strings.HasPrefix(line, "-file:") || strings.HasPrefix(line, "- file:") || (strings.HasPrefix(line, "**") && strings.HasSuffix(line, "**")) || (strings.HasPrefix(line, "#") && strings.HasSuffix(line, ":"))

	if couldBe {
		extracted := extractFilePath(line)

		extSplit := strings.Split(extracted, ".")
		hasExt := len(extSplit) > 1 && !strings.Contains(extSplit[len(extSplit)-1], " ")
		hasFileSep := strings.Contains(extracted, string(os.PathSeparator))
		hasSpaces := strings.Contains(extracted, " ")

		return !(!hasExt && !hasFileSep && hasSpaces)
	}

	return couldBe
}

var re = regexp.MustCompile(`path="([^"]+)"`)

func extractFilePath(line string) string {
	// Handle XML-style PlandexBlock tag
	if strings.HasPrefix(line, "<PlandexBlock") {
		match := re.FindStringSubmatch(line)
		if len(match) > 1 {
			return match[1]
		}
		return ""
	}

	p := strings.ReplaceAll(line, "**", "")
	p = strings.ReplaceAll(p, "`", "")
	p = strings.ReplaceAll(p, "'", "")
	p = strings.ReplaceAll(p, `"`, "")
	p = strings.TrimPrefix(p, "-")
	p = strings.TrimPrefix(p, "####")
	p = strings.TrimPrefix(p, "###")
	p = strings.TrimPrefix(p, "##")
	p = strings.TrimPrefix(p, "#")
	p = strings.TrimSpace(p)
	p = strings.TrimPrefix(p, "file:")
	p = strings.TrimPrefix(p, "file path:")
	p = strings.TrimPrefix(p, "filepath:")
	p = strings.TrimPrefix(p, "File path:")
	p = strings.TrimPrefix(p, "File Path:")
	p = strings.TrimSuffix(p, ":")
	p = strings.TrimSpace(p)

	// split := strings.Split(p, " ")
	// if len(split) > 1 {
	// 	p = split[0]
	// }

	split := strings.Split(p, ": ")
	if len(split) > 1 {
		p = split[len(split)-1]
	}

	split = strings.Split(p, " (")
	if len(split) > 1 {
		p = split[0]
	}

	return p
}

func extractMoveFile(line string) *shared.Operation {
	line = strings.TrimSpace(line)
	if !strings.HasPrefix(line, "-") {
		return nil
	}

	// Remove the leading dash and trim
	line = strings.TrimPrefix(line, "-")
	line = strings.TrimSpace(line)

	parts := strings.Split(line, "→")
	if len(parts) != 2 {
		return nil
	}

	src := strings.TrimSpace(parts[0])
	dst := strings.TrimSpace(parts[1])

	// Remove backticks
	src = strings.Trim(src, "`")
	dst = strings.Trim(dst, "`")

	return &shared.Operation{
		Type:        shared.OperationTypeMove,
		Path:        src,
		Destination: dst,
	}
}

func extractRemoveOrResetFile(opType shared.OperationType, line string) *shared.Operation {
	line = strings.TrimSpace(line)
	if !strings.HasPrefix(line, "-") {
		return nil
	}

	// Remove the leading dash and trim
	line = strings.TrimPrefix(line, "-")
	line = strings.TrimSpace(line)

	path := strings.Trim(line, "`")

	return &shared.Operation{
		Type: opType,
		Path: path,
	}
}


================================================
FILE: app/server/types/reply_test.go
================================================
package types

import (
	"fmt"
	"os"
	"strconv"
	"testing"

	shared "plandex-shared"
)

type TestExample struct {
	Only       bool
	Operations []shared.Operation
}

// These aren't the real number of tokens
// We're just splitting the file into chunks of 5 characters to simulate tokens
var examples = []TestExample{
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/apply.go",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/checkout.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/context_rm.go",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/context_update.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/context_rm.go",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "cmd/context_update.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "server/types/section.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "shared/types.go",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "cli/lib/conversation.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "server/model/proposal/create.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "file_map/map.go",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "Makefile",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "_apply.sh",
			},
		},
	},
	{
		Operations: []shared.Operation{
			{
				Type:        shared.OperationTypeMove,
				Path:        "src/game.c",
				Destination: "src/game/game.c",
			},
			{
				Type:        shared.OperationTypeMove,
				Path:        "src/game.h",
				Destination: "src/game/game.h",
			},
			{
				Type: shared.OperationTypeRemove,
				Path: "src/README.md",
			},
			{
				Type: shared.OperationTypeReset,
				Path: "Makefile",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "Makefile",
			},
		},
	},
	{
		Only: true,
		Operations: []shared.Operation{
			{
				Type: shared.OperationTypeFile,
				Path: "server/model/prompts/describe.go",
			},
			{
				Type: shared.OperationTypeFile,
				Path: "server/model/plan/commit_msg.go",
				Description: `Now let's update the commit message handling in commit_msg.go:

**Updating ` + "`server/model/plan/commit_msg.go`" + `:** I'll update the genPlanDescription method to handle XML output instead of JSON.`,
			},
		},
	},
}

func TestReplyParser(t *testing.T) {
	only := map[int]bool{}
	for i, example := range examples {
		if example.Only {
			only[i] = true
		}
	}

	for i, example := range examples {

		if len(only) > 0 && !only[i] {
			continue
		}

		t.Run(fmt.Sprintf("Example_%d", i+1), func(t *testing.T) {
			filePath := fmt.Sprintf("reply_test_examples/%d.md", i+1)
			fmt.Println(filePath)

			bytes, err := os.ReadFile(filePath)
			if err != nil {
				t.Error(err)
			}

			content := string(bytes)
			tokenSize := 5

			parser := NewReplyParser()

			for i := 0; i < len(content); {
				end := i + tokenSize
				if end > len(content) {
					end = len(content)
				}
				chunk := content[i:end]
				parser.AddChunk(chunk, true)
				i = end
			}

			res := parser.FinishAndRead()

			operations := res.Operations

			if len(operations) != len(example.Operations) {
				t.Errorf("Example %d: Expected %d operations, got %d",
					i+1, len(example.Operations), len(operations))
			}

			for j, operation := range operations {
				if operation.Name() != example.Operations[j].Name() {
					t.Errorf("Example %d: Expected operation %s, got %s",
						i+1, example.Operations[j].Name(), operation.Name())
				}

				if example.Operations[j].Description != "" {
					if operation.Description != example.Operations[j].Description {
						t.Errorf("Example %d: Expected description %s, got %s",
							i+1, strconv.Quote(example.Operations[j].Description), strconv.Quote(operation.Description))
					}
				}
			}

		})
	}
}


================================================
FILE: app/server/types/reply_test_examples/1.md
================================================
Thank you for the update. In order to handle errors from the apply command execution, we need to modify the 'checkout' command and the 'apply' command and function.

Follow the steps below:

1. Modify the 'apply' function to return an error.
2. Change 'apply' command invocation in 'checkout' function to handle the returned error.

The code changes are as follows:

- file: cmd/apply.go

<PlandexBlock lang="go" path="cmd/apply.go">
package cmd

// ... other imports ...

func init() {
	RootCmd.AddCommand(applyCmd)
}

var applyCmd = &cobra.Command{
	Use:   "apply [name]",
	Short: "Apply a plan to the project",
	Args:  cobra.MaximumNArgs(1),
	RunE:  apply,   // We use RunE instead of Run, to allow us to return an error from the apply function
}

func apply(cmd *cobra.Command, args []string) error {

	// ... rest of the code ...

	if err != nil {
		// Return error to the caller instead of directly logging it
		return fmt.Errorf("Error processing files: %v", err)
	}

	// ... rest of the code ...

	if err != nil {
		// Return error to the caller instead of directly logging it
		return fmt.Errorf("Error executing plan: %v", err)
	}

	if copiedAny || didExec {
		fmt.Println("Plan applied successfully!")
	} else {
		return fmt.Errorf("This plan has no changes to apply.")
	}

	return nil
}

// ... rest of the code ...
</PlandexBlock>

- file: cmd/checkout.go

<PlandexBlock lang="go" path="cmd/checkout.go">
package cmd

// ... other imports ...

func checkout(cmd *cobra.Command, args []string) {

	// ... rest of the code ...

	err = apply(cmd, args)

	if err != nil {
		fmt.Fprintln(os.Stderr, "Error committing plan: ", err)
		return
	}

	// ... rest of the code ...
}
</PlandexBlock>

Next, compile and run your application to verify that any error from the 'apply' command would be gracefully handled by the 'checkout' command. Changes have been made in such a way that 'apply' command can still work standalone, besides working in sync with 'checkout' command.


================================================
FILE: app/server/types/reply_test_examples/10.md
================================================
I'll work on the current subtask "Update commit message prompts and handling". This involves updating both the prompt in describe.go and the handling in commit_msg.go to use XML instead of JSON.

First, let's update the prompt in describe.go:

**Updating `server/model/prompts/describe.go`:** I'll replace the function definition and update the system prompt to use XML output instead of JSON.

<PlandexBlock lang="go" path="server/model/prompts/describe.go">
package prompts

import (
	"fmt"

	"plandex-shared"
)

const SysDescribe = `You are an AI parser. You turn an AI's plan for a programming task into a structured description. You must output a commit message for the changes proposed using XML tags.

Output your response using a <commitMsg> tag. Do not use any XML attributes, just the tag content.

Example:
<commitMsg>Add user authentication system with JWT support</commitMsg>

You must ALWAYS output a commit message using the XML format shown above. The commit message should be good and succinct.`

var SysDescribeNumTokens int

const SysPendingResults = "You are an AI commit message summarizer. You take a list of descriptions of pending changes and turn them into a succinct one-line summary of all the pending changes that makes for a good commit message title. Output ONLY this one-line title and nothing else."

var SysPendingResultsNumTokens int

func init() {
	var err error
	SysDescribeNumTokens, err = shared.GetNumTokensEstimate(SysDescribe)

	if err != nil {
		panic(fmt.Sprintf("Error getting num tokens for describe plan prompt: %v\n", err))
	}

	SysPendingResultsNumTokens, err = shared.GetNumTokensEstimate(SysPendingResults)

	if err != nil {
		panic(fmt.Sprintf("Error getting num tokens for pending results prompt: %v\n", err))
	}
}
</PlandexBlock>

Now let's update the commit message handling in commit_msg.go:

**Updating `server/model/plan/commit_msg.go`:** I'll update the genPlanDescription method to handle XML output instead of JSON.

<PlandexBlock lang="go" path="server/model/plan/commit_msg.go">
// ... existing code ...

func (state *activeTellStreamState) genPlanDescription() (*db.ConvoMessageDescription, error) {
	auth := state.auth
	plan := state.plan
	planId := plan.Id
	branch := state.branch
	settings := state.settings
	clients := state.clients
	config := settings.ModelPack.CommitMsg
	envVar := config.BaseModelConfig.ApiKeyEnvVar
	client := clients[envVar]

	activePlan := GetActivePlan(planId, branch)
	if activePlan == nil {
		return nil, fmt.Errorf("active plan not found")
	}

	numTokens := prompts.ExtraTokensPerRequest + (prompts.ExtraTokensPerMessage * 2) + prompts.SysDescribeNumTokens + activePlan.NumTokens

	_, apiErr := hooks.ExecHook(hooks.WillSendModelRequest, hooks.HookParams{
		Auth: auth,
		Plan: plan,
		WillSendModelRequestParams: &hooks.WillSendModelRequestParams{
			InputTokens:  numTokens,
			OutputTokens: config.BaseModelConfig.MaxOutputTokens,
			ModelName:    config.BaseModelConfig.ModelName,
		},
	})
	if apiErr != nil {
		return nil, errors.New(apiErr.Msg)
	}

	log.Println("Sending plan description model request")

	descResp, err := model.CreateChatCompletionWithRetries(
		client,
		activePlan.Ctx,
		openai.ChatCompletionRequest{
			Model: config.BaseModelConfig.ModelName,
			Messages: []openai.ChatCompletionMessage{
				{
					Role:    openai.ChatMessageRoleSystem,
					Content: prompts.SysDescribe,
				},
				{
					Role:    openai.ChatMessageRoleAssistant,
					Content: activePlan.CurrentReplyContent,
				},
			},
			Temperature: config.Temperature,
			TopP:        config.TopP,
		},
	)

	if err != nil {
		fmt.Printf("Error during plan description model call: %v\n", err)
		return nil, err
	}

	log.Println("Plan description model call complete")

	if len(descResp.Choices) == 0 {
		return nil, fmt.Errorf("No choices in model response")
	}

	content := descResp.Choices[0].Message.Content
	commitMsg := GetXMLContent(content, "commitMsg")

	if commitMsg == "" {
		return nil, fmt.Errorf("No commit message found in response")
	}

	var inputTokens int
	var outputTokens int
	if descResp.Usage.CompletionTokens > 0 {
		inputTokens = descResp.Usage.PromptTokens
		outputTokens = descResp.Usage.CompletionTokens
	} else {
		inputTokens = numTokens
		outputTokens, err = shared.GetNumTokensEstimate(content)

		if err != nil {
			return nil, fmt.Errorf("error getting num tokens for content: %v", err)
		}
	}

	log.Println("Sending DidSendModelRequest hook")

	_, apiErr = hooks.ExecHook(hooks.DidSendModelRequest, hooks.HookParams{
		Auth: auth,
		Plan: plan,
		DidSendModelRequestParams: &hooks.DidSendModelRequestParams{
			InputTokens:   inputTokens,
			OutputTokens:  outputTokens,
			ModelName:     config.BaseModelConfig.ModelName,
			ModelProvider: config.BaseModelConfig.Provider,
			ModelPackName: settings.ModelPack.Name,
			ModelRole:     shared.ModelRoleCommitMsg,
			Purpose:       "Generated commit message for suggested changes",
		},
	})

	if apiErr != nil {
		return nil, errors.New(apiErr.Msg)
	}

	log.Println("DidSendModelRequest hook complete")

	return &db.ConvoMessageDescription{
		PlanId:    planId,
		CommitMsg: commitMsg,
	}, nil
}

// ... existing code ...
</PlandexBlock>

**Update commit message prompts and handling** has been completed.

================================================
FILE: app/server/types/reply_test_examples/2.md
================================================
Sure, here's how you could structure your 'context rm' command and 'context update' command using placeholders for the 'lib' functions that will handle the actual removal and updating of contexts:

**cmd/context_rm.go**

<PlandexBlock lang="go" path="cmd/context_rm.go">
package cmd

import (
	"fmt"
	"log"

	"github.com/spf13/cobra"
)

// contextRmCmd represents the delete command
var contextRmCmd = &cobra.Command{
	Use:     "rm [context_name]",
	Aliases: []string{"delete"},
	Short:   "",
	Long:    ``,
	Run:     contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	all, err := cmd.Flags().GetBool("all")

	if err != nil {
		log.Fatal("Error parsing all flag: ", err)
	}

	if all {
	    	// Placeholder for lib function
		err = lib.RemoveAllContexts()
		if err != nil {
			log.Fatal("Error removing all contexts: ", err)
		}
	} else if len(args) > 0 {
		for _, contextName := range args {
	    		// Placeholder for lib function
			err = lib.RemoveContext(contextName)
			if err != nil {
				fmt.Printf("Error removing context '%s': %v\n", contextName, err)
			}
		}
	} else {
		fmt.Println("Please provide a context name or use the --all flag to remove all contexts.")
	}
}

func init() {
	contextCmd.AddCommand(contextRmCmd)
	contextRmCmd.Flags().BoolP("all", "a", false, "remove all contexts")
}
</PlandexBlock>

**cmd/context_update.go**

<PlandexBlock lang="go" path="cmd/context_update.go">
package cmd

import (
	"fmt"
	"log"

	"github.com/spf13/cobra"
)

// contextUpdateCmd represents the context command
var contextUpdateCmd = &cobra.Command{
	Use:   "update [file-or-urls...]",
	Short: "A brief description of your command",
	Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			fmt.Println("Please provide one or more files or URLs to update.")
			return
		}

		for _, arg := range args {
	    		// Placeholder for lib function
			err := lib.UpdateContext(arg)
			if err != nil {
				fmt.Printf("Error updating context for '%s': %v\n", arg, err)
			}
		}
	},
}

func init() {
	contextCmd.AddCommand(contextUpdateCmd)
}
</PlandexBlock>

In your next iteration, you could implement the functions in 'lib' package such as `RemoveAllContexts`, `RemoveContext`, and `UpdateContext`.


================================================
FILE: app/server/types/reply_test_examples/3.md
================================================
Sure, here's how you could structure your 'context rm' command and 'context update' command using placeholders for the 'lib' functions that will handle the actual removal and updating of contexts:

**cmd/context_rm.go**

<PlandexBlock lang="go" path="cmd/context_rm.go">
package cmd

import (
	"fmt"
	"log"

	"github.com/spf13/cobra"
)

// contextRmCmd represents the delete command
var contextRmCmd = &cobra.Command{
	Use:     "rm [context_name]",
	Aliases: []string{"delete"},
	Short:   "",
	Long:    ``,
	Run:     contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	all, err := cmd.Flags().GetBool("all")

	if err != nil {
		log.Fatal("Error parsing all flag: ", err)
	}

	if all {
	    	// Placeholder for lib function
		err = lib.RemoveAllContexts()
		if err != nil {
			log.Fatal("Error removing all contexts: ", err)
		}
	} else if len(args) > 0 {
		for _, contextName := range args {
	    		// Placeholder for lib function
			err = lib.RemoveContext(contextName)
			if err != nil {
				fmt.Printf("Error removing context '%s': %v\n", contextName, err)
			}
		}
	} else {
		fmt.Println("Please provide a context name or use the --all flag to remove all contexts.")
	}
}

func init() {
	contextCmd.AddCommand(contextRmCmd)
	contextRmCmd.Flags().BoolP("all", "a", false, "remove all contexts")
}
</PlandexBlock>

**cmd/context_update.go**

<PlandexBlock lang="go" path="cmd/context_update.go">
package cmd

import (
	"fmt"
	"log"

	"github.com/spf13/cobra"
)

// contextUpdateCmd represents the context command
var contextUpdateCmd = &cobra.Command{
	Use:   "update [file-or-urls...]",
	Short: "A brief description of your command",
	Long: `A longer description that spans multiple lines and likely contains examples
and usage of using your command. For example:

Cobra is a CLI library for Go that empowers applications.
This application is a tool to generate the needed files
to quickly create a Cobra application.`,
	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			fmt.Println("Please provide one or more files or URLs to update.")
			return
		}

		for _, arg := range args {
	    		// Placeholder for lib function
			err := lib.UpdateContext(arg)
			if err != nil {
				fmt.Printf("Error updating context for '%s': %v\n", arg, err)
			}
		}
	},
}

func init() {
	contextCmd.AddCommand(contextUpdateCmd)
}
</PlandexBlock>

In your next iteration, you could implement the functions in 'lib' package such as `RemoveAllContexts`, `RemoveContext`, and `UpdateContext`.


================================================
FILE: app/server/types/reply_test_examples/4.md
================================================
Yes, it does. Let's start by defining the types for `Section` and `SectionizeResponse`. For the Section type, we would need `name`, `content`, and an optional `subSections` field (to store any potentially nested sections).

Here is the structure we can follow:

1. A `Section` struct which contains a `Name` for the section, `Content` of the section, and a slice of `Subsection` for possible subsections in that section.
2. A `SectionizeResponse` struct which contains a slice of `Section`.

In `server/types/` directory, create a new `section.go` file.

- server/types/section.go

<PlandexBlock lang="go" path="types/section.go">
package types

type Section struct {
	Name       string
	Content    string
	Subsection []Section
}

type SectionizeResponse struct {
	Sections []Section
}
</PlandexBlock>

Once you have checked and confirmed this task, I will proceed to the next task which is creating a sectionize function in the server model.


================================================
FILE: app/server/types/reply_test_examples/5.md
================================================
Given that a summarization utility exists, the plan can be further simplified to utilize that. Here is the updated plan:

1. Update the shared/types.go file to introduce a new boolean field indicating if a message has been summarized.

   - shared/types.go:

   <PlandexBlock lang="go">
   type ChatCompletionMessage struct {
   	// existing fields
   	...
   	Summarized bool
   }
   </PlandexBlock>

2. Modify the loadConversation function in cli/lib/conversation.go to take advantage of this new field.

   - cli/lib/conversation.go:
     <PlandexBlock lang="go">
     // modified part of loadConversation
     ...
     	messages = append(messages, openai.ChatCompletionMessage{
     		Role:       currentRole,
     		Content:    loadContent(filePath, currentRole),
     		Summarized: checkIfMsgSummarized(filePath, currentRole)
     	})
     ...
     </PlandexBlock>
   - Add the helper functions, checkIfMsgSummarized to check if a given message has already been summarized.

3. In the server/model/proposal/create.go, handle the token limit error by introducing a summarization step.

   - Before calling the CreateChatCompletionStream, check the number of tokens in the request if they exceed the limit.
   - If they do, find the pairs of conversation and attempt to summarize starting from the second.
   - Use the model.Summarize() function provided by the system in step 2 above to handle this summarization.

4. Lastly, handle the superfluous WriteHeader call.
   - For the superfluous WriteHeader call, ensure that all response modifications (like setting headers) are made before calling WriteHeader() and before writing to the response body.

Note: It's still necessary to track which parts of the conversation have already been summarized and avoid summarizing them again if the token limit is still exceeded. This can be achieved by storing a "summarized" flag in each chat message (ChatCompletionMessage).


================================================
FILE: app/server/types/reply_test_examples/6.md
================================================
In the following implementation for error handling and conversation summarization in `server/model/proposal/create.go`, the changes will help anticipate any token limit errors. After collecting and formatting all the necessary context, we will check if the token number exceeds the permitted limit. If so, we will initialize a process for summarizing conversation pairs.

Changes will include:

- A check for the token limit before calling `CreateChatCompletionStream`
- A mechanism to iterate through conversation pairs for summarization
- Recursive calls of `CreateProposal` with summarized conversation, if necessary

-server/model/proposal/create.go:

<PlandexBlock lang="go">
// Add this at the start of the CreateProposal function
const maxTokens = 8192  // The maximum tokens allowed by the model

...

// After preparation of the main conversation context, we add checks for tokens
tokenNumbers := GetTokenNumber(messages)  // Assuming you have a function for this

if tokenNumbers > maxTokens {

    // Iterate the Conversation pairs
    for i := 1; i < len(req.Conversation)-1; i++ {

        // Check if the assistant's part has been summarized before
        if req.Conversation[i].Role == openai.ChatMessageRoleAssistant && !req.Conversation[i].Summarized {
            // Summarize the conversation, assuming we have a function Summarize() returning summarized text
            summarizedContent := Summarize(req.Conversation[i].Content)
            req.Conversation[i].Content = summarizedContent
            req.Conversation[i].Summarized = true  // Mark the message as summarized
            break
        }
    }
    // Recursive call to CreateProposal after summarizing
    err := CreateProposal(req, onStream)
    if err != nil {
        return fmt.Errorf("Error recreating proposal: %s\n", err)
    }
}

...

// Proceed the rest of the function as usual
</PlandexBlock>

This block of code handles the error arising from exceeding the maximum tokens supported by the model. If the tokens exceeded are detected, we start the process of summarizing conversation pairs till we are within allowed token limits. This is implemented via a recursive call to `CreateProposal`.

Lastly, you should address the "superfluous response.WriteHeader call" error. This issue is usually due to an unnecessary double setting of headers in HTTP responses - HTTP headers should only be written once. The fix would involve a careful review of your HTTP response handling process ensuring that the response's headers aren't set after `WriteHeader()` has been called or body written into.

Please integrate these changes into your respective function to handle the errors as described. Additional iterations might be required to fine-tune and resolve adjacent issues arising from these changes. Please also ensure your token counting and text summarization functions are accurate and performant as they play a crucial role in this error handling process.


================================================
FILE: app/server/types/reply_test_examples/7.md
================================================
**Updating `file_map/map.go`**: I'll add debug logging to the mapMarkup function between the function declaration and the end of the file.

- file_map/map.go:
<PlandexBlock lang="go">
// ... existing code ...

func mapMarkup(node *tree_sitter.Node, content []byte) []Definition {
    if verboseLogging {
        fmt.Println("mapMarkup called with node type:", node.Type())
    }
    
    var defs []Definition
    cursor := tree_sitter.NewTreeCursor(node)
    defer cursor.Close()

    if cursor.GoToFirstChild() {
        if verboseLogging {
            fmt.Println("cursor went to first child")
        }
        
        for {
            node := cursor.CurrentNode()
            if verboseLogging {
                fmt.Println("processing node type:", node.Type())
            }
            
            if node.Type() == "element" {
                if verboseLogging {
                    fmt.Println("found element node")
                }
                
                // Get tag name from start_tag
                if startTag := node.ChildByFieldName("start_tag"); startTag != nil {
                    if verboseLogging {
                        fmt.Println("found start_tag:", startTag.Type())
                    }
                    
                    if nameNode := startTag.ChildByFieldName("name"); nameNode != nil {
                        if verboseLogging {
                            fmt.Printf("found name node: %s with content: %s\n", 
                                nameNode.Type(), string(nameNode.Content(content)))
                        }
                        
                        def := Definition{
                            Type:      "tag",
                            Line:      int(node.StartPoint().Row) + 1,
                            Signature: string(nameNode.Content(content)),
                        }

                        // Get class and id attributes
                        var attrs []string
                        for i := 0; i < int(startTag.ChildCount()); i++ {
                            child := startTag.Child(i)
                            if verboseLogging {
                                fmt.Printf("checking child %d type: %s\n", i, child.Type())
                            }
                            
                            if child.Type() == "attribute" {
                                if verboseLogging {
                                    fmt.Println("found attribute node")
                                }
                                
                                if attrName := child.ChildByFieldName("name"); attrName != nil {
                                    name := string(attrName.Content(content))
                                    if verboseLogging {
                                        fmt.Printf("found attribute name: %s\n", name)
                                    }
                                    
                                    if name == "class" || name == "id" {
                                        if attrValue := child.ChildByFieldName("value"); attrValue != nil {
                                            if verboseLogging {
                                                fmt.Printf("found attribute value: %s\n", 
                                                    string(attrValue.Content(content)))
                                            }
                                            attrs = append(attrs, fmt.Sprintf("%s=%q", 
                                                name, attrValue.Content(content)))
                                        }
                                    }
                                }
                            }
                        }
                        def.TagAttrs = attrs

                        // Recursively process children
                        if verboseLogging {
                            fmt.Println("recursively processing children")
                        }
                        def.Children = mapMarkup(node, content)
                        defs = append(defs, def)
                    } else if verboseLogging {
                        fmt.Println("no name node found")
                    }
                } else if verboseLogging {
                    fmt.Println("no start_tag found")
                }
            }

            if !cursor.GoToNextSibling() {
                if verboseLogging {
                    fmt.Println("no more siblings")
                }
                break
            }
        }
    } else if verboseLogging {
        fmt.Println("cursor could not go to first child")
    }

    if verboseLogging {
        fmt.Printf("returning %d definitions\n", len(defs))
    }
    return defs
}

// ... existing code ...
</PlandexBlock>

================================================
FILE: app/server/types/reply_test_examples/8.md
================================================
**Creating the project structure and Makefile**

First, I'll create a basic project structure with a Makefile that will compile our game.

- Makefile:
<PlandexBlock lang="makefile">
CC = gcc
CFLAGS = -Wall -Wextra -I./include
LDFLAGS = -framework OpenGL -framework GLUT
SRC_DIR = src
OBJ_DIR = obj
BIN_DIR = bin

SRCS = $(wildcard $(SRC_DIR)/*.c)
OBJS = $(SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)
EXECUTABLE = $(BIN_DIR)/pong

.PHONY: all clean directories

all: directories $(EXECUTABLE)

directories:
	@mkdir -p $(OBJ_DIR) $(BIN_DIR)

$(EXECUTABLE): $(OBJS)
	$(CC) $(OBJS) -o $@ $(LDFLAGS)

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -rf $(OBJ_DIR) $(BIN_DIR)
</PlandexBlock>

- _apply.sh:
<PlandexBlock lang="bash">
# Create necessary directories if they don't exist
mkdir -p src include obj bin

# Check if Homebrew is installed
if ! command -v brew &> /dev/null; then
    echo "Homebrew is not installed. Please install Homebrew first."
    exit 1
fi

# Install GLUT if not already installed
if ! brew list | grep -q freeglut; then
    echo "Installing GLUT..."
    brew install freeglut
fi

# Compile the project
make clean && make

# Run the game
./bin/pong
</PlandexBlock>

**Creating the project structure and Makefile** has been completed.

Next, I'll implement the header files for game structures and constants.


================================================
FILE: app/server/types/reply_test_examples/9.md
================================================
I'll move the game-related files to the game directory.

### Move Files

- src/game.c → src/game/game.c
- src/game.h → src/game/game.h

<EndPlandexFileOps/>

Now I'll remove the README.md file as requested.

### Remove Files

- src/README.md

<EndPlandexFileOps/>

Then I'll reset the changes to the Makefile.

### Reset Changes

- Makefile

<EndPlandexFileOps/>

Now I'll write a new Makefile.

- Makefile:

<PlandexBlock lang="bash">
# Create necessary directories if they don't exist
mkdir -p src include obj bin

# Check if Homebrew is installed
if ! command -v brew &> /dev/null; then
    echo "Homebrew is not installed. Please install Homebrew first."
    exit 1
fi
</PlandexBlock>

================================================
FILE: app/server/types/safe_map.go
================================================
package types

import "sync"

type SafeMap[V any] struct {
	items map[string]V
	mu    sync.Mutex
}

func NewSafeMap[V any]() *SafeMap[V] {
	return &SafeMap[V]{items: make(map[string]V)}
}

func (sm *SafeMap[V]) Get(key string) V {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	return sm.items[key]
}

func (sm *SafeMap[V]) Set(key string, value V) {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	sm.items[key] = value
}

func (sm *SafeMap[V]) Delete(key string) {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	delete(sm.items, key)
}

func (sm *SafeMap[V]) Update(key string, fn func(V)) {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	if item, ok := sm.items[key]; ok {
		fn(item)
		sm.items[key] = item
	}
}

func (sm *SafeMap[V]) Items() map[string]V {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	return sm.items
}

func (sm *SafeMap[V]) Keys() []string {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	keys := make([]string, len(sm.items))
	i := 0
	for k := range sm.items {
		keys[i] = k
		i++
	}
	return keys
}

func (sm *SafeMap[V]) Len() int {
	sm.mu.Lock()
	defer sm.mu.Unlock()
	return len(sm.items)
}


================================================
FILE: app/server/types/trial.go
================================================
package types

const TrialMaxReplies = 20
const TrialMaxPlans = 10


================================================
FILE: app/server/utils/whitespace.go
================================================
package utils

import "strings"

func StripAddedBlankLines(orig, upd string) string {
	origLines := strings.Split(orig, "\n")
	updLines := strings.Split(upd, "\n")

	leadingOrig := 0
	for leadingOrig < len(origLines) && strings.TrimSpace(origLines[leadingOrig]) == "" {
		leadingOrig++
	}

	leadingUpd := 0
	for leadingUpd < len(updLines) && strings.TrimSpace(updLines[leadingUpd]) == "" {
		leadingUpd++
	}

	if leadingUpd > leadingOrig {
		updLines = updLines[leadingUpd-leadingOrig:] // trim surplus
	}

	trailingOrig := 0
	for trailingOrig < len(origLines) && strings.TrimSpace(origLines[len(origLines)-1-trailingOrig]) == "" {
		trailingOrig++
	}

	trailingUpd := 0
	for trailingUpd < len(updLines) && strings.TrimSpace(updLines[len(updLines)-1-trailingUpd]) == "" {
		trailingUpd++
	}

	if trailingUpd > trailingOrig {
		updLines = updLines[:len(updLines)-(trailingUpd-trailingOrig)]
	}

	return strings.Join(updLines, "\n")
}


================================================
FILE: app/server/utils/whitespace_test.go
================================================
package utils

import "testing"

func TestStripAddedBlankLines(t *testing.T) {
	tcs := []struct {
		name string
		orig string
		upd  string
		want string
	}{
		{
			name: "no change",
			orig: "a\nb\nc\n",
			upd:  "a\nb\nc\n",
			want: "a\nb\nc\n",
		},
		{
			name: "leading newline added",
			orig: "a\nb\n",
			upd:  "\n\na\nb\n",
			want: "a\nb\n",
		},
		{
			name: "trailing newline added",
			orig: "a\nb\n",
			upd:  "a\nb\n\n",
			want: "a\nb\n",
		},
		{
			name: "both ends, keep original padding",
			orig: "\nfoo\nbar\n\n",
			upd:  "\n\nfoo\nbar\n\n\n",
			want: "\nfoo\nbar\n\n",
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			got := StripAddedBlankLines(tc.orig, tc.upd)
			if got != tc.want {
				t.Fatalf("\norig:\n%q\nupd:\n%q\nwant:\n%q\ngot:\n%q",
					tc.orig, tc.upd, tc.want, got)
			}
		})
	}
}


================================================
FILE: app/server/utils/xml.go
================================================
package utils

import (
	"regexp"
	"strings"
)

func EscapeInvalidXMLAttributeCharacters(xmlString string) string {
	// Regular expression to match content inside double quotes, but not the quotes themselves
	re := regexp.MustCompile(`"([^"]*?)"`)
	return re.ReplaceAllStringFunc(xmlString, func(attrValue string) string {
		// Extract the content inside the quotes (removing the enclosing quotes)
		content := attrValue[1 : len(attrValue)-1]

		// Escape the content inside the quotes
		escaped := strings.ReplaceAll(content, "&", "&amp;")
		escaped = strings.ReplaceAll(escaped, "<", "&lt;")
		escaped = strings.ReplaceAll(escaped, ">", "&gt;")
		escaped = strings.ReplaceAll(escaped, `"`, "&quot;")
		escaped = strings.ReplaceAll(escaped, "'", "&apos;")

		// Re-wrap the escaped content in quotes
		return `"` + escaped + `"`
	})
}

func EscapeCdata(xmlString string) string {
	escaped := strings.ReplaceAll(xmlString, "]]>", "PDX_ESCAPED_CDATA_END")
	return escaped
}

func UnescapeCdata(xmlString string) string {
	escaped := strings.ReplaceAll(xmlString, "PDX_ESCAPED_CDATA_END", "]]>")
	return escaped
}

func StripCdata(xmlString, tagName string) string {
	openTag := "<" + tagName + ">"
	closeTag := "</" + tagName + ">"
	xmlString = regexp.MustCompile(openTag+`\s*<!\[CDATA\[`).ReplaceAllString(xmlString, openTag)
	xmlString = regexp.MustCompile(`]]>\s*`+closeTag).ReplaceAllString(xmlString, closeTag)
	return xmlString
}

func WrapCdata(xmlString, tagName string) string {
	openTag := "<" + tagName + ">"
	closeTag := "</" + tagName + ">"
	xmlString = StripCdata(xmlString, tagName)

	xmlString = strings.ReplaceAll(xmlString, openTag, openTag+"<![CDATA[")
	xmlString = strings.ReplaceAll(xmlString, closeTag, "]]>"+closeTag)

	return xmlString
}

func GetXMLTag(xmlString, tagName string, wrapCdata bool) string {
	openTag := "<" + tagName + ">"
	closeTag := "</" + tagName + ">"

	// Get everything after the last opening tag
	split := strings.Split(xmlString, openTag)
	if len(split) < 2 {
		return ""
	}
	afterOpenTag := split[len(split)-1]

	// Get everything before the first closing tag
	split2 := strings.Split(afterOpenTag, closeTag)
	if len(split2) < 1 {
		return ""
	}

	processedXml := openTag + EscapeInvalidXMLAttributeCharacters(split2[0]) + closeTag

	if wrapCdata {
		processedXml = WrapCdata(processedXml, tagName)
	}

	return processedXml
}

func GetXMLContent(xmlString, tagName string) string {
	openTag := "<" + tagName + ">"
	closeTag := "</" + tagName + ">"

	// Get everything after the last opening tag
	split := strings.Split(xmlString, openTag)
	if len(split) < 2 {
		return ""
	}
	afterOpenTag := split[len(split)-1]

	// Get everything before the first closing tag
	split2 := strings.Split(afterOpenTag, closeTag)
	if len(split2) < 1 {
		return ""
	}

	return split2[0]
}

// GetAllXMLContent returns all occurrences of content between the specified XML tags
// as an array of strings. Returns an empty array if no matches are found.
func GetAllXMLContent(xmlString, tagName string) []string {
	var results []string
	openTag := "<" + tagName + ">"
	closeTag := "</" + tagName + ">"

	// Split by opening tag
	parts := strings.Split(xmlString, openTag)

	// Skip the first part (it's before any opening tag)
	for i := 1; i < len(parts); i++ {
		// Split by closing tag
		subParts := strings.Split(parts[i], closeTag)
		if len(subParts) > 0 {
			// The content is before the first closing tag
			results = append(results, subParts[0])
		}
	}

	return results
}


================================================
FILE: app/server/version.txt
================================================
2.2.1


================================================
FILE: app/shared/ai_models_available.go
================================================
package shared

import (
	"strings"

	"github.com/davecgh/go-spew/spew"
)

/*
'MaxTokens' is the absolute input limit for the provider.

'MaxOutputTokens' is the absolute output limit for the provider.

'ReservedOutputTokens' is how much we set aside in context for the model to use in its output. It's more of a realistic output limit, since for some models, the hard maximum 'MaxTokens' is actually equal to the input limit, which would leave no room for input.

The effective input limit is 'MaxTokens' - 'ReservedOutputTokens'.

For example, OpenAI o3-mini has a MaxTokens of 200k and a MaxOutputTokens of 100k. But in practice, we are very unlikely to use all the output tokens, and we want to leave more space for input. So we set ReservedOutputTokens to 40k, allowing ~25k for reasoning tokens, as well as ~15k for real output tokens, which is enough for most use cases. The new effective input limit is therefore 200k - 40k = 160k. However, these are not passed through as hard limits. So if we have a smaller amount of input (under 100k) the model could still use up to the full 100k output tokens if necessary.

For models with a low output limit, we just set ReservedOutputTokens to the MaxOutputTokens.

When checking for sufficient credits on Plandex Cloud, we use MaxOutputTokens-InputTokens, since this is the maximum that could hypothetically be used.

'DefaultMaxConvoTokens' is the default maximum number of conversation tokens that are allowed before we start using gradual summarization to shorten the conversation.

'ModelName' is the name of the model on the provider's side.

'ModelId' is the identifier for the model on the Plandex side—it must be unique per provider. We have this so that models with the same name and provider, but different settings can be differentiated.

'ModelCompatibility' is used to check for feature support (like image support).

'BaseUrl' is the base URL for the provider.

'PreferredOutputFormat' is the preferred output format for the model—currently either 'ModelOutputFormatToolCallJson' or 'ModelOutputFormatXml' — OpenAI models like JSON (and benefit from strict JSON schemas), while most other providers are unreliable for JSON generation and do better with XML, even if they claim to support JSON.

'RoleParamsDisabled' is used to disable role-based parameters like temperature, top_p, etc. for the model—OpenAI early releases often don't allow changes to these.

'SystemPromptDisabled' is used to disable the system prompt for the model—OpenAI early releases sometimes don't allow system prompts.

'ReasoningEffortEnabled' is used to enable reasoning effort for the model (like OpenAI's o3-mini).

'ReasoningEffort' is the reasoning effort for the model, when 'ReasoningEffortEnabled' is true.

'PredictedOutputEnabled' is used to enable predicted output for the model (currently only supported by gpt-4o).

'ApiKeyEnvVar' is the environment variable that contains the API key for the model.
*/

var BuiltInModels = []*BaseModelConfigSchema{
	{
		ModelTag:    "openai/o3",
		Publisher:   ModelPublisherOpenAI,
		Description: "OpenAI o3",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 100000,
			ReservedOutputTokens: 40000, ModelCompatibility: FullCompatibility,
			PreferredOutputFormat: ModelOutputFormatXml, SystemPromptDisabled: true,
			RoleParamsDisabled: true, ReasoningEffortEnabled: true, StopDisabled: true,
		},
		RequiresVariantOverrides: []string{"ReasoningEffort"},
		Variants: []BaseModelConfigVariant{
			{VariantTag: "high", Description: "high", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortHigh}},
			{VariantTag: "medium", Description: "medium", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortMedium}},
			{VariantTag: "low", Description: "low", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortLow}},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenAI, ModelName: "o3"},
			{Provider: ModelProviderAzureOpenAI, ModelName: "azure/o3"},
			{Provider: ModelProviderOpenRouter, ModelName: "openai/o3"},
		},
	},
	{
		ModelTag:    "openai/o4-mini",
		Publisher:   ModelPublisherOpenAI,
		Description: "OpenAI o4-mini",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 200000, MaxOutputTokens: 100000,
			ReservedOutputTokens: 40000, ModelCompatibility: FullCompatibility,
			PreferredOutputFormat: ModelOutputFormatToolCallJson, SystemPromptDisabled: true,
			RoleParamsDisabled: true, ReasoningEffortEnabled: true, ReasoningEffort: ReasoningEffortHigh,
			StopDisabled: true,
		},
		RequiresVariantOverrides: []string{"ReasoningEffort"},
		Variants: []BaseModelConfigVariant{
			{VariantTag: "high", Description: "high", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortHigh}},
			{VariantTag: "medium", Description: "medium", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortMedium, ReservedOutputTokens: 30000}},
			{VariantTag: "low", Description: "low", Overrides: BaseModelShared{ReasoningEffort: ReasoningEffortLow, ReservedOutputTokens: 20000}},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenAI, ModelName: "o4-mini"},
			{Provider: ModelProviderAzureOpenAI, ModelName: "azure/o4-mini"},
			{Provider: ModelProviderOpenRouter, ModelName: "openai/o4-mini"},
		},
	},
	{
		ModelTag:    "openai/gpt-4.1",
		Publisher:   ModelPublisherOpenAI,
		Description: "OpenAI gpt-4.1",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 1047576,
			MaxOutputTokens: 32768, ReservedOutputTokens: 32768,
			ModelCompatibility: FullCompatibility, PreferredOutputFormat: ModelOutputFormatToolCallJson,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenAI, ModelName: "gpt-4.1"},
			{Provider: ModelProviderAzureOpenAI, ModelName: "azure/gpt-4.1"},
			{Provider: ModelProviderOpenRouter, ModelName: "openai/gpt-4.1"},
		},
	},
	{
		ModelTag:    "openai/gpt-4.1-mini",
		Publisher:   ModelPublisherOpenAI,
		Description: "OpenAI gpt-4.1-mini",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 1047576,
			MaxOutputTokens: 32768, ReservedOutputTokens: 32768,
			ModelCompatibility: FullCompatibility, PreferredOutputFormat: ModelOutputFormatToolCallJson,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenAI, ModelName: "gpt-4.1-mini"},
			{Provider: ModelProviderAzureOpenAI, ModelName: "azure/gpt-4.1-mini"},
			{Provider: ModelProviderOpenRouter, ModelName: "openai/gpt-4.1-mini"},
		},
	},
	{
		ModelTag:    "openai/gpt-4.1-nano",
		Publisher:   ModelPublisherOpenAI,
		Description: "OpenAI gpt-4.1-nano",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 1047576,
			MaxOutputTokens: 32768, ReservedOutputTokens: 32768,
			ModelCompatibility: FullCompatibility, PreferredOutputFormat: ModelOutputFormatToolCallJson,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenAI, ModelName: "gpt-4.1-nano"},
			{Provider: ModelProviderAzureOpenAI, ModelName: "azure/gpt-4.1-nano"},
			{Provider: ModelProviderOpenRouter, ModelName: "openai/gpt-4.1-nano"},
		},
	},
	{
		ModelTag:    "anthropic/claude-opus-4",
		Publisher:   ModelPublisherAnthropic,
		Description: "Anthropic Claude Opus 4",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 128000,
			ReservedOutputTokens: 20000, SupportsCacheControl: true,
			PreferredOutputFormat: ModelOutputFormatXml, SingleMessageNoSystemPrompt: true,
			TokenEstimatePaddingPct: 0.10,
		},
		Variants: []BaseModelConfigVariant{
			{IsBaseVariant: true},
			// Opus thinking variant not working yet—might need a specific cap set
			// {
			// 	VariantTag: "thinking", Description: "thinking",
			// 	Overrides: BaseModelShared{ReasoningBudget: AnthropicMaxReasoningBudget},
			// 	Variants: []BaseModelConfigVariant{
			// 		{VariantTag: "visible", IsDefaultVariant: true, Description: "visible", Overrides: BaseModelShared{IncludeReasoning: true}},
			// 		{VariantTag: "hidden", Description: "hidden", Overrides: BaseModelShared{IncludeReasoning: false}},
			// 	},
			// },
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderAnthropic, ModelName: "anthropic/claude-opus-4-0"},
			{Provider: ModelProviderAmazonBedrock, ModelName: "bedrock/anthropic.claude-opus-4-20250514-v1:0"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/claude-opus-4@20250514"},
			{Provider: ModelProviderOpenRouter, ModelName: "anthropic/claude-opus-4"},
		},
	},
	{
		ModelTag:    "anthropic/claude-sonnet-4",
		Publisher:   ModelPublisherAnthropic,
		Description: "Anthropic Claude Sonnet 4",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 128000,
			ReservedOutputTokens: 40000, SupportsCacheControl: true,
			PreferredOutputFormat: ModelOutputFormatXml, SingleMessageNoSystemPrompt: true,
			TokenEstimatePaddingPct: 0.10,
		},
		Variants: []BaseModelConfigVariant{
			{IsBaseVariant: true},
			{
				VariantTag: "thinking", Description: "thinking",
				Overrides: BaseModelShared{ReasoningBudget: AnthropicMaxReasoningBudget},
				Variants: []BaseModelConfigVariant{
					{VariantTag: "visible", IsDefaultVariant: true, Description: "visible", Overrides: BaseModelShared{IncludeReasoning: true}},
					{VariantTag: "hidden", Description: "hidden", Overrides: BaseModelShared{IncludeReasoning: false}},
				},
			},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderAnthropic, ModelName: "anthropic/claude-sonnet-4-0"},
			{Provider: ModelProviderAmazonBedrock, ModelName: "anthropic.claude-sonnet-4-20250514-v1:0"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/claude-sonnet-4@20250514"},
			{Provider: ModelProviderOpenRouter, ModelName: "anthropic/claude-sonnet-4"},
		},
	},
	{
		ModelTag:    "anthropic/claude-3.7-sonnet",
		Publisher:   ModelPublisherAnthropic,
		Description: "Anthropic Claude 3.7 Sonnet",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 128000,
			ReservedOutputTokens: 20000, SupportsCacheControl: true,
			PreferredOutputFormat: ModelOutputFormatXml, SingleMessageNoSystemPrompt: true,
			TokenEstimatePaddingPct: 0.10,
		},
		Variants: []BaseModelConfigVariant{
			{IsBaseVariant: true},
			{
				VariantTag: "thinking", Description: "thinking",
				Overrides: BaseModelShared{ReasoningBudget: AnthropicMaxReasoningBudget},
				Variants: []BaseModelConfigVariant{
					{VariantTag: "visible", IsDefaultVariant: true, Description: "visible", Overrides: BaseModelShared{IncludeReasoning: true}},
					{VariantTag: "hidden", Description: "hidden", Overrides: BaseModelShared{IncludeReasoning: false}},
				},
			},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderAnthropic, ModelName: "anthropic/claude-3-7-sonnet-latest"},
			{Provider: ModelProviderAmazonBedrock, ModelName: "bedrock/anthropic.claude-3-7-sonnet-20250219-v1:0"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/claude-3-7-sonnet@20250219"},
			{Provider: ModelProviderOpenRouter, ModelName: "anthropic/claude-3.7-sonnet"},
		},
	},
	{
		ModelTag:    "anthropic/claude-3.5-sonnet",
		Publisher:   ModelPublisherAnthropic,
		Description: "Anthropic Claude 3.5 Sonnet",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 128000,
			ReservedOutputTokens: 20000, SupportsCacheControl: true,
			PreferredOutputFormat: ModelOutputFormatXml, SingleMessageNoSystemPrompt: true,
			TokenEstimatePaddingPct: 0.10,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderAnthropic, ModelName: "anthropic/claude-3-5-sonnet-latest"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/claude-3-5-sonnet-v2@20241022"},
			{Provider: ModelProviderAmazonBedrock, ModelName: "bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0"},
			{Provider: ModelProviderOpenRouter, ModelName: "anthropic/claude-3.5-sonnet"},
		},
	},
	{
		ModelTag:    "anthropic/claude-3.5-haiku",
		Publisher:   ModelPublisherAnthropic,
		Description: "Anthropic Claude 3.5 Haiku",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 200000, MaxOutputTokens: 8192,
			ReservedOutputTokens: 8192, SupportsCacheControl: true,
			PreferredOutputFormat: ModelOutputFormatXml, SingleMessageNoSystemPrompt: true,
			TokenEstimatePaddingPct: 0.10,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderAnthropic, ModelName: "anthropic/claude-3-5-haiku-latest"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/claude-3-5-haiku@20241022"},
			{Provider: ModelProviderAmazonBedrock, ModelName: "bedrock/anthropic.claude-3-5-haiku-20241022-v1:0"},
			{Provider: ModelProviderOpenRouter, ModelName: "anthropic/claude-3.5-haiku"},
		},
	},
	{
		ModelTag:    "google/gemini-pro-1.5",
		Publisher:   ModelPublisherGoogle,
		Description: "Google Gemini 1.5 Pro",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 2000000,
			MaxOutputTokens: 8192, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderGoogleAIStudio, ModelName: "gemini/gemini-1.5-pro"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/gemini-1.5-pro"},
			{Provider: ModelProviderOpenRouter, ModelName: "google/gemini-pro-1.5"},
		},
	},
	{
		ModelTag:    "google/gemini-2.5-pro",
		Publisher:   ModelPublisherGoogle,
		Description: "Google Gemini 2.5 Pro",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 1048576,
			MaxOutputTokens: 65535, ReservedOutputTokens: 65535,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderGoogleAIStudio, ModelName: "gemini/gemini-2.5-pro"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/gemini-2.5-pro"},
			{Provider: ModelProviderOpenRouter, ModelName: "google/gemini-2.5-pro"},
		},
	},
	{
		ModelTag:    "google/gemini-2.5-flash",
		Publisher:   ModelPublisherGoogle,
		Description: "Google Gemini 2.5 Flash",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 75000, MaxTokens: 1048576,
			MaxOutputTokens: 65535, ReservedOutputTokens: 65535,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Variants: []BaseModelConfigVariant{
			{IsBaseVariant: true},
			{
				VariantTag:  "thinking",
				Description: "thinking",
				Overrides:   BaseModelShared{IncludeReasoning: true},
				Variants: []BaseModelConfigVariant{
					{VariantTag: "visible", IsDefaultVariant: true, Description: "visible"},
					{VariantTag: "hidden", Description: "hidden", Overrides: BaseModelShared{HideReasoning: true}},
				},
			},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderGoogleAIStudio, ModelName: "gemini/gemini-2.5-flash"},
			{Provider: ModelProviderGoogleVertex, ModelName: "vertex_ai/gemini-2.5-flash"},
			{Provider: ModelProviderOpenRouter, ModelName: "google/gemini-2.5-flash"},
		},
	},
	{
		ModelTag:    "deepseek/v3",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek V3",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 7500, MaxTokens: 64000,
			MaxOutputTokens: 8192, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderDeepSeek, ModelName: "deepseek/deepseek-chat"},
			{Provider: ModelProviderOpenRouter, ModelName: "deepseek/deepseek-chat-v3"},
		},
	},
	{
		ModelTag:    "deepseek/r1",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek R1",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 7500, MaxTokens: 164000,
			MaxOutputTokens: 33000, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Variants: []BaseModelConfigVariant{
			{VariantTag: "visible", IsDefaultVariant: true, Description: "(reasoning visible)", Overrides: BaseModelShared{IncludeReasoning: true}},
			{VariantTag: "hidden", Description: "(reasoning hidden)", Overrides: BaseModelShared{IncludeReasoning: false}},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderDeepSeek, ModelName: "deepseek/deepseek-reasoner"},
			{Provider: ModelProviderOpenRouter, ModelName: "deepseek/deepseek-r1-0528"},
		},
	},
	{
		ModelTag:    "deepseek/r1-70b",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek R1 70B",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 131072,
			MaxOutputTokens: 131072, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/deepseek-r1:70b"},
		},
	},
	{
		ModelTag:    "deepseek/r1-32b",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek R1 32B",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 131072,
			MaxOutputTokens: 131072, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/deepseek-r1:32b"},
		},
	},
	{
		ModelTag:    "deepseek/r1-14b",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek R1 14B",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 131072,
			MaxOutputTokens: 131072, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/deepseek-r1:14b"},
		},
	},
	{
		ModelTag:    "deepseek/r1-8b",
		Publisher:   ModelPublisherDeepSeek,
		Description: "DeepSeek R1 8B",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 131072,
			MaxOutputTokens: 131072, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/deepseek-r1:8b"},
		},
	},

	{
		ModelTag:    "qwen/qwen-2.5-coder-32b-instruct",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 2.5 Coder 32B (Instruct)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 128000,
			MaxOutputTokens: 8192, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenRouter, ModelName: "qwen/qwen-2.5-coder-32b-instruct"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-235b-local",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-235B (Local)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/qwen3:235b"},
		},
	},

	{
		ModelTag:    "qwen/qwen3-235b-a22b-cloud",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-235B A22B (Cloud)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenRouter, ModelName: "qwen/qwen3-235b-a22b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-32b-local",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-32B (Local)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/qwen3:32b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-32b-cloud",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-32B (Cloud)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenRouter, ModelName: "qwen/qwen3-32b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-14b-local",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-14B (Local)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/qwen3:14b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-14b-cloud",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-14B (Cloud)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 40960,
			MaxOutputTokens: 40960, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenRouter, ModelName: "qwen/qwen3-14b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-8b-local",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-8B (Local)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 5000, MaxTokens: 32768,
			MaxOutputTokens: 32768, ReservedOutputTokens: 8192,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/qwen3:8b"},
		},
	},
	{
		ModelTag:    "qwen/qwen3-8b-cloud",
		Publisher:   ModelPublisherQwen,
		Description: "Qwen 3-8B (Cloud)",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 128000,
			MaxOutputTokens: 20000, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOpenRouter, ModelName: "qwen/qwen3-8b"},
		},
	},

	{
		ModelTag:    "mistral/devstral-small",
		Publisher:   ModelPublisherMistral,
		Description: "Mistral Devstral Small",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 15000, MaxTokens: 128000,
			MaxOutputTokens: 128000, ReservedOutputTokens: 16384,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/devstral:24b"},
			{Provider: ModelProviderOpenRouter, ModelName: "mistral/devstral-small"},
		},
	},

	{
		ModelTag:    "perplexity/r1-1776",
		Publisher:   ModelPublisherPerplexity,
		Description: "Perplexity R1-1776",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 7500, MaxTokens: 128000,
			MaxOutputTokens: 128000, ReservedOutputTokens: 30000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Variants: []BaseModelConfigVariant{
			{VariantTag: "visible", IsDefaultVariant: true, Description: "(reasoning visible)", Overrides: BaseModelShared{IncludeReasoning: true}},
			{VariantTag: "hidden", Description: "(reasoning hidden)", Overrides: BaseModelShared{IncludeReasoning: false}},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderPerplexity, ModelName: "r1-1776-online"},
			{Provider: ModelProviderOpenRouter, ModelName: "perplexity/r1-1776"},
		},
	},

	{
		ModelTag:    "perplexity/r1-1776-70b",
		Publisher:   ModelPublisherPerplexity,
		Description: "Perplexity R1-1776 70B",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 10000, MaxTokens: 131072,
			MaxOutputTokens: 131072, ReservedOutputTokens: 20000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderOllama, ModelName: "ollama_chat/r1-1776:70b"},
		},
	},

	{
		ModelTag:    "perplexity/sonar-reasoning",
		Publisher:   ModelPublisherPerplexity,
		Description: "Perplexity Sonar Reasoning",
		BaseModelShared: BaseModelShared{
			DefaultMaxConvoTokens: 7500, MaxTokens: 127000,
			MaxOutputTokens: 127000, ReservedOutputTokens: 30000,
			PreferredOutputFormat: ModelOutputFormatXml,
		},
		Variants: []BaseModelConfigVariant{
			{VariantTag: "visible", IsDefaultVariant: true, Description: "(reasoning visible)", Overrides: BaseModelShared{IncludeReasoning: true}},
			{VariantTag: "hidden", Description: "(reasoning hidden)", Overrides: BaseModelShared{IncludeReasoning: false}},
		},
		Providers: []BaseModelUsesProvider{
			{Provider: ModelProviderPerplexity, ModelName: "sonar-reasoning-online"},
			{Provider: ModelProviderOpenRouter, ModelName: "perplexity/sonar-reasoning"},
		},
	},
}

var BuiltInBaseModelsById = map[ModelId]*BaseModelConfigSchema{}

var BuiltInModelProvidersByModelId = map[ModelId][]BaseModelUsesProvider{}
var BuiltInBaseModels = []*BaseModelConfigSchema{}

var AvailableModels = []*AvailableModel{}

var AvailableModelsByComposite = map[string]*AvailableModel{}

func init() {
	for _, model := range BuiltInModels {
		// if the model has an anthropic provider, insert claude max provider before it
		var usesAnthropicProvider *BaseModelUsesProvider
		for _, provider := range model.Providers {
			if provider.Provider == ModelProviderAnthropic {
				copy := provider
				latestModelName, ok := AnthropicLatestModelNameMap[provider.ModelName]
				if ok {
					copy.ModelName = latestModelName
				}
				usesAnthropicProvider = &copy
				break
			}
		}
		if usesAnthropicProvider != nil {
			usesAnthropicProvider.Provider = ModelProviderAnthropicClaudeMax
			model.Providers = append([]BaseModelUsesProvider{*usesAnthropicProvider}, model.Providers...)
		}

		AvailableModels = append(AvailableModels, model.ToAvailableModels()...)

		var addVariants func(variants []BaseModelConfigVariant, baseId ModelId)
		addVariants = func(variants []BaseModelConfigVariant, baseId ModelId) {
			for _, variant := range variants {
				var modelId ModelId
				if variant.IsBaseVariant || variant.IsDefaultVariant {
					modelId = baseId
				} else {
					modelId = ModelId(strings.Join([]string{string(baseId), string(variant.VariantTag)}, "-"))
				}

				if _, ok := BuiltInBaseModelsById[modelId]; !ok {
					cloned := *model
					cloned.ModelId = modelId
					merged := Merge(model.BaseModelShared, variant.Overrides)
					cloned.BaseModelShared = merged

					BuiltInModelProvidersByModelId[modelId] = cloned.Providers
					BuiltInBaseModelsById[modelId] = &cloned
					BuiltInBaseModels = append(BuiltInBaseModels, &cloned)
				}

				if len(variant.Variants) > 0 {
					addVariants(variant.Variants, modelId)
					continue
				}

			}
		}

		if len(model.Variants) > 0 {
			addVariants(model.Variants, ModelId(string(model.ModelTag)))
		} else {
			modelId := ModelId(string(model.ModelTag))
			model.ModelId = modelId
			BuiltInModelProvidersByModelId[modelId] = model.Providers
			BuiltInBaseModelsById[modelId] = model
			BuiltInBaseModels = append(BuiltInBaseModels, model)
		}
	}

	// fmt.Println("AvailableModels")
	// for _, model := range AvailableModels {
	// 	fmt.Println(model.ModelString())
	// }

	for _, model := range AvailableModels {
		if model.Description == "" {
			spew.Dump(model)
			panic("description is not set")
		}

		if model.Provider == "" {
			spew.Dump(model)
			panic("model provider is not set")
		}
		if model.ModelId == "" {
			spew.Dump(model)
			panic("model id is not set")
		}

		if model.DefaultMaxConvoTokens == 0 {
			spew.Dump(model)
			panic("default max convo tokens is not set")
		}

		if model.MaxTokens == 0 {
			spew.Dump(model)
			panic("max tokens is not set")
		}

		if model.MaxOutputTokens == 0 {
			spew.Dump(model)
			panic("max output tokens is not set")
		}

		if model.ReservedOutputTokens == 0 {
			spew.Dump(model)
			panic("reserved output tokens is not set")
		}

		if model.ApiKeyEnvVar == "" && len(model.ExtraAuthVars) == 0 && !model.SkipAuth && !model.HasAWSAuth && !model.HasClaudeMaxAuth {
			spew.Dump(model)
			panic("api key or auth settings are not set")
		}

		if model.BaseUrl == "" {
			spew.Dump(model)
			panic("base url is not set")
		}

		if model.PreferredOutputFormat == "" {
			spew.Dump(model)
			panic("preferred model output format is not set")
		}

		compositeKey := string(model.Provider) + "/" + string(model.ModelId)
		AvailableModelsByComposite[compositeKey] = model
	}
}

func GetAvailableModel(provider ModelProvider, modelId ModelId) *AvailableModel {
	compositeKey := string(provider) + "/" + string(modelId)
	return AvailableModelsByComposite[compositeKey]
}

var AnthropicLatestModelNameMap = map[ModelName]ModelName{
	"anthropic/claude-sonnet-4-0":        "anthropic/claude-sonnet-4-20250514",
	"anthropic/claude-opus-4-0":          "anthropic/claude-opus-4-20250514",
	"anthropic/claude-3-7-sonnet-latest": "anthropic/claude-3-7-sonnet-20250219",
	"anthropic/claude-3-5-haiku-latest":  "anthropic/claude-3-5-haiku-20241022",
	"anthropic/claude-3-5-sonnet-latest": "anthropic/claude-3-5-sonnet-20241022",
}


================================================
FILE: app/shared/ai_models_compatibility.go
================================================
package shared

var FullCompatibility = ModelCompatibility{
	HasImageSupport: true,
}

var RequiredCompatibilityByRole = map[ModelRole]ModelCompatibility{
	ModelRolePlanner:          {},
	ModelRolePlanSummary:      {},
	ModelRoleBuilder:          {},
	ModelRoleName:             {},
	ModelRoleCommitMsg:        {},
	ModelRoleExecStatus:       {},
	ModelRoleArchitect:        {},
	ModelRoleCoder:            {},
	ModelRoleWholeFileBuilder: {},
}

func FilterBuiltInCompatibleModels(models []*BaseModelConfigSchema, role ModelRole) []*BaseModelConfigSchema {
	// required := RequiredCompatibilityByRole[role]
	var compatibleModels []*BaseModelConfigSchema

	for _, model := range models {
		// no compatibility checks are needed in v2, but keeping this here in case compatibility checks are needed in the future

		compatibleModels = append(compatibleModels, model)
	}

	return compatibleModels
}

func FilterCustomCompatibleModels(models []*CustomModel, role ModelRole) []*CustomModel {
	// required := RequiredCompatibilityByRole[role]
	var compatibleModels []*CustomModel

	for _, model := range models {
		// no compatibility checks are needed in v2, but keeping this here in case compatibility checks are needed in the future

		compatibleModels = append(compatibleModels, model)
	}

	return compatibleModels
}


================================================
FILE: app/shared/ai_models_config.go
================================================
package shared

var DefaultConfigByRole = map[ModelRole]ModelRoleConfig{
	ModelRolePlanner: {
		Temperature: 0.3,
		TopP:        0.3,
	},
	ModelRoleCoder: {
		Temperature: 0.3,
		TopP:        0.3,
	},
	ModelRoleArchitect: {
		Temperature: 0.3,
		TopP:        0.3,
	},
	ModelRolePlanSummary: {
		Temperature: 0.2,
		TopP:        0.2,
	},
	ModelRoleBuilder: {
		Temperature: 0.1,
		TopP:        0.1,
	},
	ModelRoleWholeFileBuilder: {
		Temperature: 0.1,
		TopP:        0.1,
	},
	ModelRoleName: {
		Temperature: 0.8,
		TopP:        0.5,
	},
	ModelRoleCommitMsg: {
		Temperature: 0.8,
		TopP:        0.5,
	},
	ModelRoleExecStatus: {
		Temperature: 0.1,
		TopP:        0.1,
	},
}


================================================
FILE: app/shared/ai_models_credentials.go
================================================
package shared

type ModelProviderOption struct {
	Publishers map[ModelPublisher]bool
	Config     *ModelProviderConfigSchema
	Priority   int
}

type ModelProviderOptions map[string]ModelProviderOption

func (m ModelRoleConfig) GetModelProviderOptions(settings *PlanSettings) ModelProviderOptions {
	opts := ModelProviderOptions{}

	builtInUsesProviders := BuiltInModelProvidersByModelId[m.ModelId]

	var customUsesProviders []BaseModelUsesProvider
	if settings != nil {
		customUsesProviders = settings.UsesCustomProviderByModelId[m.ModelId]
	}

	usesProviders := append(builtInUsesProviders, customUsesProviders...)
	if len(usesProviders) == 0 {
		return opts
	}

	for i, usesProvider := range usesProviders {
		composite := usesProvider.ToComposite()

		foundProvider := false
		config, ok := BuiltInModelProviderConfigs[usesProvider.Provider]
		if ok {
			// built-in provider
			foundProvider = true
		} else if settings != nil && settings.CustomProviders != nil {
			// no built-in provider, check custom providers
			for _, customProvider := range settings.CustomProviders {
				if usesProvider.CustomProvider != nil && customProvider.Name == *usesProvider.CustomProvider {
					config = customProvider.ToModelProviderConfigSchema()
					foundProvider = true
					break
				}
			}
		}

		if !foundProvider {
			continue
		}

		var publisher ModelPublisher

		baseModel, ok := BuiltInBaseModelsById[m.ModelId]
		if ok {
			publisher = baseModel.Publisher
		} else if settings != nil && settings.CustomModelsById != nil {
			customModel, ok := settings.CustomModelsById[m.ModelId]
			if ok {
				publisher = customModel.Publisher
			}
		}

		if publisher == "" {
			continue
		}

		opts[composite] = ModelProviderOption{
			Publishers: map[ModelPublisher]bool{
				publisher: true,
			},
			Config:   &config,
			Priority: i,
		}
	}

	if m.ErrorFallback != nil {
		opts = opts.Condense(m.ErrorFallback.GetModelProviderOptions(settings))
	}

	if m.LargeContextFallback != nil {
		opts = opts.Condense(m.LargeContextFallback.GetModelProviderOptions(settings))
	}

	if m.LargeOutputFallback != nil {
		opts = opts.Condense(m.LargeOutputFallback.GetModelProviderOptions(settings))
	}

	if m.StrongModel != nil {
		opts = opts.Condense(m.StrongModel.GetModelProviderOptions(settings))
	}

	return opts
}

func (m ModelProviderOptions) Condense(opts ...ModelProviderOptions) ModelProviderOptions {
	for _, opt := range opts {
		for composite, option := range opt {
			existingOption, exists := m[composite]
			if !exists {
				// first time seeing this composite, add directly
				m[composite] = ModelProviderOption{
					Publishers: copyPublishersMap(option.Publishers),
					Config:     option.Config,
					Priority:   option.Priority,
				}
				continue
			}

			if option.Priority < existingOption.Priority {
				existingOption.Priority = option.Priority
			}

			// composite already exists, merge Publishers
			for pub := range option.Publishers {
				existingOption.Publishers[pub] = true
			}

			// no need to overwrite Config, as it should be identical
			m[composite] = existingOption
		}
	}
	return m
}

func copyPublishersMap(src map[ModelPublisher]bool) map[ModelPublisher]bool {
	cpy := make(map[ModelPublisher]bool, len(src))
	for k, v := range src {
		cpy[k] = v
	}
	return cpy
}


================================================
FILE: app/shared/ai_models_custom.go
================================================
package shared

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"strings"
	"time"

	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
)

type SchemaUrl string

const (
	SchemaUrlInputConfig     SchemaUrl = "https://plandex.ai/schemas/models-input.schema.json"
	SchemaUrlPlanConfig      SchemaUrl = "https://plandex.ai/schemas/plan-config.schema.json"
	SchemaUrlInlineModelPack SchemaUrl = "https://plandex.ai/schemas/model-pack-inline.schema.json"
)

// Note that none of the custom model structs should have maps anywhere in the hierarchy, since it will break deterministic hashing. Use structs or slices instead.

type CustomModel struct {
	Id          string         `json:"id,omitempty"`
	ModelId     ModelId        `json:"modelId"`
	Publisher   ModelPublisher `json:"publisher"`
	Description string         `json:"description"`

	BaseModelShared

	Providers []BaseModelUsesProvider `json:"providers"`

	CreatedAt *time.Time `json:"createdAt,omitempty"`
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

type CustomProvider struct {
	Id      string `json:"id,omitempty"`
	Name    string `json:"name"`
	BaseUrl string `json:"baseUrl"`

	// for AWS Bedrock models
	HasAWSAuth bool `json:"hasAWSAuth,omitempty"`

	// for local models that don't require auth (ollama, etc.)
	SkipAuth bool `json:"skipAuth,omitempty"`

	ApiKeyEnvVar  string                       `json:"apiKeyEnvVar,omitempty"`
	ExtraAuthVars []ModelProviderExtraAuthVars `json:"extraAuthVars,omitempty"`

	CreatedAt *time.Time `json:"createdAt,omitempty"`
	UpdatedAt *time.Time `json:"updatedAt,omitempty"`
}

type ModelsInput struct {
	CustomModels     []*CustomModel     `json:"models,omitempty"`
	CustomProviders  []*CustomProvider  `json:"providers,omitempty"`
	CustomModelPacks []*ModelPackSchema `json:"modelPacks,omitempty"`
}

func (input ModelsInput) FilterUnchanged(existing *ModelsInput) ModelsInput {
	filtered := ModelsInput{}

	existingProvidersById := map[string]*CustomProvider{}
	for _, provider := range existing.CustomProviders {
		existingProvidersById[provider.Name] = provider
	}
	existingModelsById := map[string]*CustomModel{}
	for _, model := range existing.CustomModels {
		existingModelsById[string(model.ModelId)] = model
	}
	existingPacksById := map[string]*ModelPackSchema{}
	for _, pack := range existing.CustomModelPacks {
		existingPacksById[pack.Name] = pack
	}

	for _, model := range input.CustomModels {
		if existingModel, ok := existingModelsById[string(model.ModelId)]; !ok || !modelsEqual(model, existingModel) {
			filtered.CustomModels = append(filtered.CustomModels, model)
		}
	}

	for _, provider := range input.CustomProviders {
		if existingProvider, ok := existingProvidersById[provider.Name]; !ok || !providersEqual(provider, existingProvider) {
			filtered.CustomProviders = append(filtered.CustomProviders, provider)
		}
	}

	for _, pack := range input.CustomModelPacks {
		if existingPack, ok := existingPacksById[pack.Name]; !ok || !packsEqual(pack, existingPack) {
			filtered.CustomModelPacks = append(filtered.CustomModelPacks, pack)
		}
	}

	return filtered
}

func (input ModelsInput) Equals(other ModelsInput) bool {
	left := input.FilterUnchanged(&other)
	right := other.FilterUnchanged(&input)

	return left.IsEmpty() && right.IsEmpty()
}

func (input ModelsInput) CheckNoDuplicates() (bool, string) {
	sawModelIds := map[ModelId]bool{}
	sawProviderNames := map[string]bool{}
	sawPackNames := map[string]bool{}

	builder := strings.Builder{}

	for _, provider := range input.CustomProviders {
		if _, ok := sawProviderNames[provider.Name]; ok {
			builder.WriteString(fmt.Sprintf("• Provider %s is duplicated\n", provider.Name))
		}
		sawProviderNames[provider.Name] = true
	}

	for _, model := range input.CustomModels {
		if _, ok := sawModelIds[model.ModelId]; ok {
			builder.WriteString(fmt.Sprintf("• Model %s is duplicated\n", model.ModelId))
		}
		sawModelIds[model.ModelId] = true
	}

	for _, pack := range input.CustomModelPacks {
		if _, ok := sawPackNames[pack.Name]; ok {
			builder.WriteString(fmt.Sprintf("• Model pack %s is duplicated\n", pack.Name))
		}
		sawPackNames[pack.Name] = true
	}

	res := builder.String()

	return len(res) == 0, res
}

func (input ModelsInput) IsEmpty() bool {
	return len(input.CustomModels) == 0 && len(input.CustomProviders) == 0 && len(input.CustomModelPacks) == 0
}

func modelsEqual(a, b *CustomModel) bool {
	return cmp.Equal(
		a, b,
		cmpopts.EquateEmpty(), // treat nil == empty slice/map
		cmpopts.IgnoreFields(CustomModel{}, "CreatedAt", "UpdatedAt", "Id"),
	)
}

func providersEqual(a, b *CustomProvider) bool {
	return cmp.Equal(
		a,
		b,
		cmpopts.EquateEmpty(),
		cmpopts.IgnoreFields(CustomProvider{}, "CreatedAt", "UpdatedAt", "Id"),
	)
}

func packsEqual(a, b *ModelPackSchema) bool {
	res := cmp.Equal(
		a,
		b,
		cmpopts.EquateEmpty(),
	)
	return res
}

func (s *ModelPackSchema) Equals(other *ModelPackSchema) bool {
	return packsEqual(s, other)
}

func (mp *ModelPack) Equals(other *ModelPack) bool {
	return mp.ToModelPackSchema().Equals(other.ToModelPackSchema())
}

// Hash returns a deterministic hash of the ModelsInput.
// WARNING: This relies on json.Marshal being deterministic for our struct types.
// Do not add map fields to these structs or the hash will become non-deterministic.
func (input ModelsInput) Hash() (string, error) {
	data, err := json.Marshal(input)
	if err != nil {
		return "", err
	}

	hash := sha256.Sum256(data)
	return hex.EncodeToString(hash[:]), nil
}

type ClientModelPackSchema struct {
	Name        string `json:"name"`
	Description string `json:"description"`

	ClientModelPackSchemaRoles
}

func (input *ClientModelPackSchema) ToModelPackSchema() *ModelPackSchema {
	return &ModelPackSchema{
		Name:                 input.Name,
		Description:          input.Description,
		ModelPackSchemaRoles: input.ClientModelPackSchemaRoles.ToModelPackSchemaRoles(),
	}
}

func (input *ModelPackSchema) ToClientModelPackSchema() *ClientModelPackSchema {
	return &ClientModelPackSchema{
		Name:                       input.Name,
		Description:                input.Description,
		ClientModelPackSchemaRoles: input.ToClientModelPackSchemaRoles(),
	}
}

type ClientModelsInput struct {
	SchemaUrl SchemaUrl `json:"$schema"`

	CustomModels     []*CustomModel           `json:"models,omitempty"`
	CustomProviders  []*CustomProvider        `json:"providers,omitempty"`
	CustomModelPacks []*ClientModelPackSchema `json:"modelPacks,omitempty"`
}

func (input ClientModelsInput) ToModelsInput() ModelsInput {
	modelPacks := []*ModelPackSchema{}
	for _, pack := range input.CustomModelPacks {
		modelPacks = append(modelPacks, pack.ToModelPackSchema())
	}

	return ModelsInput{
		CustomModels:     input.CustomModels,
		CustomProviders:  input.CustomProviders,
		CustomModelPacks: modelPacks,
	}
}

func (input *ClientModelsInput) PrepareUpdate() {
	for _, model := range input.CustomModels {
		model.Id = ""
		model.CreatedAt = nil
		model.UpdatedAt = nil
	}

	for _, provider := range input.CustomProviders {
		provider.Id = ""
		provider.CreatedAt = nil
		provider.UpdatedAt = nil
	}
}

func (input ModelsInput) ToClientModelsInput() ClientModelsInput {
	clientModelPacks := []*ClientModelPackSchema{}
	for _, pack := range input.CustomModelPacks {
		clientModelPacks = append(clientModelPacks, pack.ToClientModelPackSchema())
	}

	return ClientModelsInput{
		SchemaUrl:        SchemaUrlInputConfig,
		CustomModels:     input.CustomModels,
		CustomProviders:  input.CustomProviders,
		CustomModelPacks: clientModelPacks,
	}
}

func (cp *CustomProvider) ToModelProviderConfigSchema() ModelProviderConfigSchema {
	return ModelProviderConfigSchema{
		Provider:       ModelProviderCustom,
		CustomProvider: &cp.Name,
		BaseUrl:        cp.BaseUrl,
		HasAWSAuth:     cp.HasAWSAuth,
		SkipAuth:       cp.SkipAuth,
		ApiKeyEnvVar:   cp.ApiKeyEnvVar,
		ExtraAuthVars:  cp.ExtraAuthVars,
	}
}

func (input *CustomModel) ToBaseModelConfig(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *BaseModelConfig {
	providers := GetProvidersForAuthVarsWithModelId(authVars, settings, input.ModelId, orgUserConfig)

	if len(providers) == 0 {
		return nil
	}

	providerSchema := providers[0]
	return input.ToBaseModelConfigForProvider(authVars, settings, &providerSchema)
}

func (input *CustomModel) ToBaseModelConfigForProvider(authVars map[string]string, settings *PlanSettings, providerSchema *ModelProviderConfigSchema) *BaseModelConfig {
	var modelName ModelName
	for _, usesProvider := range input.Providers {
		if usesProvider.Provider == providerSchema.Provider {
			modelName = usesProvider.ModelName
			break
		}
	}

	return &BaseModelConfig{
		ModelTag:        ModelTag(input.ModelId),
		ModelId:         input.ModelId,
		Publisher:       input.Publisher,
		BaseModelShared: input.BaseModelShared,
		BaseModelProviderConfig: BaseModelProviderConfig{
			ModelProviderConfigSchema: *providerSchema,
			ModelName:                 modelName,
		},
	}
}


================================================
FILE: app/shared/ai_models_data_models.go
================================================
package shared

import (
	"crypto/sha256"
	"database/sql/driver"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"time"
)

type ModelCompatibility struct {
	HasImageSupport bool `json:"hasImageSupport"`
}

type ModelOutputFormat string

const (
	ModelOutputFormatToolCallJson ModelOutputFormat = "tool-call-json"
	ModelOutputFormatXml          ModelOutputFormat = "xml"
)

// to help avoid confusion between model tag, price id, model name, and the model id
type ModelName string
type ModelId string
type ModelTag string
type VariantTag string

type BaseModelShared struct {
	DefaultMaxConvoTokens       int               `json:"defaultMaxConvoTokens"`
	MaxTokens                   int               `json:"maxTokens"`
	MaxOutputTokens             int               `json:"maxOutputTokens"`
	ReservedOutputTokens        int               `json:"reservedOutputTokens"`
	PreferredOutputFormat       ModelOutputFormat `json:"preferredOutputFormat"`
	SystemPromptDisabled        bool              `json:"systemPromptDisabled,omitempty"`
	RoleParamsDisabled          bool              `json:"roleParamsDisabled,omitempty"`
	StopDisabled                bool              `json:"stopDisabled,omitempty"`
	PredictedOutputEnabled      bool              `json:"predictedOutputEnabled,omitempty"`
	ReasoningEffortEnabled      bool              `json:"reasoningEffortEnabled,omitempty"`
	ReasoningEffort             ReasoningEffort   `json:"reasoningEffort,omitempty"`
	IncludeReasoning            bool              `json:"includeReasoning,omitempty"`
	HideReasoning               bool              `json:"hideReasoning,omitempty"`
	ReasoningBudget             int               `json:"reasoningBudget,omitempty"`
	SupportsCacheControl        bool              `json:"supportsCacheControl,omitempty"`
	SingleMessageNoSystemPrompt bool              `json:"singleMessageNoSystemPrompt,omitempty"`
	TokenEstimatePaddingPct     float64           `json:"tokenEstimatePaddingPct,omitempty"`
	ModelCompatibility
}

type BaseModelProviderConfig struct {
	ModelProviderConfigSchema
	ModelName ModelName `json:"modelName"`
}

type BaseModelConfig struct {
	ModelTag  ModelTag       `json:"modelTag"`
	ModelId   ModelId        `json:"modelId"`
	Publisher ModelPublisher `json:"publisher,omitempty"`
	BaseModelShared
	BaseModelProviderConfig
}

type BaseModelUsesProvider struct {
	Provider       ModelProvider `json:"provider"`
	CustomProvider *string       `json:"customProvider,omitempty"`
	ModelName      ModelName     `json:"modelName"`
}

func (b BaseModelUsesProvider) ToComposite() string {
	if b.CustomProvider != nil {
		return fmt.Sprintf("%s|%s", b.Provider, *b.CustomProvider)
	}
	return string(b.Provider)
}

type BaseModelConfigSchema struct {
	ModelTag    ModelTag       `json:"modelTag"`
	ModelId     ModelId        `json:"modelId"`
	Publisher   ModelPublisher `json:"publisher"`
	Description string         `json:"description"`

	BaseModelShared

	RequiresVariantOverrides []string `json:"requiresVariantOverrides"`

	Variants  []BaseModelConfigVariant `json:"variants"`
	Providers []BaseModelUsesProvider  `json:"providers"`
}

type BaseModelConfigVariant struct {
	IsBaseVariant            bool                     `json:"isBaseVariant"`
	VariantTag               VariantTag               `json:"variantTag"`
	Description              string                   `json:"description"`
	Overrides                BaseModelShared          `json:"overrides"`
	Variants                 []BaseModelConfigVariant `json:"variants"`
	RequiresVariantOverrides []string                 `json:"requiresVariantOverrides"`
	IsDefaultVariant         bool                     `json:"isDefaultVariant"`
}

func (b *BaseModelConfigSchema) IsLocalOnly() bool {
	if len(b.Providers) == 0 {
		return false
	}

	for _, provider := range b.Providers {
		builtIn, ok := BuiltInModelProviderConfigs[provider.Provider]
		if !ok {
			// has a custom provider—assume not local only
			return false
		}
		if !builtIn.LocalOnly {
			// has a built-in provider that is not local only
			return false
		}
	}

	return true
}

func (b *BaseModelConfigSchema) ToAvailableModels() []*AvailableModel {
	avail := []*AvailableModel{}
	for _, provider := range b.Providers {

		providerConfig, ok := BuiltInModelProviderConfigs[provider.Provider]
		if !ok {
			panic(fmt.Sprintf("provider %s not found", provider.Provider))
		}

		addBase := func() {
			avail = append(avail, &AvailableModel{
				Description:           b.Description,
				DefaultMaxConvoTokens: b.DefaultMaxConvoTokens,
				BaseModelConfig: BaseModelConfig{
					ModelTag:        b.ModelTag,
					ModelId:         ModelId(string(b.ModelTag)),
					BaseModelShared: b.BaseModelShared,
					BaseModelProviderConfig: BaseModelProviderConfig{
						ModelProviderConfigSchema: providerConfig,
						ModelName:                 provider.ModelName,
					},
				},
			})
		}

		type variantParams struct {
			BaseVariant              *BaseModelConfigVariant
			BaseId                   ModelId
			BaseDescription          string
			CumulativeOverrides      BaseModelShared
			RequiresVariantOverrides []string
		}

		addBaseVariant := func(params variantParams) {
			if params.BaseVariant == nil {
				addBase()
				return
			}
			baseDescription := params.BaseVariant.Description
			baseId := params.BaseId
			mergedOverrides := params.CumulativeOverrides

			avail = append(avail, &AvailableModel{
				Description:           baseDescription,
				DefaultMaxConvoTokens: b.DefaultMaxConvoTokens,
				BaseModelConfig: BaseModelConfig{
					ModelTag:        b.ModelTag,
					ModelId:         baseId,
					Publisher:       b.Publisher,
					BaseModelShared: mergedOverrides,
					BaseModelProviderConfig: BaseModelProviderConfig{
						ModelProviderConfigSchema: providerConfig,
						ModelName:                 provider.ModelName,
					},
				},
			})
		}

		if len(b.Variants) == 0 {
			addBase()
		} else {

			var addVariants func(variants []BaseModelConfigVariant, baseParams variantParams)
			addVariants = func(variants []BaseModelConfigVariant, baseParams variantParams) {
				for _, variant := range variants {
					if variant.IsBaseVariant {
						addBaseVariant(baseParams)
						continue
					}

					if len(baseParams.RequiresVariantOverrides) > 0 {
						ok, missing := FieldsDefined(variant.Overrides, baseParams.RequiresVariantOverrides)
						if !ok {
							panic(fmt.Sprintf("variant %s is missing required field %s", variant.VariantTag, missing))
						}
					}

					var baseId ModelId
					var baseDescription string
					if baseParams.BaseId != "" {
						baseId = baseParams.BaseId
						baseDescription = baseParams.BaseDescription
					} else {
						baseId = ModelId(string(b.ModelTag))
						baseDescription = b.Description
					}

					var modelId ModelId
					if variant.IsDefaultVariant {
						modelId = baseId
					} else {
						modelId = ModelId(strings.Join([]string{string(baseId), string(variant.VariantTag)}, "-"))
					}

					description := strings.Join([]string{baseDescription, variant.Description}, " ")

					merged := Merge(baseParams.CumulativeOverrides, variant.Overrides)

					if len(variant.Variants) > 0 {
						addVariants(variant.Variants, variantParams{
							BaseVariant:              &variant,
							BaseId:                   modelId,
							BaseDescription:          description,
							CumulativeOverrides:      merged,
							RequiresVariantOverrides: variant.RequiresVariantOverrides,
						})
					}
					avail = append(avail, &AvailableModel{
						Description:           description,
						DefaultMaxConvoTokens: b.DefaultMaxConvoTokens,
						BaseModelConfig: BaseModelConfig{
							ModelTag:        b.ModelTag,
							ModelId:         modelId,
							BaseModelShared: merged,
							BaseModelProviderConfig: BaseModelProviderConfig{
								ModelProviderConfigSchema: providerConfig,
								ModelName:                 provider.ModelName,
							},
						},
					})
				}
			}

			addVariants(b.Variants, variantParams{
				BaseId:                   ModelId(string(b.ModelTag)),
				BaseDescription:          b.Description,
				CumulativeOverrides:      b.BaseModelShared,
				RequiresVariantOverrides: b.RequiresVariantOverrides,
			})
		}
	}
	return avail
}

type AvailableModel struct {
	Id string `json:"id"`
	BaseModelConfig
	Description           string    `json:"description"`
	DefaultMaxConvoTokens int       `json:"defaultMaxConvoTokens"`
	CreatedAt             time.Time `json:"createdAt"`
	UpdatedAt             time.Time `json:"updatedAt"`
}

func (m *AvailableModel) ModelString() string {
	s := ""
	if m.Provider != "" && m.Provider != ModelProviderOpenAI {
		s += string(m.Provider) + "/"
	}
	s += string(m.ModelId)
	return s
}

type PlannerModelConfig struct {
	MaxConvoTokens int `json:"maxConvoTokens"`
}

type ReasoningEffort string

const (
	ReasoningEffortLow    ReasoningEffort = "low"
	ReasoningEffortMedium ReasoningEffort = "medium"
	ReasoningEffortHigh   ReasoningEffort = "high"
)

type ModelRoleConfig struct {
	Role ModelRole `json:"role"`

	ModelId ModelId `json:"modelId"` // new in 2.2.0 refactor — uses provider lookup instead of BaseModelConfig and MissingKeyFallback

	BaseModelConfig      *BaseModelConfig `json:"baseModelConfig,omitempty"`
	Temperature          float32          `json:"temperature"`
	TopP                 float32          `json:"topP"`
	ReservedOutputTokens int              `json:"reservedOutputTokens"`

	LargeContextFallback *ModelRoleConfig `json:"largeContextFallback"`
	LargeOutputFallback  *ModelRoleConfig `json:"largeOutputFallback"`
	ErrorFallback        *ModelRoleConfig `json:"errorFallback"`
	// MissingKeyFallback   *ModelRoleConfig `json:"missingKeyFallback"` // removed in 2.2.0 refactor —
	StrongModel *ModelRoleConfig `json:"strongModel"`

	LocalProvider ModelProvider `json:"localProvider,omitempty"`
}

type ModelRoleModelConfig struct {
	Provider       ModelProvider `json:"provider"`
	CustomProvider *string       `json:"customProvider,omitempty"`
	ModelTag       ModelTag      `json:"modelTag"`
}

type ModelRoleConfigSchema struct {
	ModelId ModelId `json:"modelId"`

	Temperature          *float32 `json:"temperature,omitempty"`
	TopP                 *float32 `json:"topP,omitempty"`
	ReservedOutputTokens *int     `json:"reservedOutputTokens,omitempty"`
	MaxConvoTokens       *int     `json:"maxConvoTokens,omitempty"`

	LargeContextFallback *ModelRoleConfigSchema `json:"largeContextFallback,omitempty"`
	LargeOutputFallback  *ModelRoleConfigSchema `json:"largeOutputFallback,omitempty"`
	ErrorFallback        *ModelRoleConfigSchema `json:"errorFallback,omitempty"`
	StrongModel          *ModelRoleConfigSchema `json:"strongModel,omitempty"`
}

// ToClientVal returns either:
//   - string  – when the value (or any nested fallback) is just a bare role
//   - map[string]any – when additional fields are set, with all fallbacks
//     processed recursively.
func (m *ModelRoleConfigSchema) ToClientVal() RoleJSON {
	if m == nil {
		return nil
	}
	if m.bareRole() {
		return string(m.ModelId)
	}

	out := map[string]any{
		"modelId": string(m.ModelId),
	}

	// simple optional scalars
	if m.Temperature != nil {
		out["temperature"] = *m.Temperature
	}
	if m.TopP != nil {
		out["topP"] = *m.TopP
	}
	if m.ReservedOutputTokens != nil {
		out["reservedOutputTokens"] = *m.ReservedOutputTokens
	}
	if m.MaxConvoTokens != nil {
		out["maxConvoTokens"] = *m.MaxConvoTokens
	}

	// recurse on each fallback, collapsing to string when bare
	if m.LargeContextFallback != nil {
		out["largeContextFallback"] = m.LargeContextFallback.ToClientVal()
	}
	if m.LargeOutputFallback != nil {
		out["largeOutputFallback"] = m.LargeOutputFallback.ToClientVal()
	}
	if m.ErrorFallback != nil {
		out["errorFallback"] = m.ErrorFallback.ToClientVal()
	}
	if m.StrongModel != nil {
		out["strongModel"] = m.StrongModel.ToClientVal()
	}

	return out
}

// bareRole returns true if *every* field except ModelId is nil / zero.
func (m *ModelRoleConfigSchema) bareRole() bool {
	if m == nil {
		return true
	}

	v := reflect.ValueOf(*m)
	t := v.Type()

	for i := 0; i < v.NumField(); i++ {
		f := t.Field(i)
		if f.Name == "ModelId" { // skip the sentinel field
			continue
		}

		fv := v.Field(i)

		switch fv.Kind() {
		case reflect.Pointer, reflect.Interface, reflect.Map, reflect.Slice:
			if !fv.IsNil() {
				return false
			}
		default:
			if !fv.IsZero() {
				return false
			}
		}
	}
	return true
}

func (m *ModelRoleConfigSchema) AllModelIds() []ModelId {
	ids := []ModelId{}

	if m.ModelId != "" {
		ids = append(ids, m.ModelId)
	}

	if m.LargeContextFallback != nil {
		ids = append(ids, m.LargeContextFallback.AllModelIds()...)
	}

	if m.LargeOutputFallback != nil {
		ids = append(ids, m.LargeOutputFallback.AllModelIds()...)
	}

	if m.ErrorFallback != nil {
		ids = append(ids, m.ErrorFallback.AllModelIds()...)
	}

	if m.StrongModel != nil {
		ids = append(ids, m.StrongModel.AllModelIds()...)
	}

	return ids
}

func (m *ModelRoleConfigSchema) ToModelRoleConfig(role ModelRole) ModelRoleConfig {
	return m.toModelRoleConfig(role)
}

func (m *ModelRoleConfigSchema) toModelRoleConfig(role ModelRole) ModelRoleConfig {
	var largeContextFallback *ModelRoleConfig
	if m.LargeContextFallback != nil {
		c := m.LargeContextFallback.ToModelRoleConfig(role)
		largeContextFallback = &c
	}
	var largeOutputFallback *ModelRoleConfig
	if m.LargeOutputFallback != nil {
		c := m.LargeOutputFallback.ToModelRoleConfig(role)
		largeOutputFallback = &c
	}
	var errorFallback *ModelRoleConfig
	if m.ErrorFallback != nil {
		c := m.ErrorFallback.ToModelRoleConfig(role)
		errorFallback = &c
	}
	var strongModel *ModelRoleConfig
	if m.StrongModel != nil {
		c := m.StrongModel.ToModelRoleConfig(role)
		strongModel = &c
	}

	temperature := m.Temperature
	topP := m.TopP

	config := DefaultConfigByRole[role]

	if temperature == nil {
		temperature = &config.Temperature
	}
	if topP == nil {
		topP = &config.TopP
	}

	var reservedOutputTokens int
	if m.ReservedOutputTokens != nil {
		reservedOutputTokens = *m.ReservedOutputTokens
	}

	return ModelRoleConfig{
		Role: role,

		ModelId: m.ModelId,

		Temperature:          *temperature,
		TopP:                 *topP,
		ReservedOutputTokens: reservedOutputTokens,

		LargeContextFallback: largeContextFallback,
		LargeOutputFallback:  largeOutputFallback,
		ErrorFallback:        errorFallback,
		StrongModel:          strongModel,
	}
}

func (m *ModelRoleConfigSchema) MarshalJSON() ([]byte, error) {
	if m == nil {
		return []byte("null"), nil
	}
	if m.bareRole() {
		if m.ModelId == "" {
			return []byte("null"), nil
		}

		return json.Marshal(string(m.ModelId)) // compact form
	}
	type alias ModelRoleConfigSchema
	return json.Marshal((*alias)(m)) // full object
}

func (m *ModelRoleConfigSchema) UnmarshalJSON(data []byte) error {
	// attempt the short string first
	var s string
	if err := json.Unmarshal(data, &s); err == nil {
		*m = ModelRoleConfigSchema{ModelId: ModelId(s)}
		return nil
	}
	// fallback to full object
	type alias ModelRoleConfigSchema
	return json.Unmarshal(data, (*alias)(m))
}

func (m *ModelRoleConfig) ToModelRoleConfigSchema() ModelRoleConfigSchema {
	var largeContextFallback *ModelRoleConfigSchema
	if m.LargeContextFallback != nil {
		c := m.LargeContextFallback.ToModelRoleConfigSchema()
		largeContextFallback = &c
	}
	var largeOutputFallback *ModelRoleConfigSchema
	if m.LargeOutputFallback != nil {
		c := m.LargeOutputFallback.ToModelRoleConfigSchema()
		largeOutputFallback = &c
	}
	var errorFallback *ModelRoleConfigSchema
	if m.ErrorFallback != nil {
		c := m.ErrorFallback.ToModelRoleConfigSchema()
		errorFallback = &c
	}
	var strongModel *ModelRoleConfigSchema
	if m.StrongModel != nil {
		c := m.StrongModel.ToModelRoleConfigSchema()
		strongModel = &c
	}

	defaultConfig := DefaultConfigByRole[m.Role]

	var temperature *float32
	var topP *float32
	var reservedOutputTokens *int

	if m.Temperature != defaultConfig.Temperature {
		temperature = &m.Temperature
	}
	if m.TopP != defaultConfig.TopP {
		topP = &m.TopP
	}

	if m.ReservedOutputTokens != 0 {
		reservedOutputTokens = &m.ReservedOutputTokens
	}

	return ModelRoleConfigSchema{
		ModelId:              m.GetModelId(),
		Temperature:          temperature,
		TopP:                 topP,
		ReservedOutputTokens: reservedOutputTokens,
		LargeContextFallback: largeContextFallback,
		LargeOutputFallback:  largeOutputFallback,
		ErrorFallback:        errorFallback,
		StrongModel:          strongModel,
	}
}

func (p PlannerRoleConfig) ToModelRoleConfigSchema() ModelRoleConfigSchema {
	s := p.ModelRoleConfig.ToModelRoleConfigSchema()

	var maxConvoTokens *int
	if p.MaxConvoTokens != 0 {
		maxConvoTokens = &p.MaxConvoTokens
	}

	s.MaxConvoTokens = maxConvoTokens
	return s
}

func (m ModelRoleConfig) GetModelId() ModelId {
	if m.BaseModelConfig != nil {
		return m.BaseModelConfig.ModelId
	}

	return m.ModelId
}

func (m ModelRoleConfig) GetBaseModelConfig(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *BaseModelConfig {
	foundProvider := m.GetFirstProviderForAuthVars(authVars, settings, orgUserConfig)
	if foundProvider == nil {
		return nil
	}

	return m.GetBaseModelConfigForProvider(authVars, settings, foundProvider)
}

func (m ModelRoleConfig) GetBaseModelConfigForProvider(authVars map[string]string, settings *PlanSettings, providerSchema *ModelProviderConfigSchema) *BaseModelConfig {
	if m.BaseModelConfig != nil {
		return m.BaseModelConfig
	}

	availableModel := GetAvailableModel(providerSchema.Provider, m.ModelId)
	if availableModel != nil {
		c := availableModel.BaseModelConfig
		return &c
	}

	var customModel *CustomModel
	if settings != nil {
		customModel = settings.CustomModelsById[m.ModelId]
	}
	if customModel != nil {
		c := customModel.ToBaseModelConfigForProvider(authVars, settings, providerSchema)
		return c
	}

	return nil
}

func (m ModelRoleConfig) GetProviderComposite(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) string {
	baseModelConfig := m.GetBaseModelConfig(authVars, settings, orgUserConfig)

	if baseModelConfig == nil {
		return ""
	}

	return baseModelConfig.ToComposite()
}

func (m ModelRoleConfig) GetReservedOutputTokens(customModelsById map[ModelId]*CustomModel) int {
	if m.ReservedOutputTokens > 0 {
		return m.ReservedOutputTokens
	}

	sharedBaseConfig := m.GetSharedBaseConfigWithCustomModels(customModelsById)
	return sharedBaseConfig.ReservedOutputTokens
}

func (m ModelRoleConfig) GetSharedBaseConfig(settings *PlanSettings) *BaseModelShared {
	return m.GetSharedBaseConfigWithCustomModels(settings.CustomModelsById)
}

func (m ModelRoleConfig) GetSharedBaseConfigWithCustomModels(customModels map[ModelId]*CustomModel) *BaseModelShared {
	if m.BaseModelConfig != nil {
		return &m.BaseModelConfig.BaseModelShared
	}

	builtInModel := BuiltInBaseModelsById[m.ModelId]
	if builtInModel != nil {
		return &builtInModel.BaseModelShared
	}

	customModel := customModels[m.ModelId]
	if customModel != nil {
		return &customModel.BaseModelShared
	}

	return nil
}

func (m *ModelRoleConfig) Scan(src interface{}) error {
	if src == nil {
		return nil
	}
	switch s := src.(type) {
	case []byte:
		return json.Unmarshal(s, m)
	case string:
		return json.Unmarshal([]byte(s), m)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (m ModelRoleConfig) Value() (driver.Value, error) {
	return json.Marshal(m)
}

type PlannerRoleConfig struct {
	ModelRoleConfig
	PlannerModelConfig
}

func (p *PlannerRoleConfig) Scan(src interface{}) error {
	if src == nil {
		return nil
	}
	switch s := src.(type) {
	case []byte:
		return json.Unmarshal(s, p)
	case string:
		return json.Unmarshal([]byte(s), p)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (p PlannerRoleConfig) Value() (driver.Value, error) {
	return json.Marshal(p)
}

func (p PlannerRoleConfig) GetMaxConvoTokens(settings *PlanSettings) int {
	if p.MaxConvoTokens > 0 {
		return p.MaxConvoTokens
	}

	return p.ModelRoleConfig.GetSharedBaseConfig(settings).DefaultMaxConvoTokens
}

type RoleJSON any

type ClientModelPackSchemaRoles struct {
	SchemaUrl SchemaUrl `json:"$schema,omitempty"`

	LocalProvider ModelProvider `json:"localProvider,omitempty"`

	// in the JSON, these can either be a role as a string or a ModelRoleConfigSchema object for more complex config
	Planner          RoleJSON `json:"planner"`
	Architect        RoleJSON `json:"architect,omitempty"`
	Coder            RoleJSON `json:"coder,omitempty"`
	PlanSummary      RoleJSON `json:"summarizer"`
	Builder          RoleJSON `json:"builder"`
	WholeFileBuilder RoleJSON `json:"wholeFileBuilder,omitempty"`
	Namer            RoleJSON `json:"names"`
	CommitMsg        RoleJSON `json:"commitMessages"`
	ExecStatus       RoleJSON `json:"autoContinue"`
}

func (c *ClientModelPackSchemaRoles) ToModelPackSchemaRoles() ModelPackSchemaRoles {
	res := ModelPackSchemaRoles{
		LocalProvider: c.LocalProvider,
	}

	var convertField func(field interface{}) *ModelRoleConfigSchema
	convertField = func(field interface{}) *ModelRoleConfigSchema {
		if field == nil {
			return nil
		}

		switch v := field.(type) {
		case string:
			// It's a string, handle accordingly
			return &ModelRoleConfigSchema{
				ModelId: ModelId(v),
			}
		case map[string]any:
			// re-marshal then unmarshal into the right struct
			b, _ := json.Marshal(v)
			var m ModelRoleConfigSchema
			if err := json.Unmarshal(b, &m); err != nil {
				return nil
			}

			// Now handle the fallback fields recursively
			if fallback, ok := v["largeContextFallback"]; ok && fallback != nil {
				m.LargeContextFallback = convertField(fallback)
			}
			if fallback, ok := v["largeOutputFallback"]; ok && fallback != nil {
				m.LargeOutputFallback = convertField(fallback)
			}
			if fallback, ok := v["errorFallback"]; ok && fallback != nil {
				m.ErrorFallback = convertField(fallback)
			}
			if fallback, ok := v["strongModel"]; ok && fallback != nil {
				m.StrongModel = convertField(fallback)
			}

			return &m
		default:
			// Handle unexpected type - you might want to log or panic
			// Or try to convert from a map if it's coming from JSON
			return nil
		}
	}

	// Convert each field
	res.Planner = *convertField(c.Planner)
	if c.Coder != nil {
		converted := convertField(c.Coder)
		res.Coder = converted
	}
	res.PlanSummary = *convertField(c.PlanSummary)
	res.Builder = *convertField(c.Builder)
	if c.WholeFileBuilder != nil {
		converted := convertField(c.WholeFileBuilder)
		res.WholeFileBuilder = converted
	}
	res.Namer = *convertField(c.Namer)
	res.CommitMsg = *convertField(c.CommitMsg)
	res.ExecStatus = *convertField(c.ExecStatus)
	if c.Architect != nil {
		converted := convertField(c.Architect)
		res.Architect = converted
	}

	return res
}

type ModelPackSchemaRoles struct {
	LocalProvider    ModelProvider          `json:"localProvider,omitempty"`
	Planner          ModelRoleConfigSchema  `json:"planner"`
	Coder            *ModelRoleConfigSchema `json:"coder,omitempty"`
	PlanSummary      ModelRoleConfigSchema  `json:"planSummary"`
	Builder          ModelRoleConfigSchema  `json:"builder"`
	WholeFileBuilder *ModelRoleConfigSchema `json:"wholeFileBuilder,omitempty"` // optional, defaults to builder model — access via GetWholeFileBuilder()
	Namer            ModelRoleConfigSchema  `json:"namer"`
	CommitMsg        ModelRoleConfigSchema  `json:"commitMsg"`
	ExecStatus       ModelRoleConfigSchema  `json:"execStatus"`
	Architect        *ModelRoleConfigSchema `json:"contextLoader,omitempty"`
}

func (m *ModelPackSchemaRoles) ToClientModelPackSchemaRoles() ClientModelPackSchemaRoles {
	res := ClientModelPackSchemaRoles{
		SchemaUrl:     SchemaUrlInlineModelPack,
		LocalProvider: m.LocalProvider,
	}

	res.Planner = m.Planner.ToClientVal()
	if m.Coder != nil {
		val := m.Coder.ToClientVal()
		res.Coder = &val
	}
	res.PlanSummary = m.PlanSummary.ToClientVal()
	res.Builder = m.Builder.ToClientVal()
	if m.WholeFileBuilder != nil {
		val := m.WholeFileBuilder.ToClientVal()
		res.WholeFileBuilder = &val
	}
	res.Namer = m.Namer.ToClientVal()
	res.CommitMsg = m.CommitMsg.ToClientVal()
	res.ExecStatus = m.ExecStatus.ToClientVal()
	if m.Architect != nil {
		val := m.Architect.ToClientVal()
		res.Architect = &val
	}

	return res
}

type ModelPackSchema struct {
	Name        string `json:"name"`
	Description string `json:"description"`

	ModelPackSchemaRoles
}

func (m *ModelPackSchema) AllModelIds() []ModelId {
	ids := []ModelId{}

	ids = append(ids, m.Planner.AllModelIds()...)

	if m.Coder != nil {
		ids = append(ids, m.Coder.AllModelIds()...)
	}

	ids = append(ids, m.PlanSummary.AllModelIds()...)
	ids = append(ids, m.Builder.AllModelIds()...)

	if m.WholeFileBuilder != nil {
		ids = append(ids, m.WholeFileBuilder.AllModelIds()...)
	}

	ids = append(ids, m.Namer.AllModelIds()...)
	ids = append(ids, m.CommitMsg.AllModelIds()...)
	ids = append(ids, m.ExecStatus.AllModelIds()...)

	if m.Architect != nil {
		ids = append(ids, m.Architect.AllModelIds()...)
	}

	return ids
}

func (m *ModelPackSchema) ToModelPack() ModelPack {
	var (
		coder            *ModelRoleConfig
		wholeFileBuilder *ModelRoleConfig
		architect        *ModelRoleConfig
	)

	if m.Coder != nil {
		c := m.Coder.ToModelRoleConfig(ModelRoleCoder)
		coder = &c
	}

	if m.WholeFileBuilder != nil {
		c := m.WholeFileBuilder.ToModelRoleConfig(ModelRoleWholeFileBuilder)
		wholeFileBuilder = &c
	}

	if m.Architect != nil {
		c := m.Architect.ToModelRoleConfig(ModelRoleArchitect)
		architect = &c
	}

	var maxConvoTokens int
	if m.Planner.MaxConvoTokens != nil {
		maxConvoTokens = *m.Planner.MaxConvoTokens
	}

	return ModelPack{
		Name:          m.Name,
		Description:   m.Description,
		LocalProvider: m.LocalProvider,
		Planner: PlannerRoleConfig{
			ModelRoleConfig: m.Planner.ToModelRoleConfig(ModelRolePlanner),
			PlannerModelConfig: PlannerModelConfig{
				MaxConvoTokens: maxConvoTokens,
			},
		},
		Coder:            coder,
		PlanSummary:      m.PlanSummary.ToModelRoleConfig(ModelRolePlanSummary),
		Builder:          m.Builder.ToModelRoleConfig(ModelRoleBuilder),
		WholeFileBuilder: wholeFileBuilder,
		Namer:            m.Namer.ToModelRoleConfig(ModelRoleName),
		CommitMsg:        m.CommitMsg.ToModelRoleConfig(ModelRoleCommitMsg),
		ExecStatus:       m.ExecStatus.ToModelRoleConfig(ModelRoleExecStatus),
		Architect:        architect,
	}
}

type ModelPack struct {
	Id               string            `json:"id"`
	Name             string            `json:"name"`
	LocalProvider    ModelProvider     `json:"localProvider,omitempty"`
	Description      string            `json:"description"`
	Planner          PlannerRoleConfig `json:"planner"`
	Coder            *ModelRoleConfig  `json:"coder"`
	PlanSummary      ModelRoleConfig   `json:"planSummary"`
	Builder          ModelRoleConfig   `json:"builder"`
	WholeFileBuilder *ModelRoleConfig  `json:"wholeFileBuilder"` // optional, defaults to builder model — access via GetWholeFileBuilder()
	Namer            ModelRoleConfig   `json:"namer"`
	CommitMsg        ModelRoleConfig   `json:"commitMsg"`
	ExecStatus       ModelRoleConfig   `json:"execStatus"`
	Architect        *ModelRoleConfig  `json:"contextLoader"`
}

func (m *ModelPack) GetCoder() ModelRoleConfig {
	if m.Coder == nil {
		return m.Planner.ModelRoleConfig
	}
	return *m.Coder
}

func (m *ModelPack) GetWholeFileBuilder() ModelRoleConfig {
	if m.WholeFileBuilder == nil {
		return m.Builder
	}
	return *m.WholeFileBuilder
}

func (m *ModelPack) GetArchitect() ModelRoleConfig {
	if m.Architect == nil {
		return m.Planner.ModelRoleConfig
	}
	return *m.Architect
}

func (m *ModelPack) ToModelPackSchema() *ModelPackSchema {
	var coder *ModelRoleConfigSchema
	if m.Coder != nil {
		c := m.Coder.ToModelRoleConfigSchema()
		coder = &c
	}
	var wholeFileBuilder *ModelRoleConfigSchema
	if m.WholeFileBuilder != nil {
		c := m.WholeFileBuilder.ToModelRoleConfigSchema()
		wholeFileBuilder = &c
	}
	var architect *ModelRoleConfigSchema
	if m.Architect != nil {
		c := m.Architect.ToModelRoleConfigSchema()
		architect = &c
	}

	return &ModelPackSchema{
		Name:        m.Name,
		Description: m.Description,
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			LocalProvider:    m.LocalProvider,
			Planner:          m.Planner.ToModelRoleConfigSchema(),
			Coder:            coder,
			Architect:        architect,
			PlanSummary:      m.PlanSummary.ToModelRoleConfigSchema(),
			Builder:          m.Builder.ToModelRoleConfigSchema(),
			WholeFileBuilder: wholeFileBuilder,
			Namer:            m.Namer.ToModelRoleConfigSchema(),
			CommitMsg:        m.CommitMsg.ToModelRoleConfigSchema(),
			ExecStatus:       m.ExecStatus.ToModelRoleConfigSchema(),
		},
	}
}

func (m ModelPackSchemaRoles) Hash() (string, error) {
	bytes, err := json.Marshal(m)
	if err != nil {
		return "", err
	}
	hash := sha256.Sum256(bytes)
	return hex.EncodeToString(hash[:]), nil
}


================================================
FILE: app/shared/ai_models_errors.go
================================================
package shared

import (
	"log"

	"github.com/davecgh/go-spew/spew"
	"github.com/jinzhu/copier"
)

type ModelErrKind string

const (
	ErrOverloaded                 ModelErrKind = "ErrOverloaded"
	ErrContextTooLong             ModelErrKind = "ErrContextTooLong"
	ErrRateLimited                ModelErrKind = "ErrRateLimited"
	ErrSubscriptionQuotaExhausted ModelErrKind = "ErrSubscriptionQuotaExhausted"
	ErrOther                      ModelErrKind = "ErrOther"
	ErrCacheSupport               ModelErrKind = "ErrCacheSupport"
)

type ModelError struct {
	Kind              ModelErrKind
	Retriable         bool
	RetryAfterSeconds int
}

func (m ModelError) ShouldIncrementRetry() bool {
	return m.Kind != ErrSubscriptionQuotaExhausted && m.Kind != ErrCacheSupport
}

// if fallback is defined, retry with main model, then remaining tries use error fallback
type FallbackType string

const (
	FallbackTypeError    FallbackType = "error"
	FallbackTypeContext  FallbackType = "context"
	FallbackTypeProvider FallbackType = "provider"
)

type FallbackResult struct {
	ModelRoleConfig *ModelRoleConfig
	IsFallback      bool
	FallbackType    FallbackType
	BaseModelConfig *BaseModelConfig
}

const MAX_RETRIES_BEFORE_FALLBACK = 1

func (m *ModelRoleConfig) GetFallbackForModelError(
	numTotalRetry int,
	didProviderFallback bool,
	modelErr *ModelError,
	authVars map[string]string,
	settings *PlanSettings,
	orgUserConfig *OrgUserConfig,
) FallbackResult {
	if m == nil || modelErr == nil {
		return FallbackResult{
			ModelRoleConfig: m,
			BaseModelConfig: m.GetBaseModelConfig(authVars, settings, orgUserConfig),
			IsFallback:      false,
		}
	}
	if modelErr.Kind == ErrContextTooLong {
		if m.LargeContextFallback != nil {
			return FallbackResult{
				ModelRoleConfig: m.LargeContextFallback,
				BaseModelConfig: m.LargeContextFallback.GetBaseModelConfig(authVars, settings, orgUserConfig),
				FallbackType:    FallbackTypeContext,
				IsFallback:      true,
			}
		}
	} else if !modelErr.Retriable || numTotalRetry > MAX_RETRIES_BEFORE_FALLBACK {
		if m.ErrorFallback != nil {
			return FallbackResult{
				ModelRoleConfig: m.ErrorFallback,
				BaseModelConfig: m.ErrorFallback.GetBaseModelConfig(authVars, settings, orgUserConfig),
				FallbackType:    FallbackTypeError,
				IsFallback:      true,
			}
		} else if !didProviderFallback {
			log.Println("no error fallback, trying provider fallback")

			providerFallback := m.GetProviderFallback(authVars, settings, orgUserConfig)

			log.Println(spew.Sdump(map[string]interface{}{
				"providerFallback": providerFallback,
			}))

			if providerFallback != nil {
				return FallbackResult{
					ModelRoleConfig: providerFallback,
					BaseModelConfig: providerFallback.GetBaseModelConfig(authVars, settings, orgUserConfig),
					FallbackType:    FallbackTypeProvider,
					IsFallback:      true,
				}
			}
		}
	}

	return FallbackResult{
		ModelRoleConfig: m,
		IsFallback:      false,
	}
}

// we just try a single provider fallback if all defined fallbacks are exhausted
// if we've got openrouter credentials in the stack, we always use OpenRouter as the fallback since it has its own routing/fallback routing to maximize resilience
// otherwise we just use the second provider in the stack
// if we're using the claude subscription, we also go to second provider in the stack rather than openrouter
func (m ModelRoleConfig) GetProviderFallback(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *ModelRoleConfig {
	providers := m.GetProvidersForAuthVars(authVars, settings, orgUserConfig)

	if len(providers) < 2 {
		return nil
	}

	firstProvider := providers[0]

	res := ModelRoleConfig{}
	copier.Copy(&res, m)

	var provider ModelProvider

	if !firstProvider.HasClaudeMaxAuth {
		for _, p := range providers {
			if p.Provider == ModelProviderOpenRouter {
				provider = p.Provider
				break
			}
		}
	}

	if provider == "" {
		provider = providers[1].Provider
	}

	availableModel := GetAvailableModel(provider, m.ModelId)

	if availableModel != nil {
		c := availableModel.BaseModelConfig
		res.BaseModelConfig = &c
	} else {
		c := m.GetBaseModelConfig(authVars, settings, orgUserConfig)
		res.BaseModelConfig = c
	}

	return &res
}


================================================
FILE: app/shared/ai_models_large_context.go
================================================
package shared

const maxFallbackDepth = 10 // max fallback depth for large context fallback - should never be reached in real scenarios, but protects against infinite loops in case of circular references etc.

func (m ModelRoleConfig) GetFinalLargeContextFallback() ModelRoleConfig {
	var currentConfig ModelRoleConfig = m
	var n int = 0

	for {
		if currentConfig.LargeContextFallback == nil {
			return currentConfig
		} else {
			currentConfig = *currentConfig.LargeContextFallback
		}
		n++
		if n > maxFallbackDepth {
			break
		}
	}

	return currentConfig
}

func (m ModelRoleConfig) GetFinalLargeOutputFallback() ModelRoleConfig {
	var currentConfig ModelRoleConfig = m
	var n int = 0

	if currentConfig.LargeOutputFallback == nil {
		return currentConfig.GetFinalLargeContextFallback()
	}

	for {
		if currentConfig.LargeOutputFallback == nil {
			return currentConfig
		} else {
			currentConfig = *currentConfig.LargeOutputFallback
		}
		n++
		if n > maxFallbackDepth {
			break
		}
	}

	return currentConfig
}

// note that if the token number exeeds all the fallback models, it will return the last fallback model

func (m ModelRoleConfig) GetRoleForInputTokens(inputTokens int, settings *PlanSettings) ModelRoleConfig {
	var maxTokens int
	var paddingPct float64

	sharedBaseConfig := m.GetSharedBaseConfig(settings)
	maxTokens = sharedBaseConfig.MaxTokens
	paddingPct = sharedBaseConfig.TokenEstimatePaddingPct

	inputTokens = int(float64(inputTokens) * (1 + paddingPct))
	var currentConfig ModelRoleConfig = m
	var n int = 0
	for {
		if maxTokens >= inputTokens {
			return currentConfig
		}

		if currentConfig.LargeContextFallback == nil {
			return currentConfig
		} else {
			currentConfig = *currentConfig.LargeContextFallback
		}
		n++
		if n > maxFallbackDepth {
			break
		}
	}
	return currentConfig
}

func (m ModelRoleConfig) GetRoleForOutputTokens(outputTokens int, settings *PlanSettings) ModelRoleConfig {
	sharedBaseConfig := m.GetSharedBaseConfig(settings)

	outputTokens = int(float64(outputTokens) * (1 + sharedBaseConfig.TokenEstimatePaddingPct))
	var currentConfig ModelRoleConfig = m

	customModelsById := map[ModelId]*CustomModel{}
	if settings != nil {
		customModelsById = settings.CustomModelsById
	}

	var n int = 0
	for {
		if currentConfig.GetReservedOutputTokens(customModelsById) >= outputTokens {
			return currentConfig
		}

		if currentConfig.LargeOutputFallback == nil {
			if currentConfig.LargeContextFallback == nil {
				return currentConfig
			} else {
				currentConfig = *currentConfig.LargeContextFallback
			}
		} else {
			currentConfig = *currentConfig.LargeOutputFallback
		}
		n++
		if n > maxFallbackDepth {
			break
		}
	}
	return currentConfig
}


================================================
FILE: app/shared/ai_models_openrouter.go
================================================
package shared

type OpenRouterFamily string

const (
	OpenRouterFamilyAnthropic OpenRouterFamily = "anthropic"
	OpenRouterFamilyGoogle    OpenRouterFamily = "google"
	OpenRouterFamilyOpenAI    OpenRouterFamily = "openai"
	OpenRouterFamilyQwen      OpenRouterFamily = "qwen"
	OpenRouterFamilyDeepSeek  OpenRouterFamily = "deepseek"
)

// type OpenRouterProvider string

// const (
// 	OpenRouterProviderAnthropic OpenRouterProvider = "Anthropic"
// 	OpenRouterProviderGoogle    OpenRouterProvider = "Google Vertex"
// 	OpenRouterProviderOpenAI    OpenRouterProvider = "OpenAI"
// 	OpenRouterProviderDeepSeek  OpenRouterProvider = "DeepSeek"
// 	OpenRouterProviderQwen      OpenRouterProvider = "Hyperbolic"
// 	OpenRouterProviderDeepInfra OpenRouterProvider = "DeepInfra"
// 	OpenRouterProviderFireworks OpenRouterProvider = "Fireworks"
// )

// var DefaultOpenRouterProvidersByFamily = map[OpenRouterFamily][]OpenRouterProvider{
// 	OpenRouterFamilyAnthropic: {OpenRouterProviderAnthropic},
// 	OpenRouterFamilyGoogle:    {OpenRouterProviderGoogle},
// 	OpenRouterFamilyOpenAI:    {OpenRouterProviderOpenAI},
// 	OpenRouterFamilyQwen:      {OpenRouterProviderQwen},
// 	OpenRouterFamilyDeepSeek:  {OpenRouterProviderDeepSeek},
// }

// // open source models don't have fallbacks enabled for now because pricing and context limits aren't predictable across providers
// var DefaultOpenRouterAllowFallbacksByFamily = map[OpenRouterFamily]bool{
// 	OpenRouterFamilyAnthropic: true,
// 	OpenRouterFamilyGoogle:    true,
// 	OpenRouterFamilyOpenAI:    false,
// }


================================================
FILE: app/shared/ai_models_packs.go
================================================
package shared

var DailyDriverModelPack ModelPack
var ReasoningModelPack ModelPack
var StrongModelPack ModelPack
var OSSModelPack ModelPack
var CheapModelPack ModelPack

var OpusPlannerModelPack ModelPack

var AnthropicModelPack ModelPack
var OpenAIModelPack ModelPack
var GoogleModelPack ModelPack

var GeminiPlannerModelPack ModelPack
var O3PlannerModelPack ModelPack
var R1PlannerModelPack ModelPack
var PerplexityPlannerModelPack ModelPack

var OllamaExperimentalModelPack ModelPack
var OllamaAdaptiveOssModelPack ModelPack
var OllamaAdaptiveDailyModelPack ModelPack

var BuiltInModelPacks = []*ModelPack{
	&DailyDriverModelPack,
	&ReasoningModelPack,
	&StrongModelPack,
	&CheapModelPack,
	&OSSModelPack,
	&OllamaExperimentalModelPack,
	&OllamaAdaptiveOssModelPack,
	&OllamaAdaptiveDailyModelPack,
	&AnthropicModelPack,
	&OpenAIModelPack,
	&GoogleModelPack,
	&GeminiPlannerModelPack,
	&OpusPlannerModelPack,
	&O3PlannerModelPack,
	&R1PlannerModelPack,
	&PerplexityPlannerModelPack,
}

var BuiltInModelPacksByName = make(map[string]*ModelPack)

var DefaultModelPack *ModelPack = &DailyDriverModelPack

func getModelRoleConfig(role ModelRole, modelId ModelId, fns ...func(*ModelRoleConfigSchema)) ModelRoleConfigSchema {
	c := ModelRoleConfigSchema{
		ModelId: modelId,
	}
	for _, f := range fns {
		f(&c)
	}
	return c
}

func getLargeContextFallback(role ModelRole, modelId ModelId, fns ...func(*ModelRoleConfigSchema)) func(*ModelRoleConfigSchema) {
	return func(c *ModelRoleConfigSchema) {
		n := getModelRoleConfig(role, modelId)
		for _, f := range fns {
			f(&n)
		}
		c.LargeContextFallback = &n
	}
}

func getErrorFallback(role ModelRole, modelId ModelId, fns ...func(*ModelRoleConfigSchema)) func(*ModelRoleConfigSchema) {
	return func(c *ModelRoleConfigSchema) {
		n := getModelRoleConfig(role, modelId)
		for _, f := range fns {
			f(&n)
		}
		c.ErrorFallback = &n
	}
}

func getStrongModelFallback(role ModelRole, modelId ModelId, fns ...func(*ModelRoleConfigSchema)) func(*ModelRoleConfigSchema) {
	return func(c *ModelRoleConfigSchema) {
		n := getModelRoleConfig(role, modelId)
		for _, f := range fns {
			f(&n)
		}
		c.StrongModel = &n
	}
}

var (
	DailyDriverSchema         ModelPackSchema
	ReasoningSchema           ModelPackSchema
	StrongSchema              ModelPackSchema
	OssSchema                 ModelPackSchema
	CheapSchema               ModelPackSchema
	OllamaExperimentalSchema  ModelPackSchema
	OllamaAdaptiveOssSchema   ModelPackSchema
	OllamaAdaptiveDailySchema ModelPackSchema
	AnthropicSchema           ModelPackSchema
	OpenAISchema              ModelPackSchema
	GoogleSchema              ModelPackSchema
	GeminiPlannerSchema       ModelPackSchema
	OpusPlannerSchema         ModelPackSchema
	R1PlannerSchema           ModelPackSchema
	PerplexityPlannerSchema   ModelPackSchema
	O3PlannerSchema           ModelPackSchema
)

var BuiltInModelPackSchemas = []*ModelPackSchema{
	&DailyDriverSchema,
	&ReasoningSchema,
	&StrongSchema,
	&CheapSchema,
	&OssSchema,
	&OllamaExperimentalSchema,
	&OllamaAdaptiveOssSchema,
	&OllamaAdaptiveDailySchema,
	&AnthropicSchema,
	&OpenAISchema,
	&GeminiPlannerSchema,
	&OpusPlannerSchema,
	&O3PlannerSchema,
	&R1PlannerSchema,
	&PerplexityPlannerSchema,
}

func init() {
	defaultBuilder := getModelRoleConfig(ModelRoleBuilder, "openai/o4-mini-medium",
		getStrongModelFallback(ModelRoleBuilder, "openai/o4-mini-high"),
	)

	DailyDriverSchema = ModelPackSchema{
		Name:        "daily-driver",
		Description: "A mix of models from Anthropic, OpenAI, and Google that balances speed, quality, and cost. Supports up to 2M context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner: getModelRoleConfig(ModelRolePlanner, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRolePlanner, "google/gemini-2.5-pro",
					getLargeContextFallback(ModelRolePlanner, "google/gemini-pro-1.5"),
				),
			),
			Architect: Pointer(getModelRoleConfig(ModelRoleArchitect, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleArchitect, "google/gemini-2.5-pro",
					getLargeContextFallback(ModelRoleArchitect, "google/gemini-pro-1.5"),
				),
			)),
			Coder: Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleCoder, "openai/gpt-4.1"),
			)),
			PlanSummary:      getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:          defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder, "openai/o4-mini-medium")),
			Namer:            getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:        getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus:       getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	ReasoningSchema = ModelPackSchema{
		Name:        "reasoning",
		Description: "Like the daily driver, but uses sonnet-4-thinking with reasoning enabled for planning and coding. Supports up to 160k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "anthropic/claude-sonnet-4-thinking-hidden"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4-thinking-hidden")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	StrongSchema = ModelPackSchema{
		Name:        "strong",
		Description: "For difficult tasks where slower responses and builds are ok. Uses o3-high for architecture and planning, claude-sonnet-4 thinking for implementation. Supports up to 160k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "openai/o3-high"),
			Architect:   Pointer(getModelRoleConfig(ModelRoleArchitect, "openai/o3-high")),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4-thinking-hidden")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "openai/o4-mini-high"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-high")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-medium"),
		},
	}

	CheapSchema = ModelPackSchema{
		Name:        "cheap",
		Description: "Cost-effective models that can still get the job done for easier tasks. Supports up to 160k context. Uses OpenAI's o4-mini model for planning, GPT-4.1 for coding, and GPT-4.1 Mini for lighter tasks.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "openai/o4-mini-medium"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "openai/gpt-4.1")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/gpt-4.1-mini"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "openai/o4-mini-low"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-low")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	OssSchema = ModelPackSchema{
		Name:        "oss",
		Description: "An experimental mix of the best open source models for coding. Supports up to 144k context, 33k per file.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "deepseek/r1"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "deepseek/v3")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "deepseek/r1-hidden"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "deepseek/r1-hidden"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"deepseek/r1-hidden")),
			Namer:      getModelRoleConfig(ModelRoleName, "qwen/qwen3-8b-cloud"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "qwen/qwen3-8b-cloud"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "deepseek/r1-hidden"),
		},
	}

	OllamaExperimentalSchema = ModelPackSchema{
		Name:        "ollama",
		Description: "Ollama experimental local blend. Supports up to 110k context. For now, more for experimentation and benchmarking than getting work done.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			LocalProvider: ModelProviderOllama,
			Planner:       getModelRoleConfig(ModelRolePlanner, "qwen/qwen3-32b-local"),
			PlanSummary:   getModelRoleConfig(ModelRolePlanSummary, "mistral/devstral-small"),
			Builder:       getModelRoleConfig(ModelRoleBuilder, "mistral/devstral-small"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"mistral/devstral-small")),
			Namer:      getModelRoleConfig(ModelRoleName, "qwen/qwen3-8b-local"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "qwen/qwen3-8b-local"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "mistral/devstral-small"),
		},
	}

	// Copy daily driver schema and modify it to use ollama for lighter tasks
	OllamaAdaptiveDailySchema = cloneSchema(DailyDriverSchema)
	OllamaAdaptiveDailySchema.Name = "ollama-daily"
	OllamaAdaptiveDailySchema.Description = "Ollama adaptive/daily-driver blend. Uses 'daily-driver' for heavy lifting, local models for lighter tasks."
	OllamaAdaptiveDailySchema.LocalProvider = ModelProviderOllama
	OllamaAdaptiveDailySchema.PlanSummary = getModelRoleConfig(ModelRolePlanSummary, "mistral/devstral-small")
	OllamaAdaptiveDailySchema.CommitMsg = getModelRoleConfig(ModelRoleCommitMsg, "qwen/qwen3-8b-local")
	OllamaAdaptiveDailySchema.Namer = getModelRoleConfig(ModelRoleName, "qwen/qwen3-8b-local")

	// Copy oss schema and modify it to use ollama for lighter tasks
	OllamaAdaptiveOssSchema = cloneSchema(OssSchema)
	OllamaAdaptiveOssSchema.Name = "ollama-oss"
	OllamaAdaptiveOssSchema.Description = "Ollama adaptive/oss blend. Uses local models for planning and context selection, open source cloud models for implementation and file edits. Supports up to 110k context."
	OllamaAdaptiveOssSchema.LocalProvider = ModelProviderOllama
	OllamaAdaptiveOssSchema.PlanSummary = getModelRoleConfig(ModelRolePlanSummary, "mistral/devstral-small")
	OllamaAdaptiveOssSchema.CommitMsg = getModelRoleConfig(ModelRoleCommitMsg, "qwen/qwen3-8b-local")
	OllamaAdaptiveOssSchema.Namer = getModelRoleConfig(ModelRoleName, "qwen/qwen3-8b-local")

	OpenAISchema = ModelPackSchema{
		Name:        "openai",
		Description: "OpenAI blend. Supports up to 1M context. Uses OpenAI's GPT-4.1 model for heavy lifting, GPT-4.1 Mini for lighter tasks.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "openai/gpt-4.1"),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	AnthropicSchema = ModelPackSchema{
		Name:        "anthropic",
		Description: "Anthropic blend. Supports up to 180k context. Uses Claude Sonnet 4 for heavy lifting, Claude 3 Haiku for lighter tasks.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "anthropic/claude-sonnet-4"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "anthropic/claude-3.5-haiku"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "anthropic/claude-sonnet-4"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"anthropic/claude-sonnet-4")),
			Namer:      getModelRoleConfig(ModelRoleName, "anthropic/claude-3.5-haiku"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "anthropic/claude-3.5-haiku"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "anthropic/claude-sonnet-4"),
		},
	}

	GoogleSchema = ModelPackSchema{
		Name:        "google",
		Description: "Uses Gemini 2.5 Pro for heavy lifting, 2.5 Flash for light tasks. Supports up to 1M input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "google/gemini-2.5-pro"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "google/gemini-2.5-flash")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "google/gemini-2.5-flash"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "google/gemini-2.5-pro"),
			Namer:       getModelRoleConfig(ModelRoleName, "google/gemini-2.5-flash"),
			CommitMsg:   getModelRoleConfig(ModelRoleCommitMsg, "google/gemini-2.5-flash"),
			ExecStatus:  getModelRoleConfig(ModelRoleExecStatus, "google/gemini-2.5-pro"),
		},
	}

	GeminiPlannerSchema = ModelPackSchema{
		Name:        "gemini-planner",
		Description: "Uses Gemini 2.5 Pro for planning, default models for other roles. Supports up to 1M input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner: getModelRoleConfig(ModelRolePlanner, "google/gemini-2.5-pro"),
			Coder: Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleCoder, "openai/gpt-4.1"),
			)),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	OpusPlannerSchema = ModelPackSchema{
		Name:        "opus-planner",
		Description: "Uses Claude Opus 4 for planning, default models for other roles. Supports up to 180k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner: getModelRoleConfig(ModelRolePlanner, "anthropic/claude-opus-4"),
			Coder: Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleCoder, "openai/gpt-4.1"),
			)),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	O3PlannerSchema = ModelPackSchema{
		Name:        "o3-planner",
		Description: "Uses Claude Opus 4 for planning, default models for other roles. Supports up to 180k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner: getModelRoleConfig(ModelRolePlanner, "anthropic/opus-4"),
			Coder: Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleCoder, "openai/gpt-4.1"),
			)),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	O3PlannerSchema = ModelPackSchema{
		Name:        "o3-planner",
		Description: "Uses OpenAI o3-medium for planning, default models for other roles. Supports up to 160k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner: getModelRoleConfig(ModelRolePlanner, "openai/o3-medium"),
			Coder: Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4",
				getLargeContextFallback(ModelRoleCoder, "openai/gpt-4.1"),
			)),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     defaultBuilder,
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-medium")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-low"),
		},
	}

	R1PlannerSchema = ModelPackSchema{
		Name:        "r1-planner",
		Description: "Uses DeepSeek R1 for planning, Qwen for light tasks, and default models for implementation. Supports up to 56k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "deepseek/r1"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "openai/o4-mini-medium"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-low")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-medium"),
		},
	}

	PerplexityPlannerSchema = ModelPackSchema{
		Name:        "perplexity-planner",
		Description: "Uses Perplexity Sonar for planning, Qwen for light tasks, and default models for implementation. Supports up to 97k input context.",
		ModelPackSchemaRoles: ModelPackSchemaRoles{
			Planner:     getModelRoleConfig(ModelRolePlanner, "perplexity/sonar-reasoning"),
			Coder:       Pointer(getModelRoleConfig(ModelRoleCoder, "anthropic/claude-sonnet-4")),
			PlanSummary: getModelRoleConfig(ModelRolePlanSummary, "openai/o4-mini-low"),
			Builder:     getModelRoleConfig(ModelRoleBuilder, "openai/o4-mini-medium"),
			WholeFileBuilder: Pointer(getModelRoleConfig(ModelRoleWholeFileBuilder,
				"openai/o4-mini-low")),
			Namer:      getModelRoleConfig(ModelRoleName, "openai/gpt-4.1-mini"),
			CommitMsg:  getModelRoleConfig(ModelRoleCommitMsg, "openai/gpt-4.1-mini"),
			ExecStatus: getModelRoleConfig(ModelRoleExecStatus, "openai/o4-mini-medium"),
		},
	}

	DailyDriverModelPack = DailyDriverSchema.ToModelPack()
	ReasoningModelPack = ReasoningSchema.ToModelPack()
	StrongModelPack = StrongSchema.ToModelPack()
	CheapModelPack = CheapSchema.ToModelPack()
	OSSModelPack = OssSchema.ToModelPack()
	OllamaExperimentalModelPack = OllamaExperimentalSchema.ToModelPack()
	OllamaAdaptiveOssModelPack = OllamaAdaptiveOssSchema.ToModelPack()
	OllamaAdaptiveDailyModelPack = OllamaAdaptiveDailySchema.ToModelPack()
	AnthropicModelPack = AnthropicSchema.ToModelPack()
	OpenAIModelPack = OpenAISchema.ToModelPack()
	GoogleModelPack = GoogleSchema.ToModelPack()
	GeminiPlannerModelPack = GeminiPlannerSchema.ToModelPack()
	OpusPlannerModelPack = OpusPlannerSchema.ToModelPack()
	R1PlannerModelPack = R1PlannerSchema.ToModelPack()
	PerplexityPlannerModelPack = PerplexityPlannerSchema.ToModelPack()
	O3PlannerModelPack = O3PlannerSchema.ToModelPack()

	BuiltInModelPacks = []*ModelPack{
		&DailyDriverModelPack,
		&ReasoningModelPack,
		&StrongModelPack,
		&CheapModelPack,
		&OSSModelPack,
		&OllamaExperimentalModelPack,
		&OllamaAdaptiveOssModelPack,
		&OllamaAdaptiveDailyModelPack,
		&AnthropicModelPack,
		&OpenAIModelPack,
		&GoogleModelPack,
		&GeminiPlannerModelPack,
		&OpusPlannerModelPack,
		&O3PlannerModelPack,
		&R1PlannerModelPack,
		&PerplexityPlannerModelPack,
	}

	DefaultModelPack = &DailyDriverModelPack

	for _, mp := range BuiltInModelPacks {
		BuiltInModelPacksByName[mp.Name] = mp

		for _, id := range mp.ToModelPackSchema().AllModelIds() {
			if BuiltInBaseModelsById[id] == nil {
				panic("missing base model: " + id)
			}
		}
	}

}

// pointer fields need to be cloned to avoid modifying the original schema
func cloneSchema(schema ModelPackSchema) ModelPackSchema {
	res := schema

	if schema.Architect != nil {
		tmp := *schema.Architect
		res.Architect = &tmp
	}

	if schema.Coder != nil {
		tmp := *schema.Coder
		res.Coder = &tmp
	}
	if schema.WholeFileBuilder != nil {
		tmp := *schema.WholeFileBuilder
		res.WholeFileBuilder = &tmp
	}

	return res
}


================================================
FILE: app/shared/ai_models_providers.go
================================================
package shared

import (
	"fmt"
)

const OpenAIV1BaseUrl = "https://api.openai.com/v1"
const OpenRouterBaseUrl = "https://openrouter.ai/api/v1"
const LiteLLMBaseUrl = "http://localhost:4000/v1" // runs in the same container alongside the plandex server

const OpenAIEnvVar = "OPENAI_API_KEY"
const OpenRouterApiKeyEnvVar = "OPENROUTER_API_KEY"
const AnthropicApiKeyEnvVar = "ANTHROPIC_API_KEY"
const GoogleAIStudioApiKeyEnvVar = "GEMINI_API_KEY"
const AzureOpenAIEnvVar = "AZURE_OPENAI_API_KEY"
const DeepSeekApiKeyEnvVar = "DEEPSEEK_API_KEY"
const PerplexityApiKeyEnvVar = "PERPLEXITY_API_KEY"

// not set directly via env vars, but used for auth var resolution
const AnthropicClaudeMaxTokenEnvVar = "ANTHROPIC_CLAUDE_MAX_TOKEN"
const AnthropicClaudeMaxBetaHeader = "oauth-2025-04-20"
const LiteLLMAnthropicBaseUrl = "https://api.anthropic.com"

type ModelPublisher string

const (
	ModelPublisherOpenAI     ModelPublisher = "OpenAI"
	ModelPublisherAnthropic  ModelPublisher = "Anthropic"
	ModelPublisherGoogle     ModelPublisher = "Google"
	ModelPublisherDeepSeek   ModelPublisher = "DeepSeek"
	ModelPublisherPerplexity ModelPublisher = "Perplexity"
	ModelPublisherQwen       ModelPublisher = "Qwen"
	ModelPublisherMistral    ModelPublisher = "Mistral"
)

type ModelProvider string

const (
	ModelProviderOpenRouter ModelProvider = "openrouter"
	ModelProviderOpenAI     ModelProvider = "openai"

	ModelProviderAnthropic          ModelProvider = "anthropic"
	ModelProviderAnthropicClaudeMax ModelProvider = "anthropic-pro"
	ModelProviderGoogleAIStudio     ModelProvider = "google-ai-studio"
	ModelProviderGoogleVertex       ModelProvider = "google-vertex"
	ModelProviderAzureOpenAI        ModelProvider = "azure-openai"
	ModelProviderDeepSeek           ModelProvider = "deepseek"
	ModelProviderPerplexity         ModelProvider = "perplexity"

	ModelProviderAmazonBedrock ModelProvider = "aws-bedrock"

	ModelProviderOllama ModelProvider = "ollama"

	ModelProviderCustom ModelProvider = "custom"
)

var ModelProviderToLiteLLMId = map[ModelProvider]string{
	ModelProviderGoogleAIStudio: "gemini",
	ModelProviderGoogleVertex:   "vertex_ai",
	ModelProviderAzureOpenAI:    "azure",
	ModelProviderAmazonBedrock:  "bedrock",
}

var AllModelProviders = []ModelProvider{
	ModelProviderOpenRouter,
	ModelProviderOpenAI,
	ModelProviderAnthropic,
	ModelProviderAnthropicClaudeMax,
	ModelProviderGoogleAIStudio,
	ModelProviderGoogleVertex,
	ModelProviderAzureOpenAI,
	ModelProviderAmazonBedrock,
	ModelProviderDeepSeek,
	ModelProviderPerplexity,
	ModelProviderOllama,
	ModelProviderCustom,
}

type ModelProviderExtraAuthVars struct {
	Var               string `json:"var"`
	MaybeJSONFilePath bool   `json:"maybeJSONFilePath,omitempty"`
	Required          bool   `json:"required,omitempty"`
	Default           string `json:"default,omitempty"`
}

type ModelProviderConfigSchema struct {
	Provider       ModelProvider `json:"provider"`
	CustomProvider *string       `json:"customProvider,omitempty"`
	BaseUrl        string        `json:"baseUrl"`

	// for AWS Bedrock models
	HasAWSAuth bool `json:"hasAWSAuth,omitempty"`

	// for Claude Max integration
	HasClaudeMaxAuth bool `json:"hasClaudeMaxAuth,omitempty"`

	// for local models that don't require auth (ollama, etc.)
	SkipAuth  bool `json:"skipAuth,omitempty"`
	LocalOnly bool `json:"localOnly,omitempty"`

	ApiKeyEnvVar  string                       `json:"apiKeyEnvVar,omitempty"`
	ExtraAuthVars []ModelProviderExtraAuthVars `json:"extraAuthVars,omitempty"`
}

func (m *ModelProviderConfigSchema) ToComposite() string {
	if m.CustomProvider != nil {
		return fmt.Sprintf("%s|%s", m.Provider, *m.CustomProvider)
	}
	return string(m.Provider)
}

const DefaultAzureApiVersion = "2025-04-01-preview"
const AnthropicMaxReasoningBudget = 32000
const GoogleMaxReasoningBudget = 32000

var BuiltInModelProviderConfigs = map[ModelProvider]ModelProviderConfigSchema{
	ModelProviderOpenAI: {
		Provider:     ModelProviderOpenAI,
		BaseUrl:      OpenAIV1BaseUrl,
		ApiKeyEnvVar: OpenAIEnvVar,
		ExtraAuthVars: []ModelProviderExtraAuthVars{
			{
				Var:      "OPENAI_ORG_ID",
				Required: false,
			},
		},
	},
	ModelProviderOpenRouter: {
		Provider:     ModelProviderOpenRouter,
		BaseUrl:      OpenRouterBaseUrl,
		ApiKeyEnvVar: OpenRouterApiKeyEnvVar,
	},
	ModelProviderAnthropic: {
		Provider:     ModelProviderAnthropic,
		BaseUrl:      LiteLLMBaseUrl,
		ApiKeyEnvVar: AnthropicApiKeyEnvVar,
	},
	ModelProviderAnthropicClaudeMax: {
		Provider:         ModelProviderAnthropicClaudeMax,
		BaseUrl:          LiteLLMBaseUrl,
		HasClaudeMaxAuth: true,
	},
	ModelProviderGoogleAIStudio: {
		Provider:     ModelProviderGoogleAIStudio,
		BaseUrl:      LiteLLMBaseUrl,
		ApiKeyEnvVar: GoogleAIStudioApiKeyEnvVar,
	},
	ModelProviderGoogleVertex: {
		Provider: ModelProviderGoogleVertex,
		BaseUrl:  LiteLLMBaseUrl,
		ExtraAuthVars: []ModelProviderExtraAuthVars{
			{
				// this is a file path, but client-side it will be read and then passed along as an auth var just as if it were an env var
				Var:               "GOOGLE_APPLICATION_CREDENTIALS",
				MaybeJSONFilePath: true,
				Required:          true,
			},
			{
				Var:      "VERTEXAI_PROJECT",
				Required: true,
			},
			{
				Var:      "VERTEXAI_LOCATION",
				Required: true,
			},
		},
	},
	ModelProviderAzureOpenAI: {
		Provider:     ModelProviderAzureOpenAI,
		BaseUrl:      LiteLLMBaseUrl,
		ApiKeyEnvVar: AzureOpenAIEnvVar,
		ExtraAuthVars: []ModelProviderExtraAuthVars{
			{
				Var:      "AZURE_API_BASE",
				Required: true,
			},
			{
				Var:      "AZURE_API_VERSION",
				Required: false,
				Default:  DefaultAzureApiVersion,
			},
			{
				Var:               "AZURE_DEPLOYMENTS_MAP",
				Required:          false,
				MaybeJSONFilePath: true,
			},
		},
	},
	ModelProviderDeepSeek: {
		Provider:     ModelProviderDeepSeek,
		BaseUrl:      LiteLLMBaseUrl,
		ApiKeyEnvVar: DeepSeekApiKeyEnvVar,
	},
	ModelProviderPerplexity: {
		Provider:     ModelProviderPerplexity,
		BaseUrl:      LiteLLMBaseUrl,
		ApiKeyEnvVar: PerplexityApiKeyEnvVar,
	},
	ModelProviderAmazonBedrock: {
		Provider:   ModelProviderAmazonBedrock,
		BaseUrl:    LiteLLMBaseUrl,
		HasAWSAuth: true,

		// these aren't required as env vars—but if found in the credentials file, they are passed along as auth vars just as if they were env vars
		ExtraAuthVars: []ModelProviderExtraAuthVars{
			{Var: "AWS_ACCESS_KEY_ID", Required: true},
			{Var: "AWS_SECRET_ACCESS_KEY", Required: true},
			{Var: "AWS_REGION", Required: true},
			{Var: "AWS_SESSION_TOKEN", Required: false},
			{Var: "AWS_INFERENCE_PROFILE_ARN", Required: false},
		},
	},
	ModelProviderOllama: {
		Provider:  ModelProviderOllama,
		BaseUrl:   LiteLLMBaseUrl,
		SkipAuth:  true,
		LocalOnly: true,
	},
}

var BuiltInModelProviderConfigsByComposite = map[string]ModelProviderConfigSchema{}

func init() {
	for _, providerConfig := range BuiltInModelProviderConfigs {
		BuiltInModelProviderConfigsByComposite[providerConfig.ToComposite()] = providerConfig
	}
}

func GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
	var claudeSubscriptionCooldownActive bool
	if orgUserConfig != nil {
		claudeSubscriptionCooldownActive = orgUserConfig.IsClaudeSubscriptionCooldownActive()
	}

	var foundProviders []ModelProviderConfigSchema

	allProviders := []ModelProviderConfigSchema{}

	for _, providerConfig := range BuiltInModelProviderConfigs {
		allProviders = append(allProviders, providerConfig)
	}

	if settings != nil {
		for _, customProvider := range settings.CustomProviders {
			allProviders = append(allProviders, customProvider.ToModelProviderConfigSchema())
		}
	}

	for _, providerConfig := range allProviders {
		// filter out claude max if the cooldown is active
		if claudeSubscriptionCooldownActive && providerConfig.HasClaudeMaxAuth {
			continue
		}

		if providerConfig.SkipAuth {
			foundProviders = append(foundProviders, providerConfig)
			continue
		}

		var checkVars []string
		if providerConfig.ApiKeyEnvVar != "" {
			checkVars = append(checkVars, providerConfig.ApiKeyEnvVar)
		}
		for _, extraAuthVar := range providerConfig.ExtraAuthVars {
			if extraAuthVar.Required {
				checkVars = append(checkVars, extraAuthVar.Var)
			}
		}
		if providerConfig.HasClaudeMaxAuth {
			checkVars = append(checkVars, AnthropicClaudeMaxTokenEnvVar)
		}

		missingAny := false
		for _, checkVar := range checkVars {
			if _, ok := authVars[checkVar]; !ok {
				missingAny = true
				break
			}
		}
		if missingAny {
			continue
		}

		foundProviders = append(foundProviders, providerConfig)
	}

	return foundProviders
}

func GetProvidersForAuthVarsWithModelId(authVars map[string]string, settings *PlanSettings, modelId ModelId, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
	var localProvider ModelProvider
	if settings != nil {
		modelPack := settings.GetModelPack()
		if modelPack != nil {
			localProvider = modelPack.LocalProvider
		}
	}

	builtInUsesProviders := BuiltInModelProvidersByModelId[modelId]

	var customUsesProviders []BaseModelUsesProvider
	if settings != nil {
		customUsesProviders = settings.UsesCustomProviderByModelId[modelId]
	}

	usesProviders := append(builtInUsesProviders, customUsesProviders...)
	if len(usesProviders) == 0 {
		return []ModelProviderConfigSchema{}
	}

	providers := GetProvidersForAuthVars(authVars, settings, orgUserConfig)
	providersByComposite := map[string]ModelProviderConfigSchema{}
	for _, provider := range providers {
		providersByComposite[provider.ToComposite()] = provider
	}

	res := []ModelProviderConfigSchema{}
	for _, usesProvider := range usesProviders {
		composite := usesProvider.ToComposite()
		provider, ok := providersByComposite[composite]
		if !ok {
			continue
		}

		// if the model pack has a local provider, the provider is local only, and the provider is not the local provider, skip it
		if localProvider != "" && provider.LocalOnly && provider.Provider != localProvider {
			continue
		}

		res = append(res, provider)
	}

	return res

}

func (m ModelRoleConfig) GetProvidersForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) []ModelProviderConfigSchema {
	return GetProvidersForAuthVarsWithModelId(authVars, settings, m.ModelId, orgUserConfig)
}

func (m ModelRoleConfig) GetFirstProviderForAuthVars(authVars map[string]string, settings *PlanSettings, orgUserConfig *OrgUserConfig) *ModelProviderConfigSchema {
	providers := m.GetProvidersForAuthVars(authVars, settings, orgUserConfig)
	if len(providers) == 0 {
		return nil
	}
	return &providers[0]
}


================================================
FILE: app/shared/ai_models_roles.go
================================================
package shared

type ModelRole string

const (
	ModelRolePlanner          ModelRole = "planner"
	ModelRoleCoder            ModelRole = "coder"
	ModelRoleArchitect        ModelRole = "architect"
	ModelRolePlanSummary      ModelRole = "summarizer"
	ModelRoleBuilder          ModelRole = "builder"
	ModelRoleWholeFileBuilder ModelRole = "whole-file-builder"
	ModelRoleName             ModelRole = "names"
	ModelRoleCommitMsg        ModelRole = "commit-messages"
	ModelRoleExecStatus       ModelRole = "auto-continue"
)

var AllModelRoles = []ModelRole{ModelRolePlanner, ModelRoleCoder, ModelRoleArchitect, ModelRolePlanSummary, ModelRoleBuilder, ModelRoleWholeFileBuilder, ModelRoleName, ModelRoleCommitMsg, ModelRoleExecStatus}

var ModelRoleDescriptions = map[ModelRole]string{
	ModelRolePlanner:          "replies to prompts and makes plans",
	ModelRoleCoder:            "writes code to implement a plan",
	ModelRolePlanSummary:      "summarizes conversations exceeding max-convo-tokens",
	ModelRoleBuilder:          "builds a plan into file diffs",
	ModelRoleWholeFileBuilder: "builds a plan into file diffs by writing the entire file",
	ModelRoleName:             "names plans",
	ModelRoleCommitMsg:        "writes commit messages",
	ModelRoleExecStatus:       "determines whether to auto-continue",
	ModelRoleArchitect:        "makes high level plan and decides what context to load using codebase map",
}


================================================
FILE: app/shared/auth.go
================================================
package shared

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"strconv"
	"strings"
)

type AuthHeader struct {
	Token string `json:"token"`
	OrgId string `json:"orgId"`
	Hash  string `json:"hash"`
}

type ApiErrorType string

const (
	ApiErrorTypeInvalidToken          ApiErrorType = "invalid_token"
	ApiErrorTypeAuthOutdated          ApiErrorType = "auth_outdated"
	ApiErrorTypeTrialPlansExceeded    ApiErrorType = "trial_plans_exceeded"
	ApiErrorTypeTrialMessagesExceeded ApiErrorType = "trial_messages_exceeded"
	ApiErrorTypeTrialActionNotAllowed ApiErrorType = "trial_action_not_allowed"

	ApiErrorTypeContinueNoMessages ApiErrorType = "continue_no_messages"

	ApiErrorTypeCloudInsufficientCredits ApiErrorType = "cloud_insufficient_credits"
	ApiErrorTypeCloudMonthlyMaxReached   ApiErrorType = "cloud_monthly_max_reached"
	ApiErrorTypeCloudSubscriptionPaused  ApiErrorType = "cloud_subscription_paused"
	ApiErrorTypeCloudSubscriptionOverdue ApiErrorType = "cloud_subscription_overdue"

	ApiErrorTypeOther ApiErrorType = "other"
)

type TrialPlansExceededError struct {
	MaxPlans int `json:"maxPlans"`
}

type TrialMessagesExceededError struct {
	MaxReplies int `json:"maxMessages"`
}

type BillingError struct {
	HasBillingPermission bool `json:"hasBillingPermission"`
	IsTrial              bool `json:"isTrial"`
}

type ApiError struct {
	Type   ApiErrorType `json:"type"`
	Status int          `json:"status"`
	Msg    string       `json:"msg"`

	// only used for trial plans exceeded error
	TrialPlansExceededError *TrialPlansExceededError `json:"trialPlansExceededError,omitempty"`

	// only used for trial messages exceeded error
	TrialMessagesExceededError *TrialMessagesExceededError `json:"trialMessagesExceededError,omitempty"`

	// only used for billing errors
	BillingError *BillingError `json:"billingError,omitempty"`
}

func (e *ApiError) Error() string {
	return fmt.Sprintf("%d Error: %s", e.Status, e.Msg)
}

type ClientAccount struct {
	IsCloud     bool   `json:"isCloud"`
	Host        string `json:"host"`
	Email       string `json:"email"`
	UserName    string `json:"userName"`
	UserId      string `json:"userId"`
	Token       string `json:"token"`
	IsLocalMode bool   `json:"isLocalMode"`

	IsTrial bool `json:"isTrial"` // legacy field
}

type ClientAuth struct {
	ClientAccount
	OrgId                string `json:"orgId"`
	OrgName              string `json:"orgName"`
	OrgIsTrial           bool   `json:"orgIsTrial"`
	IntegratedModelsMode bool   `json:"integratedModelsMode"`
}

// Helps the client refresh auth if any of the org fields change
func (c *ClientAuth) ToHash() string {
	s := strings.Join([]string{
		c.OrgName,
		strconv.FormatBool(c.OrgIsTrial),
		strconv.FormatBool(c.IntegratedModelsMode),
	}, "||")

	hash := sha256.Sum256([]byte(s))
	return hex.EncodeToString(hash[:])
}


================================================
FILE: app/shared/context.go
================================================
package shared

import (
	"fmt"
	"math"
	"strconv"
	"strings"

	"github.com/olekukonko/tablewriter"
)

const (
	MaxContextBodySize           = 25 * 1024 * 1024 // 25MB
	MaxContextCount              = 1000
	MaxContextMapPaths           = 3000
	MaxContextMapSingleInputSize = 500 * 1024             // 500KB
	MaxContextMapTotalInputSize  = 250 * 1024 * 1024      // 250MB
	MaxTotalContextSize          = 1 * 1024 * 1024 * 1024 // 1GB

	ContextMapMaxBatchBytes = 10 * 1024 * 1024 // 10MB
	ContextMapMaxBatchSize  = 500
)

type ContextUpdateResult struct {
	UpdatedContexts []*Context
	TokenDiffsById  map[string]int
	TokensDiff      int
	TotalTokens     int
	NumFiles        int
	NumUrls         int
	NumImages       int
	NumTrees        int
	NumMaps         int
	MaxTokens       int
}

func (c *Context) TypeAndIcon() (string, string) {
	var icon string
	var t string
	switch c.ContextType {
	case ContextFileType:
		icon = "📄"
		t = "file"
	case ContextURLType:
		icon = "🌎"
		t = "url"
	case ContextDirectoryTreeType:
		icon = "🗂 "
		t = "tree"
	case ContextNoteType:
		icon = "✏️ "
		t = "note"
	case ContextPipedDataType:
		icon = "↔️ "
		t = "piped"
	case ContextImageType:
		icon = "🖼️ "
		t = "image"
	case ContextMapType:
		icon = "🗺️ "
		t = "map"
	}

	return t, icon
}

func TableForLoadContext(contexts []*Context, plaintext bool) string {
	tableString := &strings.Builder{}
	table := tablewriter.NewWriter(tableString)
	table.SetHeader([]string{"Name", "Type", "🪙"})
	table.SetAutoWrapText(false)

	for _, context := range contexts {
		t, icon := context.TypeAndIcon()
		row := []string{
			" " + icon + " " + context.Name,
			t,
			"+" + strconv.Itoa(context.NumTokens),
		}

		if !plaintext {
			table.Rich(row, []tablewriter.Colors{
				{tablewriter.FgHiGreenColor, tablewriter.Bold},
				{tablewriter.FgHiGreenColor},
				{tablewriter.FgHiGreenColor},
			})
		} else {
			table.Append(row)
		}
	}

	table.Render()

	return strings.TrimSpace(tableString.String())
}

func MarkdownTableForLoadContext(contexts []*Context) string {
	var sb strings.Builder
	sb.WriteString("| Name | Type | 🪙 |\n")
	sb.WriteString("|------|------|----|\n")

	for _, context := range contexts {
		t, icon := context.TypeAndIcon()
		sb.WriteString(fmt.Sprintf("| %s %s | %s | +%d |\n",
			icon, context.Name, t, context.NumTokens))
	}

	return sb.String()
}

func SummaryForLoadContext(contexts []*Context, tokensAdded, totalTokens int) string {

	var hasNote bool
	var hasPiped bool

	var numFiles int
	var numTrees int
	var numUrls int
	var numMaps int

	for _, context := range contexts {
		switch context.ContextType {
		case ContextFileType:
			numFiles++
		case ContextURLType:
			numUrls++
		case ContextDirectoryTreeType:
			numTrees++
		case ContextNoteType:
			hasNote = true
		case ContextPipedDataType:
			hasPiped = true
		case ContextMapType:
			numMaps++
		}
	}

	var added []string

	if hasNote {
		added = append(added, "a note")
	}
	if hasPiped {
		added = append(added, "piped data")
	}
	if numFiles > 0 {
		label := "file"
		if numFiles > 1 {
			label = "files"
		}
		added = append(added, fmt.Sprintf("%d %s", numFiles, label))
	}
	if numTrees > 0 {
		label := "directory tree"
		if numTrees > 1 {
			label = "directory trees"
		}
		added = append(added, fmt.Sprintf("%d %s", numTrees, label))
	}
	if numUrls > 0 {
		label := "url"
		if numUrls > 1 {
			label = "urls"
		}
		added = append(added, fmt.Sprintf("%d %s", numUrls, label))
	}
	if numMaps > 0 {
		label := "map"
		if numMaps > 1 {
			label = "maps"
		}
		added = append(added, fmt.Sprintf("%d %s", numMaps, label))
	}

	msg := "Loaded "

	if len(added) <= 2 {
		msg += strings.Join(added, " and ")
	} else {
		for i, add := range added {
			if i == len(added)-1 {
				msg += ", and " + add
			} else {
				msg += ", " + add
			}
		}
	}

	msg += fmt.Sprintf(" into context | added → %d 🪙 |  total → %d 🪙", tokensAdded, totalTokens)

	return msg
}

func TableForRemoveContext(contexts []*Context) string {
	tableString := &strings.Builder{}
	table := tablewriter.NewWriter(tableString)
	table.SetHeader([]string{"Name", "Type", "🪙"})
	table.SetAutoWrapText(false)

	for _, context := range contexts {
		t, icon := context.TypeAndIcon()
		row := []string{
			" " + icon + " " + context.Name,
			t,
			"-" + strconv.Itoa(context.NumTokens),
		}

		table.Rich(row, []tablewriter.Colors{
			{tablewriter.FgHiRedColor, tablewriter.Bold},
			{tablewriter.FgHiRedColor},
			{tablewriter.FgHiRedColor},
		})
	}

	table.Render()

	return tableString.String()
}

func SummaryForRemoveContext(contexts []*Context, previousTotalTokens int) string {
	removedTokens := 0

	for _, context := range contexts {
		removedTokens += context.NumTokens
	}

	totalTokens := previousTotalTokens - removedTokens

	suffix := ""
	if len(contexts) > 1 {
		suffix = "s"
	}

	return fmt.Sprintf("Removed %d piece%s of context | removed → %d 🪙 | total → %d 🪙", len(contexts), suffix, removedTokens, totalTokens)
}

type SummaryForUpdateContextParams struct {
	NumFiles    int
	NumTrees    int
	NumUrls     int
	NumMaps     int
	TokensDiff  int
	TotalTokens int
}

func SummaryForUpdateContext(params SummaryForUpdateContextParams) string {
	numFiles := params.NumFiles
	numTrees := params.NumTrees
	numUrls := params.NumUrls
	numMaps := params.NumMaps
	tokensDiff := params.TokensDiff
	totalTokens := params.TotalTokens

	msg := "Updated"
	var toAdd []string
	if numFiles > 0 {
		postfix := "s"
		if numFiles == 1 {
			postfix = ""
		}
		toAdd = append(toAdd, fmt.Sprintf("%d file%s", numFiles, postfix))
	}
	if numTrees > 0 {
		postfix := "s"
		if numTrees == 1 {
			postfix = ""
		}
		toAdd = append(toAdd, fmt.Sprintf("%d tree%s", numTrees, postfix))
	}
	if numUrls > 0 {
		postfix := "s"
		if numUrls == 1 {
			postfix = ""
		}
		toAdd = append(toAdd, fmt.Sprintf("%d url%s", numUrls, postfix))
	}
	if numMaps > 0 {
		postfix := "s"
		if numMaps == 1 {
			postfix = ""
		}
		toAdd = append(toAdd, fmt.Sprintf("%d map%s", numMaps, postfix))
	}

	if len(toAdd) <= 2 {
		msg += " " + strings.Join(toAdd, " and ")
	} else {
		for i, add := range toAdd {
			if i == len(toAdd)-1 {
				msg += ", and " + add
			} else {
				msg += ", " + add
			}
		}
	}

	msg += " in context"

	action := "added"
	if tokensDiff < 0 {
		action = "removed"
	}
	absTokenDiff := int(math.Abs(float64(tokensDiff)))
	msg += fmt.Sprintf(" | %s → %d 🪙 | total → %d 🪙", action, absTokenDiff, totalTokens)

	return msg
}

func TableForContextUpdate(updateRes *ContextUpdateResult) string {
	contexts := updateRes.UpdatedContexts
	tokenDiffsById := updateRes.TokenDiffsById

	if len(contexts) == 0 {
		return ""
	}

	tableString := &strings.Builder{}
	table := tablewriter.NewWriter(tableString)
	table.SetHeader([]string{"Name", "Type", "🪙"})
	table.SetAutoWrapText(false)

	for _, context := range contexts {
		t, icon := context.TypeAndIcon()
		diff := tokenDiffsById[context.Id]

		diffStr := "+" + strconv.Itoa(diff)
		tableColor := tablewriter.FgHiGreenColor

		if diff < 0 {
			diffStr = strconv.Itoa(diff)
			tableColor = tablewriter.FgHiRedColor
		}

		row := []string{
			" " + icon + " " + context.Name,
			t,
			diffStr,
		}

		table.Rich(row, []tablewriter.Colors{
			{tableColor, tablewriter.Bold},
			{tableColor},
			{tableColor},
		})
	}

	table.Render()

	return tableString.String()
}


================================================
FILE: app/shared/convo_message.go
================================================
package shared

func (f *ConvoMessageFlags) GetReplyTags() []string {
	var replyTags []string
	if f.DidLoadContext {
		replyTags = append(replyTags, "📥 Loaded Context")
	}
	if f.DidMakePlan {
		if f.DidMakeDebuggingPlan {
			replyTags = append(replyTags, "🐞 Made Debug Plan")
		} else if f.DidRemoveTasks {
			replyTags = append(replyTags, "🔄 Revised Plan")
		} else {
			replyTags = append(replyTags, "📋 Made Plan")
		}
	}
	if f.DidWriteCode {
		replyTags = append(replyTags, "👨‍💻 Wrote Code")
	}
	// if f.DidCompleteTask {
	// 	replyTags = append(replyTags, "✅")
	// }
	if f.DidCompletePlan {
		replyTags = append(replyTags, "🏁")
	}

	if f.HasError {
		replyTags = append(replyTags, "🚨 Error")
	}

	return replyTags
}


================================================
FILE: app/shared/data_models.go
================================================
package shared

import (
	"time"

	"github.com/sashabaranov/go-openai"
	"github.com/shopspring/decimal"
)

type Org struct {
	Id                 string `json:"id"`
	Name               string `json:"name"`
	IsTrial            bool   `json:"isTrial"`
	AutoAddDomainUsers bool   `json:"autoAddDomainUsers"`

	// optional cloud attributes
	IntegratedModelsMode bool                `json:"integratedModelsMode,omitempty"`
	CloudBillingFields   *CloudBillingFields `json:"cloudBillingFields,omitempty"`
}

type User struct {
	Id               string `json:"id"`
	Name             string `json:"name"`
	Email            string `json:"email"`
	IsTrial          bool   `json:"isTrial"`
	NumNonDraftPlans int    `json:"numNonDraftPlans"`

	DefaultPlanConfig *PlanConfig `json:"defaultPlanConfig,omitempty"`
}

type OrgUser struct {
	OrgId     string `json:"orgId"`
	UserId    string `json:"userId"`
	OrgRoleId string `json:"orgRoleId"`

	Config *OrgUserConfig `json:"config,omitempty"`
}

type Invite struct {
	Id         string     `json:"id"`
	OrgId      string     `json:"orgId"`
	Email      string     `json:"email"`
	Name       string     `json:"name"`
	OrgRoleId  string     `json:"orgRoleId"`
	InviterId  string     `json:"inviterId"`
	InviteeId  *string    `json:"inviteeId"`
	AcceptedAt *time.Time `json:"acceptedAt"`
	CreatedAt  time.Time  `json:"createdAt"`
}

type Project struct {
	Id   string `json:"id"`
	Name string `json:"name"`
}

type Plan struct {
	Id              string      `json:"id"`
	OwnerId         string      `json:"ownerId"`
	ProjectId       string      `json:"projectId"`
	Name            string      `json:"name"`
	SharedWithOrgAt *time.Time  `json:"sharedWithOrgAt,omitempty"`
	TotalReplies    int         `json:"totalReplies"`
	ActiveBranches  int         `json:"activeBranches"`
	PlanConfig      *PlanConfig `json:"planConfig,omitempty"`
	ArchivedAt      *time.Time  `json:"archivedAt,omitempty"`
	CreatedAt       time.Time   `json:"createdAt"`
	UpdatedAt       time.Time   `json:"updatedAt"`
}

type Branch struct {
	Id              string     `json:"id"`
	PlanId          string     `json:"planId"`
	OwnerId         string     `json:"ownerId"`
	ParentBranchId  *string    `json:"parentBranchId"`
	Name            string     `json:"name"`
	Status          PlanStatus `json:"status"`
	ContextTokens   int        `json:"contextTokens"`
	ConvoTokens     int        `json:"convoTokens"`
	SharedWithOrgAt *time.Time `json:"sharedWithOrgAt,omitempty"`
	ArchivedAt      *time.Time `json:"archivedAt,omitempty"`
	CreatedAt       time.Time  `json:"createdAt"`
	UpdatedAt       time.Time  `json:"updatedAt"`
}

type ContextType string

const (
	ContextFileType          ContextType = "file"
	ContextURLType           ContextType = "url"
	ContextNoteType          ContextType = "note"
	ContextDirectoryTreeType ContextType = "directory tree"
	ContextPipedDataType     ContextType = "piped data"
	ContextImageType         ContextType = "image"
	ContextMapType           ContextType = "map"
)

type FileMapBodies map[string]string

type Context struct {
	Id              string                `json:"id"`
	OwnerId         string                `json:"ownerId"`
	ContextType     ContextType           `json:"contextType"`
	Name            string                `json:"name"`
	Url             string                `json:"url"`
	FilePath        string                `json:"file_path"`
	Sha             string                `json:"sha"`
	NumTokens       int                   `json:"numTokens"`
	Body            string                `json:"body,omitempty"`
	BodySize        int64                 `json:"bodySize,omitempty"`
	ForceSkipIgnore bool                  `json:"forceSkipIgnore"`
	ImageDetail     openai.ImageURLDetail `json:"imageDetail,omitempty"`
	MapParts        FileMapBodies         `json:"mapParts,omitempty"`
	MapShas         map[string]string     `json:"mapShas,omitempty"`
	MapTokens       map[string]int        `json:"mapTokens,omitempty"`
	MapSizes        map[string]int64      `json:"mapSizes,omitempty"`
	AutoLoaded      bool                  `json:"autoLoaded"`
	CreatedAt       time.Time             `json:"createdAt"`
	UpdatedAt       time.Time             `json:"updatedAt"`
}

type TellStage string

const (
	TellStagePlanning       TellStage = "planning"
	TellStageImplementation TellStage = "implementation"
)

type PlanningPhase string

const (
	PlanningPhaseContext PlanningPhase = "context"
	PlanningPhaseTasks   PlanningPhase = "tasks"
)

type CurrentStage struct {
	TellStage     TellStage
	PlanningPhase PlanningPhase
}

type ConvoMessageFlags struct {
	DidMakePlan           bool `json:"didMakePlan"`
	DidRemoveTasks        bool `json:"didRemoveTasks"`
	DidMakeDebuggingPlan  bool `json:"didMakeDebuggingPlan"`
	DidLoadContext        bool `json:"didLoadContext"`
	CurrentStage          CurrentStage
	IsChat                bool `json:"isChat"`
	DidWriteCode          bool `json:"didWriteCode"`
	DidCompleteTask       bool `json:"didCompleteTask"`
	DidCompletePlan       bool `json:"didCompletePlan"`
	HasUnfinishedSubtasks bool `json:"hasUnfinishedSubtasks"`
	IsApplyDebug          bool `json:"isApplyDebug"`
	IsUserDebug           bool `json:"isUserDebug"`
	HasError              bool `json:"hasError"`
}

type Subtask struct {
	Title       string   `json:"title"`
	Description string   `json:"description"`
	UsesFiles   []string `json:"usesFiles"`
	IsFinished  bool     `json:"isFinished"`
}

type ConvoMessage struct {
	Id               string            `json:"id"`
	UserId           string            `json:"userId"`
	Role             string            `json:"role"`
	Tokens           int               `json:"tokens"`
	Num              int               `json:"num"`
	Message          string            `json:"message"`
	Stopped          bool              `json:"stopped"`
	Flags            ConvoMessageFlags `json:"flags"`
	Subtask          *Subtask          `json:"subtask,omitempty"`
	AddedSubtasks    []*Subtask        `json:"addedSubtasks,omitempty"`
	RemovedSubtasks  []string          `json:"removedSubtasks,omitempty"`
	ActiveContextIds []string          `json:"activeContextIds"`
	CreatedAt        time.Time         `json:"createdAt"`
}

type ConvoSummary struct {
	Id                          string    `json:"id"`
	LatestConvoMessageCreatedAt time.Time `json:"latestConvoMessageCreatedAt"`
	LatestConvoMessageId        string    `json:"lastestConvoMessageId"`
	Summary                     string    `json:"summary"`
	Tokens                      int       `json:"tokens"`
	NumMessages                 int       `json:"numMessages"`
	CreatedAt                   time.Time `json:"createdAt"`
}

type OperationType string

const (
	OperationTypeFile   OperationType = "file"
	OperationTypeMove   OperationType = "move"
	OperationTypeRemove OperationType = "remove"
	OperationTypeReset  OperationType = "reset"
)

type Operation struct {
	Type        OperationType
	Path        string
	Destination string
	Content     string
	Description string
	ReplyBefore string
	NumTokens   int
}

func (o *Operation) Name() string {
	res := string(o.Type) + " | " + o.Path
	if o.Destination != "" {
		res += " → " + o.Destination
	}
	return res
}

type ConvoMessageDescription struct {
	Id                    string `json:"id"`
	ConvoMessageId        string `json:"convoMessageId"`
	SummarizedToMessageId string `json:"summarizedToMessageId"`
	WroteFiles            bool   `json:"wroteFiles"`
	CommitMsg             string `json:"commitMsg"`
	// Files                 []string        `json:"files"`
	Operations            []*Operation    `json:"operations"`
	DidBuild              bool            `json:"didBuild"`
	BuildPathsInvalidated map[string]bool `json:"buildPathsInvalidated"`
	Error                 string          `json:"error"`
	AppliedAt             *time.Time      `json:"appliedAt,omitempty"`
	CreatedAt             time.Time       `json:"createdAt"`
	UpdatedAt             time.Time       `json:"updatedAt"`
}

type PlanBuild struct {
	Id             string    `json:"id"`
	ConvoMessageId string    `json:"convoMessageId"`
	FilePath       string    `json:"filePath"`
	Error          string    `json:"error"`
	CreatedAt      time.Time `json:"createdAt"`
	UpdatedAt      time.Time `json:"updatedAt"`
}

type Replacement struct {
	Id             string                      `json:"id"`
	Old            string                      `json:"old"`
	Summary        string                      `json:"summary"`
	EntireFile     bool                        `json:"entireFile"`
	New            string                      `json:"new"`
	Failed         bool                        `json:"failed"`
	RejectedAt     *time.Time                  `json:"rejectedAt,omitempty"`
	StreamedChange *StreamedChangeWithLineNums `json:"streamedChange"`
}

type PlanFileResult struct {
	Id                  string         `json:"id"`
	TypeVersion         int            `json:"typeVersion"`
	ReplaceWithLineNums bool           `json:"replaceWithLineNums"`
	ConvoMessageId      string         `json:"convoMessageId"`
	PlanBuildId         string         `json:"planBuildId"`
	Path                string         `json:"path"`
	Content             string         `json:"content"`
	AnyFailed           bool           `json:"anyFailed"`
	AppliedAt           *time.Time     `json:"appliedAt,omitempty"`
	RejectedAt          *time.Time     `json:"rejectedAt,omitempty"`
	Replacements        []*Replacement `json:"replacements"`

	RemovedFile bool `json:"removedFile"`

	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

type CurrentPlanFiles struct {
	Files           map[string]string    `json:"files"`
	Removed         map[string]bool      `json:"removedByPath"`
	UpdatedAtByPath map[string]time.Time `json:"updatedAtByPath"`
}

type PlanFileResultsByPath map[string][]*PlanFileResult
type PlanResult struct {
	SortedPaths        []string                  `json:"sortedPaths"`
	FileResultsByPath  PlanFileResultsByPath     `json:"fileResultsByPath"`
	Results            []*PlanFileResult         `json:"results"`
	ReplacementsByPath map[string][]*Replacement `json:"replacementsByPath"`
}

type PlanApply struct {
	Id                         string    `json:"id"`
	UserId                     string    `json:"userId"`
	ConvoMessageIds            []string  `json:"convoMessageIds"`
	ConvoMessageDescriptionIds []string  `json:"convoMessageDescriptionIds"`
	PlanFileResultIds          []string  `json:"planFileResultIds"`
	CommitMsg                  string    `json:"commitMsg"`
	CreatedAt                  time.Time `json:"createdAt"`
}

type CurrentPlanState struct {
	PlanResult               *PlanResult                `json:"planResult"`
	CurrentPlanFiles         *CurrentPlanFiles          `json:"currentPlanFiles"`
	ConvoMessageDescriptions []*ConvoMessageDescription `json:"convoMessageDescriptions"`
	PlanApplies              []*PlanApply               `json:"planApplies"`
	ContextsByPath           map[string]*Context        `json:"contextsByPath"`
}

type OrgRole struct {
	Id          string `json:"id"`
	IsDefault   bool   `json:"isDefault"`
	Label       string `json:"label"`
	Description string `json:"description"`
}

type CloudBillingFields struct {
	CreditsBalance        decimal.Decimal `json:"creditsBalance"`
	MonthlyGrant          decimal.Decimal `json:"monthlyGrant"`
	AutoRebuyEnabled      bool            `json:"autoRebuyEnabled"`
	AutoRebuyMinThreshold decimal.Decimal `json:"autoRebuyMinThreshold"`
	AutoRebuyToBalance    decimal.Decimal `json:"autoRebuyToBalance"`
	NotifyThreshold       decimal.Decimal `json:"notifyThreshold"`
	MaxThresholdPerMonth  decimal.Decimal `json:"maxThresholdPerMonth"`
	BillingCycleStartedAt time.Time       `json:"billingCycleStartedAt"`

	ChangedBillingMode bool `json:"changedBillingMode"`
	TrialPaid          bool `json:"trialPaid"`

	StripeSubscriptionId                 *string    `json:"stripeSubscriptionId"`
	SubscriptionStatus                   *string    `json:"subscriptionStatus"`
	SubscriptionPausedAt                 *time.Time `json:"subscriptionPausedAt"`
	StripePaymentMethod                  *string    `json:"stripePaymentMethod"`
	SubscriptionActionRequired           bool       `json:"subscriptionActionRequired"` // for 3ds/sca approvals
	SubscriptionActionRequiredInvoiceUrl *string    `json:"subscriptionActionRequiredInvoiceUrl"`
}

type CreditsTransactionType string

const (
	CreditsTransactionTypeCredit CreditsTransactionType = "credit"
	CreditsTransactionTypeDebit  CreditsTransactionType = "debit"
)

type CreditType string

const (
	CreditTypeTrial      CreditType = "trial"
	CreditTypeGrant      CreditType = "grant"
	CreditTypeAdminGrant CreditType = "admin_grant"
	CreditTypePurchase   CreditType = "purchase"
	CreditTypeSwitch     CreditType = "switch"
)

type CreditsTransaction struct {
	Id              string                 `json:"id"`
	OrgId           string                 `json:"orgId"`
	OrgName         string                 `json:"orgName"`
	UserId          *string                `json:"userId"`
	UserEmail       *string                `json:"userEmail"`
	UserName        *string                `json:"userName"`
	TransactionType CreditsTransactionType `json:"transactionType"`
	Amount          decimal.Decimal        `json:"amount"`
	StartBalance    decimal.Decimal        `json:"startBalance"`
	EndBalance      decimal.Decimal        `json:"endBalance"`

	CreditType                  *CreditType      `json:"creditType,omitempty"`
	CreditIsAutoRebuy           bool             `json:"creditIsAutoRebuy"`
	CreditAutoRebuyMinThreshold *decimal.Decimal `json:"creditAutoRebuyMinThreshold,omitempty"`
	CreditAutoRebuyToBalance    *decimal.Decimal `json:"creditAutoRebuyToBalance,omitempty"`

	DebitInputTokens              *int             `json:"debitInputTokens,omitempty"`
	DebitOutputTokens             *int             `json:"debitOutputTokens,omitempty"`
	DebitModelInputPricePerToken  *decimal.Decimal `json:"debitModelInputPricePerToken,omitempty"`
	DebitModelOutputPricePerToken *decimal.Decimal `json:"debitModelOutputPricePerToken,omitempty"`

	DebitBaseAmount *decimal.Decimal `json:"debitBaseAmount,omitempty"`
	DebitSurcharge  *decimal.Decimal `json:"debitSurcharge,omitempty"`

	DebitModelProvider *ModelProvider `json:"debitModelProvider,omitempty"`
	DebitModelName     *string        `json:"debitModelName,omitempty"`
	DebitModelPackName *string        `json:"debitModelPackName,omitempty"`
	DebitModelRole     *ModelRole     `json:"debitModelRole,omitempty"`

	DebitPurpose  *string `json:"debitPurpose,omitempty"`
	DebitPlanId   *string `json:"debitPlanId,omitempty"`
	DebitPlanName *string `json:"debitPlanName,omitempty"`
	DebitId       *string `json:"debitId,omitempty"`

	DebitCacheDiscount *decimal.Decimal `json:"debitCacheDiscount,omitempty"`

	DebitSessionId *string `json:"debitSessionId,omitempty"`

	CreatedAt time.Time `json:"createdAt"`
}

func (t *CreditsTransaction) ModelString() string {
	s := ""
	if t.DebitModelProvider != nil && *t.DebitModelProvider != ModelProviderOpenAI {
		s += string(*t.DebitModelProvider) + "/"
	}
	if t.DebitModelName != nil {
		s += *t.DebitModelName
	}

	return s
}


================================================
FILE: app/shared/email.go
================================================
package shared

func IsEmailServiceDomain(domain string) bool {
	_, ok := emailServiceDomains[domain]
	return ok
}

var emailServiceDomains = map[string]bool{
	"gmail.com":        true,
	"yahoo.com":        true,
	"outlook.com":      true,
	"hotmail.com":      true,
	"icloud.com":       true,
	"zoho.com":         true,
	"protonmail.com":   true,
	"mail.com":         true,
	"yandex.com":       true,
	"fastmail.com":     true,
	"tutanota.com":     true,
	"hey.com":          true,
	"hushmail.com":     true,
	"runbox.com":       true,
	"mailfence.com":    true,
	"disroot.org":      true,
	"posteo.de":        true,
	"mailinator.com":   true,
	"aol.com":          true,
	"hotmail.co.uk":    true,
	"hotmail.fr":       true,
	"msn.com":          true,
	"yahoo.fr":         true,
	"wanadoo.fr":       true,
	"orange.fr":        true,
	"comcast.net":      true,
	"yahoo.co.uk":      true,
	"yahoo.com.br":     true,
	"yahoo.co.in":      true,
	"live.com":         true,
	"rediffmail.com":   true,
	"free.fr":          true,
	"gmx.de":           true,
	"web.de":           true,
	"yandex.ru":        true,
	"ymail.com":        true,
	"libero.it":        true,
	"uol.com.br":       true,
	"bol.com.br":       true,
	"mail.ru":          true,
	"cox.net":          true,
	"hotmail.it":       true,
	"sbcglobal.net":    true,
	"sfr.fr":           true,
	"live.fr":          true,
	"verizon.net":      true,
	"live.co.uk":       true,
	"googlemail.com":   true,
	"yahoo.es":         true,
	"ig.com.br":        true,
	"live.nl":          true,
	"bigpond.com":      true,
	"terra.com.br":     true,
	"yahoo.it":         true,
	"neuf.fr":          true,
	"yahoo.de":         true,
	"alice.it":         true,
	"rocketmail.com":   true,
	"att.net":          true,
	"laposte.net":      true,
	"facebook.com":     true,
	"bellsouth.net":    true,
	"yahoo.in":         true,
	"hotmail.es":       true,
	"charter.net":      true,
	"yahoo.ca":         true,
	"yahoo.com.au":     true,
	"rambler.ru":       true,
	"hotmail.de":       true,
	"tiscali.it":       true,
	"shaw.ca":          true,
	"yahoo.co.jp":      true,
	"sky.com":          true,
	"earthlink.net":    true,
	"optonline.net":    true,
	"freenet.de":       true,
	"t-online.de":      true,
	"aliceadsl.fr":     true,
	"virgilio.it":      true,
	"home.nl":          true,
	"qq.com":           true,
	"telenet.be":       true,
	"me.com":           true,
	"yahoo.com.ar":     true,
	"tiscali.co.uk":    true,
	"yahoo.com.mx":     true,
	"voila.fr":         true,
	"gmx.net":          true,
	"planet.nl":        true,
	"tin.it":           true,
	"live.it":          true,
	"ntlworld.com":     true,
	"arcor.de":         true,
	"yahoo.co.id":      true,
	"frontiernet.net":  true,
	"hetnet.nl":        true,
	"live.com.au":      true,
	"yahoo.com.sg":     true,
	"zonnet.nl":        true,
	"club-internet.fr": true,
	"juno.com":         true,
	"optusnet.com.au":  true,
	"blueyonder.co.uk": true,
	"bluewin.ch":       true,
	"skynet.be":        true,
	"sympatico.ca":     true,
	"windstream.net":   true,
	"mac.com":          true,
	"centurytel.net":   true,
	"chello.nl":        true,
	"live.ca":          true,
	"aim.com":          true,
	"bigpond.net.au":   true,
	"163.com":          true,
	"126.com":          true,
	"daum.net":         true,
	"naver.com":        true,
	"sina.com":         true,
	"sohu.com":         true,
	"gmx.com":          true,
	"yopmail.com":      true,
	"bk.ru":            true,
	"list.ru":          true,
	"seznam.cz":        true,
	"nextmail.ru":      true,
	"kpnmail.nl":       true,
}


================================================
FILE: app/shared/file_maps.go
================================================
package shared

import (
	"fmt"
	"sort"
	"strings"
)

func (m FileMapBodies) CombinedMap(tokensByPath map[string]int) string {
	var combinedMap strings.Builder
	paths := make([]string, 0, len(m))
	for path := range m {
		paths = append(paths, path)
	}
	sort.Strings(paths)
	for _, path := range paths {
		body := m[path]
		body = strings.TrimSpace(body)
		fileHeading := MapFileHeading(path, tokensByPath[path])
		combinedMap.WriteString(fileHeading)
		if body == "" {
			combinedMap.WriteString("[NO MAP]")
		} else {
			combinedMap.WriteString(body)
		}
		combinedMap.WriteString("\n")
	}
	return combinedMap.String()
}

func MapFileHeading(path string, tokens int) string {
	return fmt.Sprintf("\n### %s (%d 🪙)\n\n", path, tokens)
}


================================================
FILE: app/shared/go.mod
================================================
module plandex-shared

go 1.23.3

require (
	github.com/davecgh/go-spew v1.1.1
	github.com/google/go-cmp v0.7.0
	github.com/jinzhu/copier v0.4.0
	github.com/pkoukk/tiktoken-go v0.1.7
)

require (
	github.com/mattn/go-runewidth v0.0.16 // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
)

require (
	github.com/dlclark/regexp2 v1.11.5 // indirect
	github.com/google/uuid v1.6.0 // indirect
	github.com/olekukonko/tablewriter v0.0.5
	github.com/sashabaranov/go-openai v1.38.1
	github.com/shopspring/decimal v1.4.0
	golang.org/x/image v0.25.0
)


================================================
FILE: app/shared/go.sum
================================================
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jinzhu/copier v0.4.0 h1:w3ciUoD19shMCRargcpm0cm91ytaBhDvuRpz1ODO/U8=
github.com/jinzhu/copier v0.4.0/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/pkoukk/tiktoken-go v0.1.7 h1:qOBHXX4PHtvIvmOtyg1EeKlwFRiMKAcoMp4Q+bLQDmw=
github.com/pkoukk/tiktoken-go v0.1.7/go.mod h1:9NiV+i9mJKGj1rYOT+njbv+ZwA/zJxYdewGl6qVatpg=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/sashabaranov/go-openai v1.38.1 h1:TtZabbFQZa1nEni/IhVtDF/WQjVqDgd+cWR5OeddzF8=
github.com/sashabaranov/go-openai v1.38.1/go.mod h1:lj5b/K+zjTSFxVLijLSTDZuP7adOgerWeFyZLUhAKRg=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=


================================================
FILE: app/shared/images.go
================================================
package shared

import (
	"bytes"
	"encoding/base64"
	"fmt"
	"image"
	"io"
	"log"
	"math"
	"path/filepath"
	"strings"

	"github.com/sashabaranov/go-openai"

	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"

	_ "golang.org/x/image/webp"
)

func GetImageTokens(base64Image string, detail openai.ImageURLDetail) (int, error) {
	imageData, err := base64.StdEncoding.DecodeString(base64Image)
	if err != nil {
		log.Println("failed to decode base64 image data:", err)
		return 0, fmt.Errorf("failed to decode base64 image data: %w", err)
	}

	return GetImageTokensFromHeader(bytes.NewReader(imageData), detail, int64(len(imageData)))
}

func GetImageTokensFromHeader(reader io.Reader, detail openai.ImageURLDetail, maxBytes int64) (int, error) {
	reader = io.LimitReader(reader, maxBytes)
	img, _, err := image.DecodeConfig(reader)
	if err != nil {
		log.Println("failed to decode image config:", err)
		return 0, fmt.Errorf("failed to decode image config: %w", err)
	}

	width, height := img.Width, img.Height

	anthropicTokens := getAnthropicImageTokens(width, height)
	googleTokens := getGoogleImageTokens(width, height)
	openaiTokens := getOpenAIImageTokens(width, height, detail)

	// log.Printf("GetImageTokens - width: %d, height: %d\n", width, height)
	// log.Printf("GetImageTokens - anthropicTokens: %d\n", anthropicTokens)
	// log.Printf("GetImageTokens - googleTokens: %d\n", googleTokens)
	// log.Printf("GetImageTokens - openaiTokens: %d\n", openaiTokens)

	// get max of the three
	return int(math.Max(
		float64(anthropicTokens),
		math.Max(
			float64(googleTokens),
			float64(openaiTokens),
		),
	)), nil
}

func GetImageTokensEstimateFromBytes(l int64) int {
	return int(l) / 750
}

func getAnthropicImageTokens(width, height int) int {
	// Anthropic uses a simple area-based calculation (1 token per ~750 px²)
	area := width * height
	return int(math.Ceil(float64(area) / 750.0))
}

func getGoogleImageTokens(width, height int) int {
	// Google Gemini uses 768px tiles at 258 tokens per tile
	const tileSize = 768
	const tokensPerTile = 258

	horizontalTiles := int(math.Ceil(float64(width) / float64(tileSize)))
	verticalTiles := int(math.Ceil(float64(height) / float64(tileSize)))

	numTiles := horizontalTiles * verticalTiles
	return numTiles * tokensPerTile
}

func getOpenAIImageTokens(width, height int, detail openai.ImageURLDetail) int {
	const (
		lowDetailTokens  = 85
		highDetailBase   = 85
		highDetailFactor = 170
	)

	if detail == openai.ImageURLDetailLow {
		return lowDetailTokens
	}

	// Scale to fit within 2048px square
	if width > 2048 || height > 2048 {
		scaleFactor := math.Min(2048.0/float64(width), 2048.0/float64(height))
		width = int(float64(width) * scaleFactor)
		height = int(float64(height) * scaleFactor)
	}

	// Scale shortest side to 768px
	if width < height {
		scaleFactor := 768.0 / float64(width)
		width = 768
		height = int(float64(height) * scaleFactor)
	} else {
		scaleFactor := 768.0 / float64(height)
		height = 768
		width = int(float64(width) * scaleFactor)
	}

	// Calculate 512px tiles
	horizontalTiles := int(math.Ceil(float64(width) / 512.0))
	verticalTiles := int(math.Ceil(float64(height) / 512.0))

	numTiles := horizontalTiles * verticalTiles
	return highDetailBase + numTiles*highDetailFactor
}

func GetImageDataURI(base64Image, path string) string {
	mimeType := ImageMimeType(path)
	return fmt.Sprintf("data:%s;base64,%s", mimeType, base64Image)
}

func IsImageFile(filePath string) bool {
	ext := strings.ToLower(filepath.Ext(filePath))
	return ext == ".jpg" || ext == ".jpeg" || ext == ".png" || ext == ".webp" || ext == ".gif"
}

func ImageMimeType(filePath string) string {
	ext := strings.ToLower(filepath.Ext(filePath))
	switch ext {
	case ".jpg", ".jpeg":
		return "image/jpeg"
	case ".png":
		return "image/png"
	case ".webp":
		return "image/webp"
	case ".gif":
		return "image/gif"
	}
	return "application/octet-stream"
}


================================================
FILE: app/shared/org_user_config.go
================================================
package shared

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"time"
)

// Claude pro and max use time-based cooldowns (4 hours, 8 hours, etc.) after reaching quota
// However, we still use a relatively short cooldown so that we find out fairly quickly if the quota has reset
const claudeSubscriptionCooldownDuration = 10 * time.Minute

type OrgUserConfig struct {
	PromptedClaudeMax                   bool      `json:"promptedClaudeMax"`
	UseClaudeSubscription               bool      `json:"useClaudeSubscription"`
	ClaudeSubscriptionCooldownStartedAt time.Time `json:"claudeSubscriptionCooldownStartedAt"`
}

func (p *OrgUserConfig) IsClaudeSubscriptionCooldownActive() bool {
	if p == nil || p.ClaudeSubscriptionCooldownStartedAt.IsZero() {
		return false // never started
	}
	return time.Since(p.ClaudeSubscriptionCooldownStartedAt) < claudeSubscriptionCooldownDuration
}

func (p *OrgUserConfig) Scan(src interface{}) error {
	if src == nil {
		*p = OrgUserConfig{}
		return nil
	}
	switch s := src.(type) {
	case []byte:
		if len(s) == 0 {
			*p = OrgUserConfig{}
			return nil
		}
		return json.Unmarshal(s, p)
	case string:
		if s == "" {
			*p = OrgUserConfig{}
			return nil
		}
		return json.Unmarshal([]byte(s), p)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (p *OrgUserConfig) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return json.Marshal(p)
}


================================================
FILE: app/shared/plan_config.go
================================================
package shared

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"strings"
)

const defaultAutoDebugTries = 5

const (
	EditorTypeVim  string = "vim"
	EditorTypeNano string = "nano"
)

const defaultEditor = EditorTypeVim

type AutoModeType string

const (
	AutoModeFull   AutoModeType = "full"
	AutoModeSemi   AutoModeType = "semi"
	AutoModePlus   AutoModeType = "plus"
	AutoModeBasic  AutoModeType = "basic"
	AutoModeNone   AutoModeType = "none"
	AutoModeCustom AutoModeType = "custom"
)

var AutoModeDescriptions = map[AutoModeType]string{
	AutoModeFull:   "Fully automated: context, apply, execution and debugging",
	AutoModeSemi:   "Auto context, manual apply and execution",
	AutoModePlus:   "Manual context with auto updates and smart loading, manual apply and execution",
	AutoModeBasic:  "Manual context, manual apply and execution",
	AutoModeNone:   "Fully manual and step-by-step, one response at a time, manual builds",
	AutoModeCustom: "Choose settings individually with set-config command",
}

var AutoModeOptions = [][3]string{
	{string(AutoModeFull), "Full Auto", AutoModeDescriptions[AutoModeFull]},
	{string(AutoModeSemi), "Semi Auto", AutoModeDescriptions[AutoModeSemi]},
	{string(AutoModePlus), "Basic Plus", AutoModeDescriptions[AutoModePlus]},
	{string(AutoModeBasic), "Basic", AutoModeDescriptions[AutoModeBasic]},
	{string(AutoModeNone), "None", AutoModeDescriptions[AutoModeNone]},
	{string(AutoModeCustom), "Custom", AutoModeDescriptions[AutoModeCustom]},
}

var AutoModeLabels = map[AutoModeType]string{}

// populated in init()
var AutoModeChoices []string

type PlanConfig struct {
	AutoMode AutoModeType `json:"autoMode"`
	// QuietMode bool         `json:"quietMode"`

	Editor             string   `json:"editor"`
	EditorCommand      string   `json:"editorCommand"`
	EditorArgs         []string `json:"editorArgs"`
	EditorOpenManually bool     `json:"editorOpenManually"`

	AutoContinue bool `json:"autoContinue"`
	AutoBuild    bool `json:"autoBuild"`

	AutoUpdateContext bool `json:"autoUpdateContext"`
	AutoLoadContext   bool `json:"autoContext"`
	SmartContext      bool `json:"smartContext"`

	// AutoApproveContext bool `json:"autoApproveContext"`
	// QuietContext       bool `json:"quietContext"`

	// AutoApprovePlan bool `json:"autoApprovePlan"`

	// QuietCoding    bool `json:"quietCoding"`
	// ParallelCoding bool `json:"parallelCoding"`

	AutoApply  bool `json:"autoApply"`
	AutoCommit bool `json:"autoCommit"`
	SkipCommit bool `json:"skipCommit"`

	CanExec        bool `json:"canExec"`
	AutoExec       bool `json:"autoExec"`
	AutoDebug      bool `json:"autoDebug"`
	AutoDebugTries int  `json:"autoDebugTries"`

	AutoRevertOnRewind bool `json:"autoRevertOnRewind"`

	SkipChangesMenu bool `json:"skipChangesMenu"`

	// ReplMode    bool     `json:"replMode"`
	// DefaultRepl ReplType `json:"defaultRepl"`

	// PlainTextMode     bool `json:"plainTextMode"`
	// PlainTextCommands bool `json:"plainTextCommands"`
	// PlainTextStream   bool `json:"plainTextStream"`

}

var DefaultPlanConfig = PlanConfig{}

func (p *PlanConfig) Scan(src interface{}) error {
	if src == nil {
		*p = DefaultPlanConfig
		return nil
	}
	switch s := src.(type) {
	case []byte:
		if len(s) == 0 {
			*p = DefaultPlanConfig
			return nil
		}
		return json.Unmarshal(s, p)
	case string:
		if s == "" {
			*p = DefaultPlanConfig
			return nil
		}
		return json.Unmarshal([]byte(s), p)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (p PlanConfig) Value() (driver.Value, error) {
	return json.Marshal(p)
}

func (p *PlanConfig) SetAutoMode(mode AutoModeType) {
	p.AutoMode = mode

	switch p.AutoMode {
	case AutoModeFull:
		p.AutoContinue = true
		p.AutoBuild = true
		p.AutoUpdateContext = true
		p.AutoLoadContext = true
		p.SmartContext = true
		p.AutoApply = true
		p.AutoCommit = true
		p.CanExec = true
		p.AutoExec = true
		p.AutoDebug = true
		p.AutoDebugTries = defaultAutoDebugTries
		p.AutoRevertOnRewind = true
		p.SkipChangesMenu = false

	case AutoModeSemi:
		p.AutoContinue = true
		p.AutoBuild = true
		p.AutoUpdateContext = true
		p.AutoLoadContext = true
		p.SmartContext = true
		p.AutoApply = false
		p.AutoCommit = true
		p.CanExec = true
		p.AutoExec = false
		p.AutoDebug = false
		p.AutoRevertOnRewind = true
		p.SkipChangesMenu = false

	case AutoModePlus:
		p.AutoContinue = true
		p.AutoBuild = true
		p.AutoUpdateContext = true
		p.AutoLoadContext = false
		p.SmartContext = true
		p.AutoApply = false
		p.AutoCommit = true
		p.CanExec = true
		p.AutoExec = false
		p.AutoDebug = false
		p.AutoRevertOnRewind = true
		p.SkipChangesMenu = false

	case AutoModeBasic:
		p.AutoContinue = true
		p.AutoBuild = true
		p.AutoUpdateContext = false
		p.AutoLoadContext = false
		p.SmartContext = false
		p.AutoApply = false
		p.AutoCommit = false
		p.CanExec = false
		p.AutoExec = false
		p.AutoDebug = false
		p.AutoRevertOnRewind = true
		p.SkipChangesMenu = false

	case AutoModeNone:
		p.AutoContinue = false
		p.AutoBuild = false
		p.AutoUpdateContext = false
		p.AutoLoadContext = false
		p.SmartContext = false
		p.AutoApply = false
		p.AutoCommit = false
		p.CanExec = false
		p.AutoExec = false
		p.AutoDebug = false
		p.AutoRevertOnRewind = true
		p.SkipChangesMenu = false
	}
}

type ConfigSetting struct {
	Name            string
	Desc            string
	Visible         func(p *PlanConfig) bool
	BoolSetter      func(p *PlanConfig, enabled bool)
	IntSetter       func(p *PlanConfig, value int)
	StringSetter    func(p *PlanConfig, value string)
	EditorSetter    func(p *PlanConfig, label, command string, args []string)
	Getter          func(p *PlanConfig) string
	Choices         *[]string
	HasCustomChoice bool
	ChoiceToKey     func(choice string) string
	SortKey         string
	KeyToLabel      func(key string) string
}

var ConfigSettingsByKey = map[string]ConfigSetting{

	"automode": {
		Name: "auto-mode",
		Desc: "Use preset config based on desired level of autonomy",
		StringSetter: func(p *PlanConfig, value string) {
			p.SetAutoMode(AutoModeType(value))
		},
		Getter: func(p *PlanConfig) string {
			return string(p.AutoMode)
		},
		Choices: &AutoModeChoices,
		ChoiceToKey: func(choice string) string {
			for _, option := range AutoModeOptions {
				if strings.HasPrefix(choice, option[1]) {
					return option[0]
				}
			}
			return ""
		},
		KeyToLabel: func(key string) string {
			for _, option := range AutoModeOptions {
				if option[0] == key {
					return option[1]
				}
			}
			return ""
		},
		SortKey: "0",
	},

	"editor": {
		Name: "editor",
		Desc: "Preferred editor",
		EditorSetter: func(p *PlanConfig, label, command string, args []string) {
			p.Editor = label
			p.EditorCommand = command
			p.EditorArgs = args
		},
		Getter: func(p *PlanConfig) string {
			return p.Editor
		},
	},

	"autocontinue": {
		Name: "auto-continue",
		Desc: "Continue iterating until plan is complete",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoContinue {
				p.AutoMode = AutoModeCustom
			}

			p.AutoContinue = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoContinue)
		},
	},

	"autobuild": {
		Name: "auto-build",
		Desc: "Automatically generate pending file edits",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoBuild {
				p.AutoMode = AutoModeCustom
			}

			p.AutoBuild = enabled

			if !enabled {
				p.AutoApply = false
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoBuild)
		},
	},
	"autoupdatecontext": {
		Name: "auto-update-context",
		Desc: "Automatically update context after changes",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoUpdateContext {
				p.AutoMode = AutoModeCustom
			}
			p.AutoUpdateContext = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoUpdateContext)
		},
	},
	"autoloadcontext": {
		Name: "auto-load-context",
		Desc: "Find and load context automatically",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoLoadContext {
				p.AutoMode = AutoModeCustom
			}
			p.AutoLoadContext = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoLoadContext)
		},
	},
	"smartcontext": {
		Name: "smart-context",
		Desc: "Load only necessary context for each task in the plan",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.SmartContext {
				p.AutoMode = AutoModeCustom
			}
			p.SmartContext = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.SmartContext)
		},
	},
	"autocommit": {
		Name: "auto-commit",
		Desc: "Automatically commit changes to git after apply",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoCommit {
				p.AutoMode = AutoModeCustom
			}
			p.AutoCommit = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoCommit)
		},
	},
	"skipcommit": {
		Name: "skip-commit",
		Desc: "Skip committing changes to git after apply",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			p.SkipCommit = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.SkipCommit)
		},
	},
	"autoapply": {
		Name: "auto-apply",
		Desc: "Automatically apply changes after plan finishes",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoApply {
				p.AutoMode = AutoModeCustom
			}
			p.AutoApply = enabled

			if enabled {
				p.AutoBuild = true
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoApply)
		},
	},
	"canexec": {
		Name: "can-exec",
		Desc: "Allow execution of commands",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.CanExec {
				p.AutoMode = AutoModeCustom
			}
			p.CanExec = enabled

			if !enabled {
				p.AutoExec = false
				p.AutoDebug = false
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.CanExec)
		},
	},
	"autoexec": {
		Name: "auto-exec",
		Desc: "Automatically execute commands after plan is applied",
		Visible: func(p *PlanConfig) bool {
			return p.CanExec
		},
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoExec {
				p.AutoMode = AutoModeCustom
			}
			p.AutoExec = enabled

			if enabled {
				p.CanExec = true
			} else {
				p.AutoDebug = false
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoExec)
		},
	},
	"autodebug": {
		Name: "auto-debug",
		Desc: "Automatically debug failed commands",
		Visible: func(p *PlanConfig) bool {
			return p.AutoExec
		},
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoDebug {
				p.AutoMode = AutoModeCustom
			}
			p.AutoDebug = enabled

			if enabled {
				p.CanExec = true
				p.AutoExec = true

				if p.AutoDebugTries == 0 {
					p.AutoDebugTries = defaultAutoDebugTries
				}
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoDebug)
		},
	},
	"autodebugtries": {
		Name: "auto-debug-tries",
		Desc: "Number of auto-debug attempts",
		Visible: func(p *PlanConfig) bool {
			return p.AutoDebug
		},
		IntSetter: func(p *PlanConfig, value int) {
			if value != p.AutoDebugTries {
				p.AutoMode = AutoModeCustom
			}
			p.AutoDebugTries = value

			if p.AutoDebugTries == 0 {
				p.AutoDebug = false
			} else {
				p.CanExec = true
				p.AutoExec = true
				p.AutoDebug = true
			}
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%d", p.AutoDebugTries)
		},
	},
	"autorevert": {
		Name: "auto-revert",
		Desc: "Automatically update project files when rewinding plan",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			if enabled != p.AutoRevertOnRewind {
				p.AutoMode = AutoModeCustom
			}
			p.AutoRevertOnRewind = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.AutoRevertOnRewind)
		},
	},
	"skipchangesmenu": {
		Name: "skip-changes-menu",
		Desc: "Skip interactive menu when response finishes and changes are pending",
		BoolSetter: func(p *PlanConfig, enabled bool) {
			p.SkipChangesMenu = enabled
		},
		Getter: func(p *PlanConfig) string {
			return fmt.Sprintf("%t", p.SkipChangesMenu)
		},
	},
}

func init() {
	DefaultPlanConfig.SetAutoMode(AutoModeSemi)

	for _, choice := range AutoModeOptions {
		AutoModeChoices = append(AutoModeChoices, fmt.Sprintf("%s → %s", choice[1], choice[2]))
		AutoModeLabels[AutoModeType(choice[0])] = choice[1]
	}
}


================================================
FILE: app/shared/plan_model_settings.go
================================================
package shared

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"time"
)

type PlanSettings struct {
	ModelPackName               string                              `json:"modelPackName"`
	ModelPack                   *ModelPack                          `json:"modelPack"`
	CustomModelPacks            []*ModelPack                        `json:"customModelPacks"`
	CustomModels                []*CustomModel                      `json:"customModels"`
	CustomModelsById            map[ModelId]*CustomModel            `json:"customModelsById"`
	CustomProviders             []*CustomProvider                   `json:"customProviders"`
	UsesCustomProviderByModelId map[ModelId][]BaseModelUsesProvider `json:"usesCustomProviderByModelId"`
	IsCloud                     bool                                `json:"isCloud"`
	Configured                  bool                                `json:"configured"`
	UpdatedAt                   time.Time                           `json:"updatedAt"`
}

func (p *PlanSettings) Configure(customModelPacks []*ModelPack, customModels []*CustomModel, customProviders []*CustomProvider, isCloud bool) {
	p.CustomModelPacks = customModelPacks
	p.CustomModels = customModels
	p.CustomProviders = customProviders
	p.IsCloud = isCloud
	p.Configured = true
	p.CustomModelsById = map[ModelId]*CustomModel{}
	p.UsesCustomProviderByModelId = map[ModelId][]BaseModelUsesProvider{}

	for _, customModel := range customModels {
		p.CustomModelsById[customModel.ModelId] = customModel
		p.UsesCustomProviderByModelId[customModel.ModelId] = customModel.Providers
	}

}

func (p PlanSettings) GetModelPack() *ModelPack {
	if !p.Configured {
		panic("PlanSettings not configured")
	}

	customModelPacks := p.CustomModelPacks
	isCloud := p.IsCloud

	fillDefault := true // seems best to make this the default behavior, but keeping the switch just in case

	if p.ModelPack != nil {
		return p.ModelPack
	}

	for _, builtInModelPack := range BuiltInModelPacks {
		if isCloud && builtInModelPack.LocalProvider != "" {
			continue
		}

		if builtInModelPack.Name == p.ModelPackName {
			return builtInModelPack
		}
	}

	for _, customModelPack := range customModelPacks {
		if customModelPack.Name == p.ModelPackName {
			return customModelPack
		}
	}

	if fillDefault {
		return DefaultModelPack
	}

	return nil
}

func (p *PlanSettings) SetModelPackByName(modelPackName string) {
	p.ModelPackName = modelPackName
	p.ModelPack = nil
}

func (p *PlanSettings) SetCustomModelPack(modelPack *ModelPack) {
	p.ModelPackName = ""
	p.ModelPack = modelPack
}

func (p *PlanSettings) Scan(src interface{}) error {
	if src == nil {
		return nil
	}
	switch s := src.(type) {
	case []byte:
		return json.Unmarshal(s, p)
	case string:
		return json.Unmarshal([]byte(s), p)
	default:
		return fmt.Errorf("unsupported data type: %T", src)
	}
}

func (p PlanSettings) Value() (driver.Value, error) {
	return json.Marshal(p)
}

func (ps PlanSettings) GetPlannerMaxTokens() int {
	modelPack := ps.GetModelPack()
	planner := modelPack.Planner
	fallback := planner.GetFinalLargeContextFallback()
	baseConfig := fallback.GetSharedBaseConfig(&ps)
	return baseConfig.MaxTokens
}

func (ps PlanSettings) GetPlannerMaxReservedOutputTokens() int {
	modelPack := ps.GetModelPack()
	planner := modelPack.Planner
	return planner.GetFinalLargeContextFallback().GetReservedOutputTokens(ps.CustomModelsById)
}

func (ps PlanSettings) GetArchitectMaxTokens() int {
	modelPack := ps.GetModelPack()
	architect := modelPack.GetArchitect()
	fallback := architect.GetFinalLargeContextFallback()
	return fallback.GetSharedBaseConfig(&ps).MaxTokens
}

func (ps PlanSettings) GetArchitectMaxReservedOutputTokens() int {
	modelPack := ps.GetModelPack()
	architect := modelPack.GetArchitect()
	fallback := architect.GetFinalLargeContextFallback()
	return fallback.GetReservedOutputTokens(ps.CustomModelsById)
}

func (ps PlanSettings) GetCoderMaxTokens() int {
	modelPack := ps.GetModelPack()
	coder := modelPack.GetCoder()
	fallback := coder.GetFinalLargeContextFallback()
	return fallback.GetSharedBaseConfig(&ps).MaxTokens
}

func (ps PlanSettings) GetCoderMaxReservedOutputTokens() int {
	modelPack := ps.GetModelPack()
	coder := modelPack.GetCoder()
	fallback := coder.GetFinalLargeContextFallback()
	return fallback.GetReservedOutputTokens(ps.CustomModelsById)
}

func (ps PlanSettings) GetWholeFileBuilderMaxTokens() int {
	modelPack := ps.GetModelPack()
	builder := modelPack.GetWholeFileBuilder()
	fallback := builder.GetFinalLargeContextFallback()
	return fallback.GetSharedBaseConfig(&ps).MaxTokens
}

func (ps PlanSettings) GetWholeFileBuilderMaxReservedOutputTokens() int {
	modelPack := ps.GetModelPack()
	builder := modelPack.GetWholeFileBuilder()
	fallback := builder.GetFinalLargeOutputFallback()
	return fallback.GetReservedOutputTokens(ps.CustomModelsById)
}

func (ps PlanSettings) GetPlannerMaxConvoTokens() int {
	modelPack := ps.GetModelPack()

	// for max convo tokens, we use the planner's default max convo tokens, *not* the fallback, so that we don't end up switching to the fallback just based on the conversation length
	planner := modelPack.Planner
	if planner.MaxConvoTokens != 0 {
		return planner.MaxConvoTokens
	}

	return planner.GetSharedBaseConfig(&ps).DefaultMaxConvoTokens
}

func (ps PlanSettings) GetPlannerEffectiveMaxTokens() int {
	maxPlannerTokens := ps.GetPlannerMaxTokens()
	maxReservedOutputTokens := ps.GetPlannerMaxReservedOutputTokens()

	return maxPlannerTokens - maxReservedOutputTokens
}

func (ps PlanSettings) GetArchitectEffectiveMaxTokens() int {
	maxArchitectTokens := ps.GetArchitectMaxTokens()
	maxReservedOutputTokens := ps.GetArchitectMaxReservedOutputTokens()

	return maxArchitectTokens - maxReservedOutputTokens
}

func (ps PlanSettings) GetCoderEffectiveMaxTokens() int {
	maxCoderTokens := ps.GetCoderMaxTokens()
	maxReservedOutputTokens := ps.GetCoderMaxReservedOutputTokens()

	return maxCoderTokens - maxReservedOutputTokens
}

func (ps PlanSettings) GetWholeFileBuilderEffectiveMaxTokens() int {
	maxWholeFileBuilderTokens := ps.GetWholeFileBuilderMaxTokens()
	maxReservedOutputTokens := ps.GetWholeFileBuilderMaxReservedOutputTokens()

	return maxWholeFileBuilderTokens - maxReservedOutputTokens
}

func (ps PlanSettings) GetModelProviderOptions() ModelProviderOptions {
	opts := ModelProviderOptions{}

	ms := ps.GetModelPack()
	if ms == nil {
		ms = DefaultModelPack
	}

	opts = opts.Condense(
		ms.Planner.GetModelProviderOptions(&ps),
		ms.Builder.GetModelProviderOptions(&ps),
		ms.PlanSummary.GetModelProviderOptions(&ps),
		ms.Namer.GetModelProviderOptions(&ps),
		ms.CommitMsg.GetModelProviderOptions(&ps),
		ms.ExecStatus.GetModelProviderOptions(&ps),
		// optional roles
		getOptionalModelProviderOptions(&ps, ms.WholeFileBuilder),
		getOptionalModelProviderOptions(&ps, ms.Architect),
		getOptionalModelProviderOptions(&ps, ms.Coder),
	)

	return opts
}

func (ps *PlanSettings) Equals(other *PlanSettings) bool {
	return ps.GetModelPack().Equals(other.GetModelPack())
}

func (ps PlanSettings) ForCompare() PlanSettings {
	ps.UpdatedAt = time.Time{}
	ps.CustomModelPacks = nil
	ps.CustomModels = nil
	ps.CustomProviders = nil
	ps.IsCloud = false
	ps.Configured = false
	return ps
}

func (ps PlanSettings) DeepCopy() (*PlanSettings, error) {
	bytes, err := json.Marshal(ps)
	if err != nil {
		return nil, fmt.Errorf("error marshalling plan settings: %v", err)
	}
	var copy PlanSettings
	err = json.Unmarshal(bytes, &copy)
	if err != nil {
		return nil, fmt.Errorf("error unmarshalling plan settings: %v", err)
	}
	return &copy, nil
}

func getOptionalModelProviderOptions(settings *PlanSettings, cfg *ModelRoleConfig) ModelProviderOptions {
	if cfg == nil {
		return ModelProviderOptions{}
	}
	return cfg.GetModelProviderOptions(settings)
}


================================================
FILE: app/shared/plan_result.go
================================================
package shared

import (
	"time"
)

func (rep *Replacement) IsPending() bool {
	return !rep.Failed && rep.RejectedAt == nil
}

func (rep *Replacement) SetRejected(t time.Time) {
	rep.RejectedAt = &t
}

func (res *PlanFileResult) NumPendingReplacements() int {
	numPending := 0
	for _, rep := range res.Replacements {
		if rep.IsPending() {
			numPending++
		}
	}
	return numPending
}

func (res *PlanFileResult) IsPending() bool {
	return res.AppliedAt == nil && res.RejectedAt == nil && (res.Content != "" || res.NumPendingReplacements() > 0 || res.RemovedFile)
}

func (p PlanFileResultsByPath) SetApplied(t time.Time) {
	for _, planResults := range p {
		for _, planResult := range planResults {
			if !planResult.IsPending() {
				continue
			}
			planResult.AppliedAt = &t
		}
	}
}

func (p PlanFileResultsByPath) SetRejected(t time.Time) int {
	numRejected := 0
	for _, planResults := range p {
		for _, planResult := range planResults {
			if !planResult.IsPending() {
				continue
			}
			planResult.RejectedAt = &t
			numRejected++

			for _, rep := range planResult.Replacements {
				rep.SetRejected(t)
			}
		}
	}
	return numRejected
}

func (p PlanFileResultsByPath) NumPending() int {
	numPending := 0
	for _, planResults := range p {
		for _, planResult := range planResults {
			if planResult.IsPending() {
				numPending++
			}
		}
	}
	return numPending
}

func (p PlanFileResultsByPath) ConflictedPaths(filesByPath map[string]string) map[string]bool {
	conflictedPaths := map[string]bool{}

	for path, body := range filesByPath {
		planRes := p[path]

		// log.Println("Checking for conflicts in path:", path)
		// log.Println("Body:")
		// log.Println(body)

		if planRes == nil {
			continue
		}

		updated := body

		noConflicts := true
		for _, res := range planRes {

			// log.Println("res:", res.Id)
			if len(res.Replacements) == 0 {
				continue
			}

			maybeWithLineNums := updated
			if res.ReplaceWithLineNums {
				maybeWithLineNums = string(AddLineNums(updated))
			}

			var succeeded bool
			updated, succeeded = ApplyReplacements(maybeWithLineNums, res.Replacements, false)

			updated = RemoveLineNums(LineNumberedTextType(updated))

			// log.Println("updated:", updated)
			// log.Println("succeeded:", succeeded)

			if !succeeded {
				noConflicts = false
				break
			}
		}

		// log.Println("No conflicts:", noConflicts)

		if !noConflicts {
			conflictedPaths[path] = true
		}
	}

	return conflictedPaths
}

func (r PlanResult) NumPendingForPath(path string) int {
	res := 0
	results := r.FileResultsByPath[path]
	for _, result := range results {
		if result.IsPending() {
			res += result.NumPendingReplacements()
		}
	}
	return res
}

func (desc *ConvoMessageDescription) NumBuildsPendingByPath() map[string]int {
	res := map[string]int{}
	if (!desc.DidBuild && len(desc.Operations) > 0) || len(desc.BuildPathsInvalidated) > 0 {
		for _, op := range desc.Operations {
			res[op.Path]++
		}
	}
	return res
}

func (desc *ConvoMessageDescription) HasPendingBuilds() bool {
	return len(desc.NumBuildsPendingByPath()) > 0
}

func NumBuildsPendingByPath(planDescs []*ConvoMessageDescription) map[string]int {
	res := map[string]int{}
	for _, desc := range planDescs {
		for file, num := range desc.NumBuildsPendingByPath() {
			res[file] += num
		}
	}
	return res
}

func HasPendingBuilds(planDescs []*ConvoMessageDescription) bool {
	return len(NumBuildsPendingByPath(planDescs)) > 0
}

func (c *CurrentPlanState) NumBuildsPendingByPath() map[string]int {
	return NumBuildsPendingByPath(c.ConvoMessageDescriptions)
}

func (c *CurrentPlanState) HasPendingBuilds() bool {
	return len(c.NumBuildsPendingByPath()) > 0
}


================================================
FILE: app/shared/plan_result_exec_history.go
================================================
package shared

func (state *CurrentPlanState) ExecHistory() string {
	execHistory := ""

	if state.PlanResult == nil {
		return execHistory
	}

	for _, result := range state.PlanResult.Results {
		if result.Path == "_apply.sh" && result.AppliedAt != nil {
			execHistory += "Previously executed _apply.sh:\n\n```\n" + result.Content + "\n```\n\n"
		}
	}

	return execHistory
}


================================================
FILE: app/shared/plan_result_pending_summary.go
================================================
package shared

import (
	"fmt"
	"log"
	"sort"
	"strings"
)

func (state *CurrentPlanState) PendingChangesSummaryForBuild() string {
	return state.pendingChangesSummary(false, "")
}

func (state *CurrentPlanState) PendingChangesSummaryForApply(commitSummary string) string {
	return state.pendingChangesSummary(true, commitSummary)
}

func (state *CurrentPlanState) pendingChangesSummary(forApply bool, commitSummary string) string {
	var msgs []string

	descByConvoMessageId := make(map[string]*ConvoMessageDescription)

	for _, desc := range state.ConvoMessageDescriptions {
		if desc.ConvoMessageId == "" {
			log.Println("Warning: ConvoMessageId is empty for description:", desc)
			continue
		}

		descByConvoMessageId[desc.ConvoMessageId] = desc
	}

	type changeset struct {
		descsSet map[string]bool
		descs    []*ConvoMessageDescription
		results  []*PlanFileResult
	}
	byDescs := map[string]*changeset{}

	for _, result := range state.PlanResult.Results {
		// log.Println("result:")
		// spew.Dump(result)

		convoIds := map[string]bool{}
		if descByConvoMessageId[result.ConvoMessageId] != nil {
			convoIds[result.ConvoMessageId] = true
		}
		var uniqueConvoIds []string
		for convoId := range convoIds {
			uniqueConvoIds = append(uniqueConvoIds, convoId)
		}

		composite := strings.Join(uniqueConvoIds, "|")
		if _, ok := byDescs[composite]; !ok {
			byDescs[composite] = &changeset{
				descsSet: make(map[string]bool),
			}
		}

		ch := byDescs[composite]
		ch.results = append(byDescs[composite].results, result)

		// log.Println("uniqueConvoIds:", uniqueConvoIds)

		for _, convoMessageId := range uniqueConvoIds {
			if desc, ok := descByConvoMessageId[convoMessageId]; ok {
				if !ch.descsSet[convoMessageId] && (!(desc.DidBuild && !forApply) || len(desc.BuildPathsInvalidated) > 0) {
					ch.descs = append(ch.descs, desc)
					ch.descsSet[convoMessageId] = true
				}
			} else {
				log.Println("Warning: no description for convo message id:", convoMessageId)
			}
		}
	}

	var sortedChangesets []*changeset
	for _, ch := range byDescs {
		sortedChangesets = append(sortedChangesets, ch)
	}

	sort.Slice(sortedChangesets, func(i, j int) bool {
		// put changesets with no descriptions last, otherwise sort by date
		if len(sortedChangesets[i].descs) == 0 {
			return false
		}
		if len(sortedChangesets[j].descs) == 0 {
			return true
		}
		return sortedChangesets[i].descs[0].CreatedAt.Before(sortedChangesets[j].descs[0].CreatedAt)
	})

	isRebuild := true
	rebuildPathsSet := make(map[string]bool)

	if forApply {
		msgs = append(msgs, "🤖 Plandex → "+commitSummary)
	} else {
		for _, ch := range sortedChangesets {
			allRebuild := true
			for _, desc := range ch.descs {
				if len(desc.BuildPathsInvalidated) == 0 {
					allRebuild = false
					break
				} else {
					for path := range desc.BuildPathsInvalidated {
						rebuildPathsSet[path] = true
					}
				}
			}
			if !allRebuild {
				isRebuild = false
				break
			}
		}

		if isRebuild {
			msgs = append(msgs, "🏗️  Rebuild paths invalidated by context update")
			for path := range rebuildPathsSet {
				msgs = append(msgs, fmt.Sprintf("  • rebuild → %s", path))
			}
			return strings.Join(msgs, "\n")
		}

		msgs = append(msgs, "🏗️  Build pending changes")
		currentFiles := state.CurrentPlanFiles.Files
		var sortedFiles []string
		for path := range currentFiles {
			sortedFiles = append(sortedFiles, path)
		}
		sort.Strings(sortedFiles)
		for _, path := range sortedFiles {
			msgs = append(msgs, fmt.Sprintf(" • 📄 %s", path))
		}
		return strings.Join(msgs, "\n")
	}

	for _, ch := range sortedChangesets {
		var descMsgs []string

		if len(ch.descs) <= 1 {
			continue
		}

		for _, desc := range ch.descs {
			descMsgs = append(descMsgs, fmt.Sprintf("  ✏️  %s", desc.CommitMsg))
		}

		msgs = append(msgs, descMsgs...)

		// for an apply commit message, we don't need to list file updates
		if forApply {
			continue
		}

		pendingNewFilesSet := make(map[string]bool)
		pendingReplacementPathsSet := make(map[string]bool)
		pendingReplacementsByPath := make(map[string][]*Replacement)

		for _, result := range ch.results {

			if result.IsPending() {
				if len(result.Replacements) == 0 && result.Content != "" {
					pendingNewFilesSet[result.Path] = true
				} else {
					pendingReplacementPathsSet[result.Path] = true
					pendingReplacementsByPath[result.Path] = append(pendingReplacementsByPath[result.Path], result.Replacements...)
				}
			}
		}

		if len(pendingNewFilesSet) == 0 && len(pendingReplacementPathsSet) == 0 {
			continue
		}

		var pendingNewFiles []string
		var pendingReplacementPaths []string

		for path := range pendingNewFilesSet {
			pendingNewFiles = append(pendingNewFiles, path)
		}

		for path := range pendingReplacementPathsSet {
			pendingReplacementPaths = append(pendingReplacementPaths, path)
		}

		sort.Slice(pendingReplacementPaths, func(i, j int) bool {
			return pendingReplacementPaths[i] < pendingReplacementPaths[j]
		})

		sort.Slice(pendingNewFiles, func(i, j int) bool {
			return pendingNewFiles[i] < pendingNewFiles[j]
		})

		if len(pendingNewFiles) > 0 {
			for _, path := range pendingNewFiles {
				msgs = append(msgs, fmt.Sprintf("    • new file → %s", path))
			}
		}

		if len(pendingReplacementPaths) > 0 {
			for _, path := range pendingReplacementPaths {
				msgs = append(msgs, fmt.Sprintf("    • edit → %s", path))
			}

		}

	}
	return strings.Join(msgs, "\n")
}


================================================
FILE: app/shared/plan_result_replacements.go
================================================
package shared

import (
	"fmt"
	"log"
	"strings"
	"time"

	"github.com/davecgh/go-spew/spew"
)

func ApplyReplacements(content string, replacements []*Replacement, setFailed bool) (string, bool) {
	return applyReplacements(content, replacements, setFailed, false)
}

func ApplyReplacementsVerbose(content string, replacements []*Replacement, setFailed bool) (string, bool) {
	return applyReplacements(content, replacements, setFailed, true)
}

func applyReplacements(content string, replacements []*Replacement, setFailed, verbose bool) (string, bool) {
	apply := func(replacements []*Replacement) (string, int) {
		if verbose {
			log.Println("Applying replacements")
			log.Println("original content:\n", content)
		}

		updated := content

		lastInsertedIdx := 0

		for i, replacement := range replacements {
			if verbose {
				log.Println("replacement.Old:\n", replacement.Old)
				log.Println("updated:\n", updated)
				log.Println("lastInsertedIdx:", lastInsertedIdx)
			}

			pre := updated[:lastInsertedIdx]
			sub := updated[lastInsertedIdx:]

			var originalIdx int

			if replacement.EntireFile {
				originalIdx = 0
			} else {
				originalIdx = strings.Index(sub, replacement.Old)
			}

			if verbose {
				log.Println("originalIdx:", originalIdx)
			}

			// only for use with full replacements, which we aren't using now
			// if originalIdx == -1 {
			// 	originalIdx = getUniqueFuzzyIndex(updated, replacement.Old)
			// }

			if originalIdx == -1 {
				if setFailed {
					replacement.Failed = true
				}

				log.Println("Replacement failed at index:", i)
				log.Println("replacement.Old:")
				log.Println(replacement.Old)

				log.Println("Updated:")
				log.Println(updated)

				if verbose {
					log.Println("All replacements:")
					log.Println(spew.Sdump(replacements))
				}

				return updated, i

			} else if replacement.EntireFile {
				updated = replacement.New
				lastInsertedIdx = 0
			} else {
				if verbose {
					log.Printf("originalIdx: %d, len(replacement.Old): %d\n", originalIdx, len(replacement.Old))
					log.Println("Old: ", replacement.Old)
					log.Println("New: ", replacement.New)
				}
				replaced := strings.Replace(sub, replacement.Old, replacement.New, 1)

				if verbose {
					log.Println("replaced:")
					log.Println(replaced)
				}

				updated = pre + replaced

				if verbose {
					log.Printf("lastInsertedIdx: %d, originalIdx: %d, len(replacement.New): %d\n", lastInsertedIdx, originalIdx, len(replacement.New))
					log.Println("updated after replacement:")
					log.Println(updated)
				}

				lastInsertedIdx = lastInsertedIdx + originalIdx + len(replacement.New)
			}
		}

		return updated, -1
	}

	res, failedAtIndex := apply(replacements)

	return res, failedAtIndex == -1

	// for {

	// 	if failedAtIndex == 0 {
	// 		return res, false
	// 	} else if failedAtIndex > 0 {
	// 		// check if there's overlap between the failed replacement and the previous replacement
	// 		// if there is, remove the previous one and try again
	// 		failed := replacements[failedAtIndex]
	// 		prev := replacements[failedAtIndex-1]

	// 		hasOverlap := failed.StreamedChange.Old.StartLine <= prev.StreamedChange.Old.EndLine

	// 		if hasOverlap {
	// 			replacements = append(replacements[:failedAtIndex-1], replacements[failedAtIndex:]...)

	// 			continue
	// 		} else {
	// 			return res, false
	// 		}

	// 	} else {
	// 		return res, true
	// 	}
	// }

}

func (planState *CurrentPlanState) GetFiles() (*CurrentPlanFiles, error) {
	return planState.GetFilesBeforeReplacement("")
}

func (planState *CurrentPlanState) GetFilesBeforeReplacement(
	replacementId string,
) (*CurrentPlanFiles, error) {
	// log.Println("GetFilesBeforeReplacement")

	planRes := planState.PlanResult

	files := make(map[string]string)
	shas := make(map[string]string)
	updatedAtByPath := make(map[string]time.Time)
	removedByPath := make(map[string]bool)

	for path, planResults := range planRes.FileResultsByPath {
		updated := files[path]
		// log.Println("path: ", path)

		// spew.Dump(planResults)
		// log.Println("before PlanResLoop updated:")
		// log.Println(updated)

	PlanResLoop:
		for _, planRes := range planResults {

			// log.Println("planRes: ", planRes.Id)
			// log.Println(spew.Sdump(planRes))

			if !planRes.IsPending() {
				// log.Println("Plan result is not pending -- continuing loop")
				continue
			}

			if planRes.RemovedFile {
				updated = ""
				delete(files, path)
				delete(shas, path)
				delete(updatedAtByPath, path)
				removedByPath[path] = true
				continue
			}

			if len(planRes.Replacements) == 0 {
				if updated != "" {
					log.Println("plan updates out of order:", path)
					log.Println("updated:")
					log.Println(updated)
					log.Println("planRes.Content:")
					log.Println(planRes.Content)
					return nil, fmt.Errorf("plan updates out of order: %s", path)
				}

				updated = planRes.Content
				files[path] = updated
				updatedAtByPath[path] = planRes.CreatedAt
				delete(removedByPath, path)

				continue
			} else if updated == "" {
				context := planState.ContextsByPath[path]

				if context == nil {
					// spew.Dump(planRes)

					return nil, fmt.Errorf("no context for path: %s", path)
				}

				// log.Println("No updated content -- setting to context body")

				updated = context.Body
				shas[path] = context.Sha

				// log.Println("setting updated content to context body")
				// log.Println(updated)
			}

			replacements := []*Replacement{}
			foundTarget := false
			for _, replacement := range planRes.Replacements {
				if replacement.Id == replacementId {
					// log.Println("Found target replacement")
					foundTarget = true
					break
				}
				replacements = append(replacements, replacement)
			}

			if len(replacements) > 0 {

				var allSucceeded bool

				maybeWithLineNums := updated
				if planRes.ReplaceWithLineNums {
					maybeWithLineNums = string(AddLineNums(maybeWithLineNums))
				}

				// log.Println("Before replacements. updated:")
				// log.Println(updated)

				updated, allSucceeded = ApplyReplacements(maybeWithLineNums, replacements, false)

				updated = string(RemoveLineNums(LineNumberedTextType(updated)))

				if !allSucceeded {
					log.Println("Failed to apply replacements")

					// log.Println("replacements:")
					// log.Println(spew.Sdump(replacements))

					// log.Println("updated:")
					// log.Println(updated)

					return nil, fmt.Errorf("plan replacement failed - %s", path)
				}

				// log.Println("Updated content: ")
				// log.Println(updated)

				updatedAtByPath[path] = planRes.CreatedAt
			}

			if foundTarget {
				break PlanResLoop
			}
		}

		// log.Println("Setting updated content for path: ", path)

		files[path] = updated
	}

	return &CurrentPlanFiles{Files: files, UpdatedAtByPath: updatedAtByPath, Removed: removedByPath}, nil
}


================================================
FILE: app/shared/plan_status.go
================================================
package shared

type PlanStatus string

const (
	PlanStatusDraft       PlanStatus = "draft"
	PlanStatusReplying    PlanStatus = "replying"
	PlanStatusDescribing  PlanStatus = "describing"
	PlanStatusBuilding    PlanStatus = "building"
	PlanStatusMissingFile PlanStatus = "missingFile"
	PlanStatusFinished    PlanStatus = "finished"
	PlanStatusStopped     PlanStatus = "stopped"
	PlanStatusError       PlanStatus = "error"
)


================================================
FILE: app/shared/rbac.go
================================================
package shared

import (
	"strings"
)

type Permission string

const (
	PermissionDeleteOrg             Permission = "delete_org"
	PermissionManageEmailDomainAuth Permission = "manage_email_domain_auth"
	PermissionManageBilling         Permission = "manage_billing"
	PermissionInviteUser            Permission = "invite_user"
	PermissionRemoveUser            Permission = "remove_user"
	PermissionSetUserRole           Permission = "set_user_role"
	PermissionListOrgRoles          Permission = "list_org_roles"
	PermissionCreateProject         Permission = "create_project"
	PermissionRenameAnyProject      Permission = "rename_any_project"
	PermissionDeleteAnyProject      Permission = "delete_any_project"
	PermissionCreatePlan            Permission = "create_plan"
	PermissionManageAnyPlanShares   Permission = "manage_any_plan_shares"
	PermissionRenameAnyPlan         Permission = "rename_any_plan"
	PermissionDeleteAnyPlan         Permission = "delete_any_plan"
	PermissionUpdateAnyPlan         Permission = "update_any_plan"
	PermissionArchiveAnyPlan        Permission = "archive_any_plan"
)

type Permissions map[string]bool

func (perms Permissions) HasPermission(permission Permission) bool {
	for p := range perms {
		split := strings.Split(p, "|")
		perm := Permission(split[0])

		if perm == permission {
			return true
		}
	}
	return false
}

func (perms Permissions) HasPermissionForResource(permission Permission, resourceId string) bool {
	for p := range perms {
		split := strings.Split(p, "|")
		perm := Permission(split[0])
		resId := split[1]

		if perm == permission && resId == resourceId {
			return true
		}
	}
	return false
}


================================================
FILE: app/shared/req_res.go
================================================
package shared

import (
	"time"

	"github.com/sashabaranov/go-openai"
	"github.com/shopspring/decimal"
)

type CreateEmailVerificationRequest struct {
	Email         string `json:"email"`
	UserId        string `json:"userId"`
	RequireUser   bool   `json:"requireUser"`
	RequireNoUser bool   `json:"requireNoUser"`
}

type CreateEmailVerificationResponse struct {
	HasAccount  bool `json:"hasAccount"`
	IsLocalMode bool `json:"isLocalMode"`
}

type VerifyEmailPinRequest struct {
	Email string `json:"email"`
	Pin   string `json:"pin"`
}

type SignInRequest struct {
	Email        string `json:"email"`
	Pin          string `json:"pin"`
	IsSignInCode bool   `json:"isSignInCode"`
}

type UiSignInToken struct {
	Pin        string `json:"pin"`
	RedirectTo string `json:"redirectTo"`
}

type CreateAccountRequest struct {
	Email    string `json:"email"`
	Pin      string `json:"pin"`
	UserName string `json:"userName"`
}

type SessionResponse struct {
	UserId      string `json:"userId"`
	Token       string `json:"token"`
	Email       string `json:"email"`
	UserName    string `json:"userName"`
	Orgs        []*Org `json:"orgs"`
	IsLocalMode bool   `json:"isLocalMode"`
}

type CreateOrgRequest struct {
	Name               string `json:"name"`
	AutoAddDomainUsers bool   `json:"autoAddDomainUsers"`
}

type ConvertTrialRequest struct {
	Email                 string `json:"email"`
	Pin                   string `json:"pin"`
	UserName              string `json:"userName"`
	OrgName               string `json:"orgName"`
	OrgAutoAddDomainUsers bool   `json:"orgAutoAddDomainUsers"`
}

type CreateOrgResponse struct {
	Id string `json:"id"`
}

type InviteRequest struct {
	Email     string `json:"email"`
	Name      string `json:"name"`
	OrgRoleId string `json:"orgRoleId"`
}

type CreateProjectRequest struct {
	Name string `json:"name"`
}

type CreateProjectResponse struct {
	Id string `json:"id"`
}

type SetProjectPlanRequest struct {
	PlanId string `json:"planId"`
}

type RenameProjectRequest struct {
	Name string `json:"name"`
}

type CreatePlanRequest struct {
	Name string `json:"name"`
}

type CreatePlanResponse struct {
	Id   string `json:"id"`
	Name string `json:"name"`
}

type GetCurrentBranchByPlanIdRequest struct {
	CurrentBranchByPlanId map[string]string `json:"currentBranchByPlanId"`
}

type ListPlansRunningResponse struct {
	Branches                   []*Branch            `json:"branches"`
	StreamStartedAtByBranchId  map[string]time.Time `json:"streamStartedAtByBranchId"`
	StreamFinishedAtByBranchId map[string]time.Time `json:"streamFinishedAtByBranchId"`
	StreamIdByBranchId         map[string]string    `json:"streamIdByBranchId"`
	PlansById                  map[string]*Plan     `json:"plansById"`
}

type BuildMode string

const (
	BuildModeAuto BuildMode = "auto"
	BuildModeNone BuildMode = "none"
)

type TellPlanRequest struct {
	Prompt         string    `json:"prompt"`
	BuildMode      BuildMode `json:"buildMode"`
	ConnectStream  bool      `json:"connectStream"`
	AutoContinue   bool      `json:"autoContinue"`
	IsUserContinue bool      `json:"isUserContinue"`
	IsUserDebug    bool      `json:"isUserDebug"`
	IsApplyDebug   bool      `json:"isApplyDebug"`
	IsChatOnly     bool      `json:"isChatOnly"`
	AutoContext    bool      `json:"autoContext"`
	SmartContext   bool      `json:"smartContext"`
	ExecEnabled    bool      `json:"execEnabled"`
	OsDetails      string    `json:"osDetails"`

	ApiKeys     map[string]string `json:"apiKeys"`     // deprecated
	OpenAIOrgId string            `json:"openAIOrgId"` // deprecated

	AuthVars map[string]string `json:"authVars"`

	ProjectPaths           map[string]bool `json:"projectPaths"`
	IsImplementationOfChat bool            `json:"isImplementationOfChat"`
	IsGitRepo              bool            `json:"isGitRepo"`
	SessionId              string          `json:"sessionId"`
}

type BuildPlanRequest struct {
	ConnectStream bool `json:"connectStream"`

	ApiKeys     map[string]string `json:"apiKeys"`     // deprecated
	OpenAIOrgId string            `json:"openAIOrgId"` // deprecated

	AuthVars map[string]string `json:"authVars"`

	ProjectPaths map[string]bool `json:"projectPaths"`
	SessionId    string          `json:"sessionId"`
}

const NoBuildsErr string = "No builds"

type RespondMissingFileChoice string

const (
	RespondMissingFileChoiceLoad      RespondMissingFileChoice = "load"
	RespondMissingFileChoiceSkip      RespondMissingFileChoice = "skip"
	RespondMissingFileChoiceOverwrite RespondMissingFileChoice = "overwrite"
)

type RespondMissingFileRequest struct {
	Choice   RespondMissingFileChoice `json:"choice"`
	FilePath string                   `json:"filePath"`
	Body     string                   `json:"body"`
}

type FileMapInputs map[string]string

func (f FileMapInputs) NumFiles() int {
	return len(f)
}

func (f FileMapInputs) TotalSize() int64 {
	var totalSize int64
	for _, body := range f {
		totalSize += int64(len(body))
	}
	return totalSize
}

type LoadContextParams struct {
	ContextType     ContextType           `json:"contextType"`
	Name            string                `json:"name"`
	Url             string                `json:"url"`
	FilePath        string                `json:"file_path"`
	Body            string                `json:"body"`
	ForceSkipIgnore bool                  `json:"forceSkipIgnore"`
	ImageDetail     openai.ImageURLDetail `json:"imageDetail"`
	AutoLoaded      bool                  `json:"autoLoaded"`

	InputShas   map[string]string `json:"inputShas"`
	InputTokens map[string]int    `json:"inputTokens"`
	InputSizes  map[string]int64  `json:"inputSizes"`
	MapBodies   FileMapBodies     `json:"mapBodies"`

	// For naming piped data
	ApiKeys     map[string]string `json:"apiKeys"`     // deprecated
	OpenAIBase  string            `json:"openAIBase"`  // deprecated
	OpenAIOrgId string            `json:"openAIOrgId"` // deprecated

	AuthVars map[string]string `json:"authVars"`

	SessionId string `json:"sessionId"`
}

type LoadContextRequest []*LoadContextParams

type LoadContextResponse struct {
	TokensAdded       int    `json:"tokensAdded"`
	TotalTokens       int    `json:"totalTokens"`
	MaxTokensExceeded bool   `json:"maxTokensExceeded"`
	MaxTokens         int    `json:"maxTokens"`
	Msg               string `json:"msg"`
}

type UpdateContextParams struct {
	Body            string            `json:"body"`
	InputShas       map[string]string `json:"inputShas"`
	InputTokens     map[string]int    `json:"inputTokens"`
	InputSizes      map[string]int64  `json:"inputSizes"`
	MapBodies       FileMapBodies     `json:"mapBodies"`
	RemovedMapPaths []string          `json:"removedMapPaths"`
}

type GetFileMapRequest struct {
	MapInputs FileMapInputs `json:"mapInputs"`
}

type GetFileMapResponse struct {
	MapBodies FileMapBodies `json:"mapBodies"`
}

type LoadCachedFileMapRequest struct {
	FilePaths []string `json:"filePaths"`
}

type LoadCachedFileMapResponse struct {
	LoadRes      *LoadContextResponse `json:"loadRes"`
	CachedByPath map[string]bool      `json:"cachedByPath"`
}

type GetContextBodyRequest struct {
	ContextId string `json:"contextId"`
}

type GetContextBodyResponse struct {
	Body string `json:"body"`
}

type UpdateContextRequest map[string]*UpdateContextParams

type UpdateContextResponse = LoadContextResponse

type DeleteContextRequest struct {
	Ids map[string]bool `json:"ids"`
}

type DeleteContextResponse struct {
	TokensRemoved int    `json:"tokensRemoved"`
	TotalTokens   int    `json:"totalTokens"`
	Msg           string `json:"msg"`
}

type RejectFileRequest struct {
	FilePath string `json:"filePath"`
}

type RejectFilesRequest struct {
	Paths []string `json:"paths"`
}

type RewindPlanRequest struct {
	Sha string `json:"sha"`
}

type RewindPlanResponse struct {
	LatestSha    string `json:"latestSha"`
	LatestCommit string `json:"latestCommit"`
}

type LogResponse struct {
	Shas []string `json:"shas"`
	Body string   `json:"body"`
}

type CreateBranchRequest struct {
	Name string `json:"name"`
}

type UpdateSettingsRequest struct {
	ModelPackName string     `json:"modelPackName"`
	ModelPack     *ModelPack `json:"modelPack"`
}

type UpdateSettingsResponse struct {
	Msg string `json:"msg"`
}

type UpdatePlanConfigRequest struct {
	Config *PlanConfig `json:"config"`
}

type UpdateDefaultPlanConfigRequest struct {
	Config *PlanConfig `json:"config"`
}

type GetPlanConfigResponse struct {
	Config *PlanConfig `json:"config"`
}

type GetDefaultPlanConfigResponse struct {
	Config *PlanConfig `json:"config"`
}

type ListUsersResponse struct {
	Users            []*User             `json:"users"`
	OrgUsersByUserId map[string]*OrgUser `json:"orgUsersByUserId"`
}

type ApplyPlanRequest struct {
	ApiKeys     map[string]string `json:"apiKeys"`     // deprecated
	OpenAIBase  string            `json:"openAIBase"`  // deprecated
	OpenAIOrgId string            `json:"openAIOrgId"` // deprecated

	AuthVars map[string]string `json:"authVars"`

	SessionId string `json:"sessionId"`
}

type RenamePlanRequest struct {
	Name string `json:"name"`
}

type GetBuildStatusResponse struct {
	BuiltFiles       map[string]bool `json:"builtFiles"`
	IsBuildingByPath map[string]bool `json:"isBuildingByPath"`
}

// Cloud requests and responses
type CreditsLogRequest struct {
	TransactionType CreditsTransactionType `json:"transactionType"`
	PlanId          string                 `json:"planId"`
	SessionId       string                 `json:"sessionId"`
	DayStart        *time.Time             `json:"dayStart"`
	Month           bool                   `json:"month"`
}

type CreditsLogResponse struct {
	Transactions  []*CreditsTransaction `json:"transactions"`
	NumPages      int                   `json:"numPages"`
	NumPagesMax   bool                  `json:"numPagesMax"`
	MonthStart    time.Time             `json:"monthStart"`
	PlanNamesById map[string]string     `json:"planNamesById"`
}

type CreditsSummaryResponse struct {
	Balance decimal.Decimal `json:"balance"`

	TotalSpend decimal.Decimal `json:"totalSpend"`

	MonthStart time.Time `json:"monthStart"`

	ByPlanId      map[string]decimal.Decimal `json:"byPlanId"`
	PlanNamesById map[string]string          `json:"planNamesById"`

	ByModelName map[string]decimal.Decimal `json:"byModelName"`
	ByPurpose   map[string]decimal.Decimal `json:"byPurpose"`

	CacheSavings decimal.Decimal `json:"cacheSavings"`
}

type GetBalanceResponse struct {
	Balance decimal.Decimal `json:"balance"`
}


================================================
FILE: app/shared/stream.go
================================================
package shared

const STREAM_MESSAGE_SEPARATOR = "@@PX@@"

type BuildInfo struct {
	Path      string `json:"path"`
	NumTokens int    `json:"numTokens"`
	Finished  bool   `json:"finished"`
	Removed   bool   `json:"removed,omitempty"`
}

type StreamMessageType string

const (
	StreamMessageStart             StreamMessageType = "start"
	StreamMessageConnectActive     StreamMessageType = "connectActive"
	StreamMessageHeartbeat         StreamMessageType = "heartbeat"
	StreamMessageReply             StreamMessageType = "reply"
	StreamMessageDescribing        StreamMessageType = "describing"
	StreamMessageRepliesFinished   StreamMessageType = "repliesFinished"
	StreamMessageBuildInfo         StreamMessageType = "buildInfo"
	StreamMessagePromptMissingFile StreamMessageType = "promptMissingFile"
	StreamMessageLoadContext       StreamMessageType = "loadContext"
	StreamMessageAborted           StreamMessageType = "aborted"
	StreamMessageFinished          StreamMessageType = "finished"
	StreamMessageError             StreamMessageType = "error"

	StreamMessageMulti StreamMessageType = "multi"
)

type StreamMessage struct {
	Type StreamMessageType `json:"type"`

	ReplyChunk string `json:"replyChunk,omitempty"`

	BuildInfo              *BuildInfo               `json:"buildInfo,omitempty"`
	Description            *ConvoMessageDescription `json:"description,omitempty"`
	Error                  *ApiError                `json:"error,omitempty"`
	MissingFilePath        string                   `json:"missingFilePath,omitempty"`
	MissingFileAutoContext bool                     `json:"missingFileAutoContext,omitempty"`
	ModelStreamId          string                   `json:"modelStreamId,omitempty"`
	LoadContextFiles       []string                 `json:"loadContextFiles,omitempty"`
	InitPrompt             string                   `json:"initPrompt,omitempty"`
	InitReplies            []string                 `json:"initReplies,omitempty"`
	InitBuildOnly          bool                     `json:"initBuildOnly,omitempty"`

	StreamMessages []StreamMessage `json:"streamMessages,omitempty"`
}


================================================
FILE: app/shared/streamed_change.go
================================================
package shared

import (
	"fmt"
	"log"
	"strconv"
	"strings"
)

type StreamedChangeSection struct {
	StartLine       int    `json:"startLine"`
	EndLine         int    `json:"endLine"`
	StartLineString string `json:"startLineString"`
	EndLineString   string `json:"endLineString"`
}

type StreamedChangeWithLineNums struct {
	Old               StreamedChangeSection `json:"old"`
	StartLineIncluded bool                  `json:"startLineIncluded"`
	EndLineIncluded   bool                  `json:"endLineIncluded"`
	New               string                `json:"new"`
}

func (streamedChangeSection StreamedChangeSection) GetLines() (int, int, error) {
	return streamedChangeSection.GetLinesWithPrefix("pdx-")
}

func (streamedChangeSection StreamedChangeSection) GetLinesWithPrefix(prefix string) (int, int, error) {
	var startLine, endLine int
	var err error

	if streamedChangeSection.StartLineString == "" {
		log.Printf("StartLineString is empty\n")
		// spew.Dump(streamedChangeSection)
		startLine = streamedChangeSection.StartLine
	} else {
		startLine, err = ExtractLineNumberWithPrefix(streamedChangeSection.StartLineString, prefix)

		if err != nil {
			log.Printf("Error extracting start line number: %v\n", err)
			return 0, 0, fmt.Errorf("error extracting start line number: %v", err)
		}
	}

	if streamedChangeSection.EndLineString == "" {
		log.Printf("EndLineString is empty\n")
		// spew.Dump(streamedChangeSection)
		if streamedChangeSection.EndLine > 0 {
			endLine = streamedChangeSection.EndLine
		} else {
			endLine = startLine
		}
	} else {
		endLine, err = ExtractLineNumberWithPrefix(streamedChangeSection.EndLineString, prefix)

		if err != nil {
			log.Printf("Error extracting end line number: %v\n", err)
			return 0, 0, fmt.Errorf("error extracting end line number: %v", err)
		}
	}

	log.Printf("StartLine: %d, EndLine: %d\n", startLine, endLine)

	if startLine > endLine {
		log.Printf("Start line is greater than end line: %d > %d\n", startLine, endLine)
		return 0, 0, fmt.Errorf("start line is greater than end line: %d > %d", startLine, endLine)
	}

	if startLine < 1 {
		log.Printf("Start line is less than 1: %d\n", startLine)
		return 0, 0, fmt.Errorf("start line is less than 1: %d", startLine)
	}

	return startLine, endLine, nil
}

func ExtractLineNumber(line string) (int, error) {
	return ExtractLineNumberWithPrefix(line, "pdx-")
}

func ExtractLineNumberWithPrefix(line, prefix string) (int, error) {
	// Split the line at the first space to isolate the line number
	parts := strings.SplitN(line, " ", 2)

	// Remove the colon from the line number part
	lineNumberStr := strings.TrimSuffix(parts[0], ":")
	lineNumberStr = strings.TrimPrefix(lineNumberStr, prefix)
	if lineNumberStr == "" {
		return 0, fmt.Errorf("no line number found")
	}

	// Convert the line number part to an integer
	lineNumber, err := strconv.Atoi(lineNumberStr)
	if err != nil {
		return 0, fmt.Errorf("invalid line number: %v", err)
	}

	return lineNumber, nil
}


================================================
FILE: app/shared/syntax.go
================================================
package shared

import (
	"path/filepath"
	"strings"
)

type Language string

const (
	LanguageBash       Language = "bash"
	LanguageC          Language = "c"
	LanguageCpp        Language = "cpp"
	LanguageCsharp     Language = "csharp"
	LanguageCss        Language = "css"
	LanguageCue        Language = "cue"
	LanguageDockerfile Language = "dockerfile"
	LanguageElixir     Language = "elixir"
	LanguageElm        Language = "elm"
	LanguageGo         Language = "go"
	LanguageGroovy     Language = "groovy"
	LanguageHcl        Language = "hcl"
	LanguageHtml       Language = "html"
	LanguageJava       Language = "java"
	LanguageJavascript Language = "javascript"
	LanguageJson       Language = "json"
	LanguageKotlin     Language = "kotlin"
	LanguageLua        Language = "lua"
	LanguageOCaml      Language = "ocaml"
	LanguagePhp        Language = "php"
	LanguageProtobuf   Language = "protobuf"
	LanguagePython     Language = "python"
	LanguageRuby       Language = "ruby"
	LanguageRust       Language = "rust"
	LanguageScala      Language = "scala"
	LanguageSvelte     Language = "svelte"
	LanguageSwift      Language = "swift"
	LanguageToml       Language = "toml"
	LanguageTypescript Language = "typescript"
	LanguageJsx        Language = "jsx"
	LanguageTsx        Language = "tsx"
	LanguageYaml       Language = "yaml"
	LanguageMarkdown   Language = "markdown"
)

var Languages = []Language{
	LanguageBash,
	LanguageC,
	LanguageCpp,
	LanguageCsharp,
	LanguageCss,
	LanguageCue,
	LanguageDockerfile,
	LanguageElixir,
	LanguageElm,
	LanguageGo,
	LanguageGroovy,
	LanguageHcl,
	LanguageHtml,
	LanguageJava,
	LanguageJavascript,
	LanguageJson,
	LanguageKotlin,
	LanguageLua,
	LanguageMarkdown,
	LanguageOCaml,
	LanguagePhp,
	LanguageProtobuf,
	LanguagePython,
	LanguageRuby,
	LanguageRust,
	LanguageScala,
	LanguageSvelte,
	LanguageSwift,
	LanguageToml,
	LanguageTypescript,
	LanguageJsx,
	LanguageTsx,
	LanguageYaml,
}

var lacksFileMapSupport = []Language{
	// config languages aren't mapped, model decides whether to load them based on file name
	LanguageHcl,
	LanguageYaml,
	LanguageToml,
	LanguageCue,
	LanguageJson,
	LanguageProtobuf,

	// these just need more work for mapping
	LanguageGroovy,
	LanguageOCaml,
}

var SkipTreeSitter = map[Language]bool{
	LanguageMarkdown: true,
}

var LanguageSet = map[Language]bool{}

var FileMapSupportSet = map[Language]bool{}

func init() {
	for _, lang := range Languages {
		LanguageSet[lang] = true
		FileMapSupportSet[lang] = true
	}
	for _, lang := range lacksFileMapSupport {
		FileMapSupportSet[lang] = false
	}
}

func IsTreeSitterLanguage(lang Language) bool {
	return LanguageSet[lang] && !SkipTreeSitter[lang]
}

func HasTreeSitterSupport(path string) bool {
	base := filepath.Base(path)
	ext := filepath.Ext(base)
	isDockerfile := strings.Contains(strings.ToLower(base), "dockerfile")
	return (isDockerfile || LanguageByExtension[ext] != "") && IsTreeSitterLanguage(LanguageByExtension[ext])
}

func HasFileMapSupport(path string) bool {
	base := filepath.Base(path)
	ext := filepath.Ext(base)
	isDockerfile := strings.Contains(strings.ToLower(base), "dockerfile")
	lang := LanguageByExtension[ext]
	return isDockerfile || (lang != "" && FileMapSupportSet[lang])
}

var LanguageByExtension = map[string]Language{
	".sh":     LanguageBash,
	".bash":   LanguageBash,
	".c":      LanguageC,
	".h":      LanguageC,
	".cpp":    LanguageCpp,
	".cc":     LanguageCpp,
	".cs":     LanguageCsharp,
	".css":    LanguageCss,
	".cue":    LanguageCue,
	".ex":     LanguageElixir,
	".exs":    LanguageElixir,
	".elm":    LanguageElm,
	".go":     LanguageGo,
	".groovy": LanguageGroovy,
	".hcl":    LanguageHcl,
	".html":   LanguageHtml,
	".java":   LanguageJava,
	".js":     LanguageJavascript,
	".json":   LanguageJson,
	".jsx":    LanguageTsx,
	".kt":     LanguageKotlin,
	".lua":    LanguageLua,
	".ml":     LanguageOCaml,
	".php":    LanguagePhp,
	".proto":  LanguageProtobuf,
	".py":     LanguagePython,
	".rb":     LanguageRuby,
	".rs":     LanguageRust,
	".scala":  LanguageScala,
	".svelte": LanguageSvelte,
	".swift":  LanguageSwift,
	".toml":   LanguageToml,
	".ts":     LanguageTypescript,
	".tsx":    LanguageTsx,
	".yaml":   LanguageYaml,
	".yml":    LanguageYaml,
	".md":     LanguageMarkdown,
}

var LanguageFallbackByExtension = map[string]Language{
	".ts": LanguageTsx,
	".js": LanguageTsx,
}


================================================
FILE: app/shared/tokens.go
================================================
package shared

import (
	"fmt"

	"github.com/pkoukk/tiktoken-go"
)

var tkm *tiktoken.Tiktoken

const EstimatedBytesPerToken = 4

func init() {
	var err error
	tkm, err = tiktoken.EncodingForModel("gpt-4o")
	if err != nil {
		panic(fmt.Sprintf("error getting encoding for model: %v", err))
	}
}

func GetNumTokensEstimate(text string) int {
	return len(tkm.Encode(text, nil, nil))
}

func GetFastNumTokensEstimate(text string) int {
	return GetBytesToTokensEstimate(int64(len(text)))
}

func GetBytesToTokensEstimate(bytes int64) int {
	return int(bytes / EstimatedBytesPerToken)
}


================================================
FILE: app/shared/tygo.yaml
================================================
# You can specify more than one package
packages:
  # The package path just like you would import it in Go
  - path: "shared"

    # Where this output should be written to.
    # If you specify a folder it will be written to a file `index.ts` within that folder. By default it is written into the Golang package folder.
    output_path: "../server/cloud/ui/node/src/types/generated.ts"
    include_files:
      - "data_models.go"
      - "plan_settings.go"
      - "streamed_change.go"
      - "plan_status.go"

    type_mappings:
      time.Time: "string /* RFC3339 */"
      decimal.Decimal: "string /* decimal.Decimal */"
      openai.ImageURLDetail: '"high" | "low" | "auto"'


================================================
FILE: app/shared/utils.go
================================================
package shared

import (
	"bytes"
	"crypto/rand"
	"fmt"
	"regexp"
	"strings"
	"time"
	"unicode/utf8"
)

func Pointer[T any](v T) *T {
	return &v
}

const TsFormat = "2006-01-02T15:04:05.999Z"

func StringTs() string {
	return time.Now().UTC().Format(TsFormat)
}

var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

func GetRandomAlphanumeric(n int) ([]byte, error) {
	bytes := make([]byte, n)
	if _, err := rand.Read(bytes); err != nil {
		return nil, err
	}
	for i, b := range bytes {
		bytes[i] = letters[int(b)%len(letters)]
	}
	return bytes, nil
}

func Dasherize(s string) string {
	regex := regexp.MustCompile("([A-Z][a-z0-9]*)")
	indexes := regex.FindAllStringIndex(s, -1)
	if indexes == nil {
		return strings.ToLower(s)
	}

	var parts []string
	lastStart := 0
	for _, loc := range indexes {
		if lastStart != loc[0] {
			parts = append(parts, s[lastStart:loc[0]])
		}
		parts = append(parts, s[loc[0]:loc[1]])
		lastStart = loc[1]
	}
	if lastStart < len(s) {
		parts = append(parts, s[lastStart:])
	}

	s = strings.ToLower(strings.Join(parts, "-"))
	s = strings.ReplaceAll(s, " ", "-")
	s = strings.ReplaceAll(s, "_", "-")

	return s
}

func Compact(s string) string {
	return strings.ReplaceAll(Dasherize(s), "-", "")
}

func Capitalize(s string) string {
	if s == "" {
		return ""
	}
	return strings.ToUpper(s[:1]) + s[1:]
}

type LineNumberedTextType string

func AddLineNums(s string) LineNumberedTextType {
	return LineNumberedTextType(AddLineNumsWithPrefix(s, "pdx-"))
}

func AddLineNumsWithPrefix(s, prefix string) LineNumberedTextType {
	var res string
	for i, line := range strings.Split(s, "\n") {
		res += fmt.Sprintf("%s%d: %s\n", prefix, i+1, line)
	}
	return LineNumberedTextType(res)
}

func RemoveLineNums(s LineNumberedTextType) string {
	return RemoveLineNumsWithPrefix(s, "pdx-")
}

func RemoveLineNumsWithPrefix(s LineNumberedTextType, prefix string) string {
	return regexp.MustCompile(fmt.Sprintf(`(?m)^%s\d+: `, prefix)).ReplaceAllString(string(s), "")
}

// indexRunes searches for the slice of runes `needle` in the slice of runes `haystack`
// and returns the index of the first rune of `needle` in `haystack`, or -1 if `needle` is not present.
func IndexRunes(haystack []rune, needle []rune) int {
	if len(needle) == 0 {
		return 0
	}
	if len(haystack) == 0 {
		return -1
	}

	// Search for the needle
	for i := 0; i <= len(haystack)-len(needle); i++ {
		found := true
		for j := 0; j < len(needle); j++ {
			if haystack[i+j] != needle[j] {
				found = false
				break
			}
		}
		if found {
			return i
		}
	}

	return -1
}

func ReplaceReverse(s, old, new string, n int) string {
	// If n is negative, there is no limit to the number of replacements
	if n == 0 {
		return s
	}

	if n < 0 {
		return strings.Replace(s, old, new, -1)
	}

	// If n is positive, replace the last n occurrences of old with new
	var res string
	for i := 0; i < n; i++ {
		idx := strings.LastIndex(s, old)
		if idx == -1 {
			break
		}
		res = s[:idx] + new + s[idx+len(old):]
		s = res
	}
	return res
}

func NormalizeEOL(data []byte) []byte {
	if !looksTextish(data) {
		return data
	}

	// CRLF -> LF
	n := bytes.ReplaceAll(data, []byte{'\r', '\n'}, []byte{'\n'})

	// treat stray CR as newline as well
	n = bytes.ReplaceAll(n, []byte{'\r'}, []byte{'\n'})
	return n
}

// looksTextish checks some very cheap heuristics:
//  1. no NUL bytes      → probably not binary
//  2. valid UTF-8       → BOMs are OK
//  3. printable ratio   → ≥ 90 % of runes are >= 0x20 or common whitespace
func looksTextish(b []byte) bool {
	if bytes.IndexByte(b, 0x00) != -1 { // 1
		return false
	}
	if !utf8.Valid(b) { // 2
		return false
	}

	printable := 0
	for len(b) > 0 {
		r, size := utf8.DecodeRune(b)
		b = b[size:]
		switch {
		case r == '\n', r == '\r', r == '\t':
			printable++
		case r >= 0x20 && r != 0x7f:
			printable++
		}
	}
	return float64(printable)/float64(len(b)) > 0.90 // 3
}


================================================
FILE: app/shared/utils_struct.go
================================================
package shared

import "reflect"

func Merge[T any](base T, ov T) T {
	rvBase := reflect.ValueOf(&base).Elem() // addressable
	rvOv := reflect.ValueOf(ov)

	for i := 0; i < rvBase.NumField(); i++ {
		fOv := rvOv.Field(i)
		if !fOv.IsZero() { // ← built-in zero test
			rvBase.Field(i).Set(fOv)
		}
	}
	return base
}

// FieldsDefined reports whether every name in fields is present on the
// (possibly-pointer) struct v. It returns the first missing field name
// (empty string means all present).
func FieldsDefined(v any, fields []string) (ok bool, missing string) {
	rv := reflect.ValueOf(v)
	if rv.Kind() == reflect.Pointer {
		rv = rv.Elem()
	}
	if rv.Kind() != reflect.Struct {
		panic("FieldsDefined: value must be a struct or *struct")
	}

	rt := rv.Type() // a reflect.Type is a bit faster for look-ups

	for _, name := range fields {
		if _, found := rt.FieldByName(name); !found {
			return false, name
		}
	}
	return true, ""
}


================================================
FILE: app/start_local.sh
================================================
#!/usr/bin/env bash

# Get the absolute path to the script's directory, regardless of where it's run from
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

# Change to the app directory if we're not already there
cd "$SCRIPT_DIR"

echo "Checking dependencies..."

if ! [ -x "$(command -v git)" ]; then
    echo 'Error: git is not installed.' >&2
    echo 'Please install git before running this setup script.' >&2
    exit 1
fi

if ! [ -x "$(command -v docker)" ]; then
    echo 'Error: docker is not installed.' >&2
    echo 'Please install docker before running this setup script.' >&2
    exit 1
fi

if ! [ -x "$(command -v docker-compose)" ]; then
    docker compose 2>&1 > /dev/null
    if [[ $? -ne 0 ]]; then
        echo 'Error: docker-compose is not installed.' >&2
        echo 'Please install docker-compose before running this setup script.' >&2
        exit 1
    fi
fi

echo "Starting the local Plandex server and database..."

docker compose pull plandex-server
docker compose up


================================================
FILE: docs/.gitignore
================================================
# Dependencies
/node_modules

# Production
/build

# Generated files
.docusaurus
.cache-loader

# Misc
.DS_Store
.env.local
.env.development.local
.env.test.local
.env.production.local

npm-debug.log*
yarn-debug.log*
yarn-error.log*


================================================
FILE: docs/README.md
================================================
# Website

This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.

### Installation

```
$ yarn
```

### Local Development

```
$ yarn start
```

This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.

### Build

```
$ yarn build
```

This command generates static content into the `build` directory and can be served using any static contents hosting service.

### Deployment

Using SSH:

```
$ USE_SSH=true yarn deploy
```

Not using SSH:

```
$ GIT_USER=<Your GitHub username> yarn deploy
```

If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.


================================================
FILE: docs/babel.config.js
================================================
module.exports = {
  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
};


================================================
FILE: docs/blog/2019-05-28-first-blog-post.md
================================================
---
slug: first-blog-post
title: First Blog Post
authors:
  name: Gao Wei
  title: Docusaurus Core Team
  url: https://github.com/wgao19
  image_url: https://github.com/wgao19.png
tags: [hola, docusaurus]
---

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet


================================================
FILE: docs/blog/2019-05-29-long-blog-post.md
================================================
---
slug: long-blog-post
title: Long Blog Post
authors: endi
tags: [hello, docusaurus]
---

This is the summary of a very long blog post,

Use a `<!--` `truncate` `-->` comment to limit blog post size in the list view.

<!--truncate-->

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet


================================================
FILE: docs/blog/2021-08-01-mdx-blog-post.mdx
================================================
---
slug: mdx-blog-post
title: MDX Blog Post
authors: [slorber]
tags: [docusaurus]
---

Blog posts support [Docusaurus Markdown features](https://docusaurus.io/docs/markdown-features), such as [MDX](https://mdxjs.com/).

:::tip

Use the power of React to create interactive blog posts.

```js
<button onClick={() => alert('button clicked!')}>Click me!</button>
```

<button onClick={() => alert('button clicked!')}>Click me!</button>

:::


================================================
FILE: docs/blog/2021-08-26-welcome/index.md
================================================
---
slug: welcome
title: Welcome
authors: [slorber, yangshun]
tags: [facebook, hello, docusaurus]
---

[Docusaurus blogging features](https://docusaurus.io/docs/blog) are powered by the [blog plugin](https://docusaurus.io/docs/api/plugins/@docusaurus/plugin-content-blog).

Simply add Markdown files (or folders) to the `blog` directory.

Regular blog authors can be added to `authors.yml`.

The blog post date can be extracted from filenames, such as:

- `2019-05-30-welcome.md`
- `2019-05-30-welcome/index.md`

A blog post folder can be convenient to co-locate blog post images:

![Docusaurus Plushie](./docusaurus-plushie-banner.jpeg)

The blog supports tags as well!

**And if you don't want a blog**: just delete this directory, and use `blog: false` in your Docusaurus config.


================================================
FILE: docs/blog/authors.yml
================================================
endi:
  name: Endilie Yacop Sucipto
  title: Maintainer of Docusaurus
  url: https://github.com/endiliey
  image_url: https://github.com/endiliey.png

yangshun:
  name: Yangshun Tay
  title: Front End Engineer @ Facebook
  url: https://github.com/yangshun
  image_url: https://github.com/yangshun.png

slorber:
  name: Sébastien Lorber
  title: Docusaurus maintainer
  url: https://sebastienlorber.com
  image_url: https://github.com/slorber.png


================================================
FILE: docs/blog/tags.yml
================================================
facebook:
  label: Facebook
  permalink: /facebook
  description: Facebook tag description
hello:
  label: Hello
  permalink: /hello
  description: Hello tag description
docusaurus:
  label: Docusaurus
  permalink: /docusaurus
  description: Docusaurus tag description
hola:
  label: Hola
  permalink: /hola
  description: Hola tag description


================================================
FILE: docs/docs/cli-reference.md
================================================
---
sidebar_position: 8
sidebar_label: CLI Reference
---

# CLI Reference

All Plandex CLI commands and their options.

## Usage

```bash
plandex [command] [flags]
pdx [command] [flags] # 'pdx' is an alias for 'plandex'
```

## Help

Built-in help.

```bash
plandex help
pdx h # alias
```

`--all/-a`: List all commands.

For help on a specific command, use:

```bash
plandex [command] --help
```

## REPL

The easiest way to use Plandex is through the REPL. Start it in your project directory with:

```bash
plandex
```

or for short:

```bash
pdx
```

### Flags

The REPL has a few convenient flags you can use to start it with different modes, autonomy settings, and model packs. You can pass any of these to `plandex` or `pdx` when starting the REPL.

```
  Mode
    --chat, -c     Start in chat mode (for conversation without making changes)
    --tell, -t     Start in tell mode (for implementation)

  Autonomy
    --no-auto      None → step-by-step, no automation
    --basic        Basic → auto-continue plans, no other automation
    --plus         Plus → auto-update context, smart context, auto-commit changes
    --semi         Semi-Auto → auto-load context
    --full         Full-Auto → auto-apply, auto-exec, auto-debug

  Models
    --daily        Daily driver pack (default models, balanced capability, cost, and speed)
    --reasoning    Similar to daily driver, but uses reasoning model for planning
    --strong       Strong pack (more capable models, higher cost and slower)
    --cheap        Cheap pack (less capable models, lower cost and faster)
    --oss          Open source pack (open source models)
    
    --gemini-planner       Gemini pack (Gemini 2.5 Pro for planning, default models for other roles)
    --o3-planner           OpenAI o3-medium for planning, default models for other roles
    --r1-planner           DeepSeek R1 for planning, default models for other roles
    --perplexity-planner   Perplexity for planning, default models for other roles
    --opus-planner         Anthropic Opus 4 for planning, default models for other roles
```

All commands listed below can be run in the REPL by prefixing them with a backslash (`\`), e.g. `\new`.

## Plans

### new

Start a new plan.

```bash
plandex new
plandex new -n new-plan # with name
```

`--name/-n`: Name of the new plan. The name is generated automatically after first prompt if no name is specified on creation.

`--context-dir/-d`: Base directory to load context from when auto-loading context is enabled. Defaults to `.` (current directory). Set a different directoy if you don't want all files to be included in the project map.

`--no-auto`: Start the plan with auto-mode 'None' (step-by-step, no automation).

`--basic`: Start the plan with auto-mode 'Basic' (auto-continue plans, no other automation).

`--plus`: Start the plan with auto-mode 'Plus' (auto-update context, smart context, auto-commit changes).

`--semi`: Start the plan with auto-mode 'Semi-Auto' (auto-load context).

`--full`: Start the plan with auto-mode 'Full-Auto' (auto-apply, auto-exec, auto-debug).

`--daily`: Start the plan with the daily driver model pack.

`--reasoning`: Start the plan with the reasoning model pack.

`--strong`: Start the plan with the strong model pack.

`--cheap`: Start the plan with the cheap model pack.

`--oss`: Start the plan with the open source model pack.

`--gemini-planner`: Start the plan with the Gemini planner model pack.

`--o3-planner`: Start the plan with the OpenAI o3-medium planner model pack.

`--r1-planner`: Start the plan with the DeepSeek R1 planner model pack.

`--perplexity-planner`: Start the plan with the Perplexity planner model pack.

`--opus-planner`: Start the plan with the Anthropic Opus 4 planner model pack.

### plans

List plans. Output includes index, when each plan was last updated, the current branch of each plan, the number of tokens in context, and the number of tokens in the conversation (prior to summarization).

Includes full details on plans in current directory. Also includes names of plans in parent directories and child directories.

```bash
plandex plans
plandex plans --archived # list archived plans only

pdx pl # alias
```

`--archived/-a`: List archived plans only.

### current

Show current plan. Output includes when the plan was last updated and created, the current branch, the number of tokens in context, and the number of tokens in the conversation (prior to summarization).

```bash
plandex current
pdx cu # alias
```

### cd

Set current plan by name or index.

```bash
plandex cd # select from a list of plans
plandex cd some-plan # by name
plandex cd 4 # by index in `plandex plans`
```

With no arguments, Plandex prompts you with a list of plans to select from.

With one argument, Plandex selects a plan by name or by index in the `plandex plans` list.

### delete-plan

Delete a plan by name, index, range, pattern, or select from a list.

```bash
plandex delete-plan # select from a list of plans
plandex delete-plan some-plan # by name
plandex delete-plan 4 # by index in `plandex plans`
plandex delete-plan 2-4 # by range of indices
plandex delete-plan 'docs-*' # by pattern
plandex delete-plan --all # delete all plans
pdx dp # alias
```

`--all/-a`: Delete all plans.

### rename

Rename the current plan.

```bash
plandex rename # prompt for new name
plandex rename new-name # set new name
```

### archive

Archive a plan.

```bash
plandex archive # select from a list of plans
plandex archive some-plan # by name
plandex archive 4 # by index in `plandex plans`

pdx arc # alias
```

### unarchive

Unarchive a plan.

```bash
plandex unarchive # select from a list of archived plans
plandex unarchive some-plan # by name
plandex unarchive 4 # by index in `plandex plans --archived`
pdx unarc # alias
```

## Context

### load

Load files, directories, directory layouts, URLs, notes, images, or piped data into context.

```bash
plandex load component.ts # single file
plandex load component.ts action.ts reducer.ts # multiple files
plandex load lib -r # loads lib and all its subdirectories
plandex load tests/**/*.ts # loads all .ts files in tests and its subdirectories
plandex load . --tree # loads the layout of the current directory and its subdirectories (file names only)
plandex load https://redux.js.org/usage/writing-tests # loads the text-only content of the url
npm test | plandex load # loads the output of `npm test`
plandex load -n 'add logging statements to all the code you generate.' # load a note into context
plandex load ui-mockup.png # load an image into context

pdx l component.ts # alias
```

`--recursive/-r`: Load an entire directory and all its subdirectories.

`--tree`: Load directory tree layout with file names only.

`--map`: Load file map of the given directory (function/method/class signatures, variable names, types, etc.)

`--note/-n`: Load a note into context.

`--force/-f`: Load files even when ignored by .gitignore or .plandexignore.

`--detail/-d`: Image detail level when loading an image (high or low)—default is high. See https://platform.openai.com/docs/guides/vision/low-or-high-fidelity-image-understanding for more info.

### ls

List everything in the current plan's context. Output includes index, name, type, token size, when the context added, and when the context was last updated.

```bash
plandex ls

plandex list-context # longer alias
```

### rm

Remove context by index, range, name, or glob.

```bash
plandex rm some-file.ts # by name
plandex rm app/**/*.ts # by glob pattern
plandex rm 4 # by index in `plandex ls`
plandex rm 2-4 # by range of indices

plandex remove # longer alias
plandex unload # longer alias
```

### show

Output context by name or index.

```bash
plandex show some-file.ts # by name
plandex show 4 # by index in `plandex ls`
```

### update

Update any outdated context.

```bash
plandex update
pdx u # alias
```

### clear

Remove all context.

```bash
plandex clear
```

## Control

### tell

Describe a task.

```bash
plandex tell -f prompt.txt # from file
plandex tell # open vim to write prompt
plandex tell "add a cancel button to the left of the submit button" # inline

pdx t # alias
```

`--file/-f`: File path containing prompt.

`--stop/-s`: Stop after a single model response (don't auto-continue). Defaults to opposite of config value `auto-continue`.

`--no-build/-n`: Don't build proposed changes into pending file updates. Defaults to opposite of config value `auto-build`.

`--bg`: Run task in the background. Only allowed if `--auto-load-context` and `--apply/-a` are not enabled. Not allowed with the default [autonomy level](./core-concepts/autonomy.md) in Plandex v2.

`--auto-update-context`: Automatically confirm context updates. Defaults to config value `auto-update-context`.

`--auto-load-context`: Automatically load context using project map. Defaults to config value `auto-load-context`.

`--smart-context`: Use smart context to only load the necessary file(s) for each step during implementation. Defaults to config value `smart-context`.

`--no-exec`: Don't execute commands after successful apply. Defaults to opposite of config value `can-exec`.

`--auto-exec`: Automatically execute commands after successful apply without confirmation. Defaults to config value `auto-exec`.

`--skip-menu`: Skip interactive menu when response finishes and changes are pending. Defaults to config value `skip-changes-menu`.

`--debug`: Automatically execute and debug failing commands (optionally specify number of tries—default is 5). Defaults to config values of `auto-debug` and `auto-debug-tries`.

`--apply/-a`: Automatically apply changes (and confirm context updates). Defaults to config value `auto-apply`.

`--commit/-c`: Commit changes to git when `--apply/-a` is passed. Defaults to config value `auto-commit`.

`--skip-commit`: Don't commit changes to git. Defaults to opposite of config value `auto-commit`.

### continue

Continue the plan.

```bash
plandex continue

pdx c # alias
```

`--stop/-s`: Stop after a single model response (don't auto-continue). Defaults to opposite of config value `auto-continue`.

`--no-build/-n`: Don't build proposed changes into pending file updates. Defaults to opposite of config value `auto-build`.

`--bg`: Run task in the background. Only allowed if `--auto-load-context` and `--apply/-a` are not enabled. Not allowed with the default [autonomy level](./core-concepts/autonomy.md) in Plandex v2.

`--auto-update-context`: Automatically confirm context updates. Defaults to config value `auto-update-context`.

`--auto-load-context`: Automatically load context using project map. Defaults to config value `auto-load-context`.

`--smart-context`: Use smart context to only load the necessary file(s) for each step during implementation. Defaults to config value `smart-context`.

`--no-exec`: Don't execute commands after successful apply. Defaults to opposite of config value `can-exec`.

`--auto-exec`: Automatically execute commands after successful apply without confirmation. Defaults to config value `auto-exec`.

`--skip-menu`: Skip interactive menu when response finishes and changes are pending. Defaults to config value `skip-changes-menu`.

`--debug`: Automatically execute and debug failing commands (optionally specify number of tries—default is 5). Defaults to config values of `auto-debug` and `auto-debug-tries`.

`--apply/-a`: Automatically apply changes (and confirm context updates). Defaults to config value `auto-apply`.

`--commit/-c`: Commit changes to git when `--apply/-a` is passed. Defaults to config value `auto-commit`.

`--skip-commit`: Don't commit changes to git. Defaults to opposite of config value `auto-commit`.

### build

Build any unbuilt pending changes from the plan conversation.

```bash
plandex build
pdx b # alias
```

`--bg`: Build in the background. Not allowed if `--apply/-a` is enabled.

`--stop/-s`: Stop after a single model response (don't auto-continue). Defaults to opposite of config value `auto-continue`.

`--no-build/-n`: Don't build proposed changes into pending file updates. Defaults to opposite of config value `auto-build`.

`--auto-update-context`: Automatically confirm context updates. Defaults to config value `auto-update-context`.

`--no-exec`: Don't execute commands after successful apply. Defaults to opposite of config value `can-exec`.

`--auto-exec`: Automatically execute commands after successful apply without confirmation. Defaults to config value `auto-exec`.

`--skip-menu`: Skip interactive menu when response finishes and changes are pending. Defaults to config value `skip-changes-menu`.

`--debug`: Automatically execute and debug failing commands (optionally specify number of tries—default is 5). Defaults to config values of `auto-debug` and `auto-debug-tries`.

`--apply/-a`: Automatically apply changes (and confirm context updates). Defaults to config value `auto-apply`.

`--commit/-c`: Commit changes to git when `--apply/-a` is passed. Defaults to config value `auto-commit`.

`--skip-commit`: Don't commit changes to git. Defaults to opposite of config value `auto-commit`.

### chat

Ask a question or chat without making any changes.

```bash
plandex chat "is it clear from the context how to add a new line chart?"
pdx ch # alias
```

`--file/-f`: File path containing prompt.

`--bg`: Run task in the background. Not allowed if `--auto-load-context` is enabled. Not allowed with the default [autonomy level](./core-concepts/autonomy.md) in Plandex v2.

`--auto-update-context`: Automatically confirm context updates. Defaults to config value `auto-update-context`.

`--auto-load-context`: Automatically load context using project map. Defaults to config value `auto-load-context`.

### debug

Repeatedly run a command and automatically attempt fixes until it succeeds, rolling back changes on failure. Defaults to 5 tries before giving up.

```bash
plandex debug 'npm test' # try 5 times or until it succeeds
plandex debug 10 'npm test' # try 10 times or until it succeeds
pdx db 'npm test' # alias
```

`--commit/-c`: Commit changes to git when `--apply/-a` is passed. Defaults to config value `auto-commit`.

`--skip-commit`: Don't commit changes to git. Defaults to opposite of config value `auto-commit`.

## Changes

### diff

Review pending changes in 'git diff' format or in a local browser UI.

```bash
plandex diff
plandex diff --ui
```

`--plain/-p`: Output diffs in plain text with no ANSI codes.

`--ui/-u`: Review pending changes in a local browser UI.

`--side-by-side/-s`: Show diffs UI in side-by-side view

`--line-by-line/-l`: Show diffs UI in line-by-line view

### apply

Apply pending changes to project files.

```bash
plandex apply
pdx ap # alias
```

`--auto-update-context`: Automatically confirm context updates. Defaults to config value `auto-update-context`.

`--no-exec`: Don't execute commands after successful apply. Defaults to opposite of config value `can-exec`.

`--auto-exec`: Automatically execute commands after successful apply without confirmation. Defaults to config value `auto-exec`.

`--debug`: Automatically execute and debug failing commands (optionally specify number of tries—default is 5). Defaults to config values of `auto-debug` and `auto-debug-tries`.

`--commit/-c`: Commit changes to git when `--apply/-a` is passed. Defaults to config value `auto-commit`.

`--skip-commit`: Don't commit changes to git. Defaults to opposite of config value `auto-commit`.

`--full`: Apply the plan and debug in full auto mode.

### reject

Reject pending changes to one or more project files.

```bash
plandex reject # select from a list of pending files to reject
plandex reject file.ts # one file
plandex reject file.ts another-file.ts # multiple files
plandex reject --all # all pending files

pdx rj file.ts # alias
```

`--all/-a`: Reject all pending files.

## History

### log

Show plan history.

```bash
plandex log

plandex history # alias
plandex logs # alias
```

### rewind

Rewind to a previous state.

```bash
plandex rewind # select from a list of previous states to rewind to
plandex rewind 3 # rewind 3 steps
plandex rewind a7c8d66 # rewind to a specific step from `plandex log`
```

### convo

Show the current plan's conversation.

```bash
plandex convo
plandex convo 1 # show a specific message
plandex convo 1-5 # show a range of messages
plandex convo 3- # show all messages from 3 to the end
```

`--plain/-p`: Output conversation in plain text with no ANSI codes.

### summary

Show the latest summary of the current plan.

```bash
plandex summary
```

`--plain/-p`: Output summary in plain text with no ANSI codes.

## Branches

### branches

List plan branches. Output includes index, name, when the branch was last updated, the number of tokens in context, and the number of tokens in the conversation (prior to summarization).

```bash
plandex branches
pdx br # alias
```

### checkout

Checkout or create a branch.

```bash
plandex checkout # select from a list of branches or prompt to create a new branch
plandex checkout some-branch # checkout by name or create a new branch with that name
plandex checkout some-branch -y # checkout by name or create a new branch with that name, auto-confirming branch creation

pdx co # alias
```

`--yes/-y`: Auto-confirm creating a new branch if it doesn't exist.

### delete-branch

Delete a branch by name or index.

```bash
plandex delete-branch # select from a list of branches
plandex delete-branch some-branch # by name
plandex delete-branch 4 # by index in `plandex branches`

pdx dlb # alias
```

## Background Tasks / Streams

### ps

List active and recently finished plan streams. Output includes stream ID, plan name, branch name, when the stream was started, and the stream's status (active, finished, stopped, errored, or waiting for a missing file to be selected).

```bash
plandex ps
```

### connect

Connect to an active plan stream.

```bash
plandex connect # select from a list of active streams
plandex connect a4de # by stream ID in `plandex ps`
plandex connect some-plan main # by plan name and branch name
pdx conn # alias
```

### stop

Stop an active plan stream.

```bash
plandex stop # select from a list of active streams
plandex stop a4de # by stream ID in `plandex ps`
plandex stop some-plan main # by plan name and branch name
```

## Configuration

### config

Show current plan config. Output includes configuration settings for the plan, such as autonomy level, model settings, and other plan-specific options.

```bash
plandex config
```

### config default

Show the default config used for new plans. Output includes the default configuration settings that will be applied to newly created plans.

```bash
plandex config default
```

### set-config

Update configuration settings for the current plan.

```bash
plandex set-config # select from a list of config options
plandex set-config auto-context true # set a specific config option
```

With no arguments, Plandex prompts you to select from a list of config options.

With arguments, allows you to directly set specific configuration options for the current plan.

### set-config default

Update the default configuration settings for new plans.

```bash
plandex set-config default # select from a list of config options
plandex set-config default auto-mode basic # set a specific default config option
```

Works exactly the same as set-config above, but sets the default configuration for all new plans instead of only the current plan.

### set-auto

Update the auto-mode (autonomy level) for the current plan.

```bash
plandex set-auto # select from a list of auto-modes
plandex set-auto full # set to full automation
plandex set-auto semi # set to semi-auto mode
plandex set-auto plus # set to plus mode
plandex set-auto basic # set to basic mode
plandex set-auto none # set to none (step-by-step, no automation)
```

With no arguments, Plandex prompts you to select from a list of automation levels.

With one argument, Plandex sets the automation level directly to the specified value.

### set-auto default

Set the default auto-mode for new plans.

```bash
plandex set-auto default # select from a list of auto-modes
plandex set-auto default basic # set default to basic mode
```

Works exactly the same as set-auto above, but sets the default automation level for all new plans instead of only the current plan.

## Models

### models

Show current plan models and model settings.

```bash
plandex models
```

### models default

Show org-wide default models and model settings for new plans.

```bash
plandex models default
```

### models custom

Manage custom models, providers, and model packs via JSON file.

```bash
plandex models custom
plandex models custom --save # save changes from the default custom-models.json file to the server
plandex models custom --file /path/to/models.json # import custom models/providers/model-packs from a non-default JSON file
```

`--save`: Save changes from the JSON file to the server.

`--file/-f`: Path to non-default custom models JSON file.

Without `--save`, this command will:

- Create an example models file if none exists, or sync current server state to the file
- Open the file in your configured editor
- Prompt you to save changes when you return

With `--save`, it will skip opening the editor and sync changes from the JSON file to the server.

### models available

Show available models.

```bash
plandex models available # show all available models
plandex models available --custom # show available custom models only
```

`--custom`: Show available custom models only.

### providers

Show all available model providers.

```bash
plandex providers
plandex providers --custom # show custom providers only (not supported on Plandex Cloud)
```

`--custom/-c`: Show custom providers only (not supported on Plandex Cloud).

### set-model

Update current plan models or model settings.

```bash
plandex set-model # select from a list of model packs or edit via JSON
plandex set-model daily # set model pack by name
plandex set-model --json # edit plan's model settings via JSON file at default path
plandex set-model --save # save changes from the plan's model settings JSON file to the server
plandex set-model --json --file /path/to/settings.json # set plan's model settings from a JSON file at a non-default path
```

`--json`: Edit plan's model settings via JSON file at default path.

`--save`: Save changes from the plan's model settings JSON file to the server.

`--file`: Set plan's model settings from a JSON file at a non-default path.

With no arguments, Plandex prompts you to either select a model pack or edit settings via JSON.

When using JSON mode without `--save`, Plandex will:

- Write current settings to a JSON file
- Open it in your configured editor
- Apply the changes when you save and return

With `--save`, it will skip opening the editor and sync changes from the JSON file to the server.

Model pack shortcuts are still available:

```bash
plandex set-model daily
plandex set-model reasoning
plandex set-model strong
plandex set-model cheap
plandex set-model oss
plandex set-model gemini
```

### set-model default

Update org-wide default model settings for new plans.

```bash
plandex set-model default # select from a list of model packs or edit via JSON
plandex set-model default daily # set default model pack by name
plandex set-model default --json # edit default settings via JSON file at default path
plandex set-model default --save # save changes from the default model settings JSON file to the server
plandex set-model default --json --file /path/to/settings.json # set default model settings from a JSON file at a non-default path
```

Works exactly the same as `set-model` above, but sets the default model settings for all new plans instead of only the current plan.

### model-packs

Show all available model packs.

```bash
plandex model-packs # list built-in and custom model packs
plandex model-packs --custom # list custom model packs only
```

`--custom`: Show available custom (user-created) model packs only.


### model-packs show

Show a built-in or custom model pack's settings.

```bash
plandex model-packs show # select from a list of built-in and custom model packs
plandex model-packs show some-model-pack # by name
```

## Account Management

### sign-in

Sign in, accept an invite, or create an account.

```bash
plandex sign-in
```

`--pin`: Sign in with a pin from the Plandex Cloud web UI.

Unless you pass `--pin` (from the Plandex Cloud web UI), Plandex will prompt you for all required information to sign in, accept an invite, or create an account.

### invite

Invite a user to join your org.

```bash
plandex invite # prompt for email, name, and role
plandex invite name@domain.com 'Full Name' member # invite with email, name, and role
```

Users can be invited as `member`, `admin`, or `owner`.

### revoke

Revoke an invite or remove a user from your org.

```bash
plandex revoke # select from a list of users and invites
plandex revoke name@domain.com # by email
```

### users

List users and pending invites in your org.

```bash
plandex users
```

## Integrations

### connect-claude

Connect a Claude Pro or Max subscription. When Plandex calls Anthropic models, it will use your Claude subscription up to its quota.

```bash
plandex connect-claude
```

### disconnect-claude

```bash
plandex disconnect-claude
```

Disconnect your Claude Pro or Max subscription and clear credentials from your device. 

### claude-status

```bash
plandex claude-status
```

Shows whether a Claude Pro or Max subscription is connected, and whether the quota has been exceeded.

## Plandex Cloud

### billing

Show the billing settings page.

```bash
plandex billing
```

### usage

Show Plandex Cloud current balance and usage report. Includes recent spend, amount saved by input caching, a breakdown of spend by plan, category, and model, and a log of individual transactions with the `--log` flag.

Defaults to showing usage for the current session if you're using the REPL. Otherwise, defaults to showing usage for the day so far.

Requires **Integrated Models** mode.

```bash
plandex usage
```

`--today`: Show usage for the day so far.

`--month`: Show usage for the current billing month.

`--plan`: Show usage for the current plan.

`--log`: Show a log of individual transactions. Defaults to showing the log for the current session if you're using the REPL. Otherwise, defaults to showing the log for the day so far. Works with `--today`, `--month`, and `--plan` flags.

Flags for `usage --log`:

`--debits`: Show only debits in the log.

`--purchases`: Show only purchases in the log.

`--page-size/-s`: Number of transactions to display per page.

`--page/-p`: Page number to display.








================================================
FILE: docs/docs/core-concepts/_category_.json
================================================
{
  "label": "Core Concepts",
  "position": 5,
  "collapsible": true,
  "collapsed": false
}

================================================
FILE: docs/docs/core-concepts/autonomy.md
================================================
---
sidebar_position: 10
sidebar_label: Autonomy Levels
---

# Autonomy

Plandex v2 offers multiple levels of autonomy with pre-set config. Each autonomy level controls:

- Context loading and management
- Plan continuation through multiple steps
- Building of changes into pending updates
- Application of changes to project files
- Command execution and debugging
- Git commits after changes are applied successfully

## Autonomy Matrix

| Feature               | None | Basic | Plus | Semi | Full |
| --------------------- | ---- | ----- | ---- | ---- | ---- |
| `auto-continue`       | ❌   | ✅    | ✅   | ✅   | ✅   |
| `auto-build`          | ❌   | ✅    | ✅   | ✅   | ✅   |
| `auto-load-context`   | ❌   | ❌    | ❌   | ✅   | ✅   |
| `smart-context`       | ❌   | ❌    | ✅   | ✅   | ✅   |
| `auto-update-context` | ❌   | ❌    | ✅   | ✅   | ✅   |
| `auto-apply`          | ❌   | ❌    | ❌   | ❌   | ✅   |
| `can-exec`            | ❌   | ❌    | ✅   | ✅   | ✅   |
| `auto-exec`           | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-debug`          | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-commit`         | ❌   | ❌    | ✅   | ✅   | ✅   |

## Setting Autonomy Levels

### Using the CLI

```bash
# For current plan
plandex set-auto none    # No automation
plandex set-auto basic   # Auto-continue only
plandex set-auto plus    # Smart context management
plandex set-auto semi    # Auto-load context
plandex set-auto full    # Full automation

# For default settings on new plans
plandex set-auto default basic   # Set default to basic
```

### When Starting the REPL

```bash
plandex --no-auto    # Start with 'None'
plandex --basic      # Start with 'Basic'
plandex --plus       # Start with 'Plus'
plandex --semi       # Start with 'Semi'
plandex --full       # Start with 'Full'
```

### When Creating a New Plan

```bash
plandex new --no-auto    # Create with 'None'
plandex new --basic      # Create with 'Basic'
plandex new --plus       # Create with 'Plus'
plandex new --semi       # Create with 'Semi'
plandex new --full       # Create with 'Full'
```

### Using the REPL

```
\set-auto none    # Set to None
\set-auto basic   # Set to Basic
\set-auto plus    # Set to Plus
\set-auto semi    # Set to Semi-Auto
\set-auto full    # Set to Full-Auto
```

## Autonomy Levels

### None

Complete manual control with no automation:

- Manual context loading
- Context updates require approval
- Manual plan continuation
- Manual building of changes
- Manually apply changes
- Command execution disabled

### Basic

_Equivalent to Plandex v1 autonomy level_

Minimal automation:

- Manual context loading
- Context updates require approval
- Auto-continue plans until completion
- Auto-build changes into pending updates
- Manually apply changes
- Command execution disabled

### Plus

Smart context management and manual command execution:

- Manual context loading
- Auto-update context when files change
- Auto-continue plans until completion
- Smart context management (only loads necessary files during implementation steps)
- Auto-build changes into pending updates
- Manually apply changes
- Manual command execution
- Auto-commit changes to git when applied

### Semi

_Default autonomy level for a fresh Plandex v2 install_

Automatic context loading:

- Auto-load context using project map
- Auto-update context when files change
- Auto-continue plans until completion
- Smart context management
- Auto-build changes into pending updates
- Manually apply changes
- Manual command execution
- Auto-commit changes to git when applied

### Full

Complete automation:

- Auto-load context using project map
- Auto-continue plans until completion
- Smart context management
- Auto-update context when files change
- Auto-build changes into pending updates
- Auto-apply changes to project files
- Auto-execute commands after successful apply
- Auto-debug failing commands
- Auto-commit changes to git when applied

### Custom

You can give a plan custom autonomy settings by setting config values directly:

```bash
plandex set-config auto-continue true
plandex set-config auto-build true
plandex set-config auto-load-context true
```

[More details on configuration](./configuration.md)

## Safety

Be extremely careful with full auto mode! It can make many changes quickly without any prompting or review, and can run commands that could potentially be destructive to your system.

It's a good idea to make sure your git state is clean, and to check out an isolated branch before running these commands.


================================================
FILE: docs/docs/core-concepts/background-tasks.md
================================================
---
sidebar_position: 12
sidebar_label: Background Tasks
---

# Background Tasks

Plandex allows you to run tasks in the background, helping you work on multiple tasks in parallel.

**Note:** in Plandex v2, sending tasks to the background is disabled by default, because it's not compatible with automatic context loading. If you set a lower [autonomy level](./autonomy.md), you can use background tasks.

## Running a Task in the Background

To run a task in the background, use the `--bg` flag with `plandex tell` or `plandex continue`.

```bash
plandex tell --bg "Add an update credit card form to 'src/components/billing'"
plandex continue --bg
```

The plandex stream TUI also has a `b` hotkey that allows you to send a streaming plan to the background.

## Listing Background Tasks

To list active and recently finished background tasks, use the `plandex ps` command:

```bash
plandex ps
```

## Connecting to a Background Task

To connect to a running background task and view its stream in the plan stream TUI, use the `plandex connect` command:

```bash
plandex connect
```

## Stopping a Background Task

To stop a running background task, use the `plandex stop` command:

```bash
plandex stop
```


================================================
FILE: docs/docs/core-concepts/branches.md
================================================
---
sidebar_position: 8
sidebar_label: Branches
---

# Branches

Branches in Plandex allow you to easily try out multiple approaches to a task and see which gives you the best results. They work in conjunction with [version control](./version-control.md). Use cases include:

- Comparing different prompting strategies.
- Comparing results with different files in context.
- Comparing results with different models or model-settings.
- Using `plandex rewind` without losing history (first check out a new branch, then rewind).

## Creating a Branch

To create a new branch, use the `plandex checkout` command:

```bash
plandex checkout new-branch
pdxd new-branch # alias
```

## Switching Branches

To switch to a different branch, also use the `plandex checkout` command:

```bash
plandex checkout existing-branch
```

## Listing Branches

To list all branches, use the `plandex branches` command:

```bash
plandex branches
```

## Deleting a Branch

To delete a branch, use the `plandex delete-branch` command:

```bash
plandex delete-branch branch-name
```


================================================
FILE: docs/docs/core-concepts/configuration.md
================================================
---
sidebar_position: 11
sidebar_label: Configuration
---

# Configuration

Plandex provides a flexible configuration system that lets you customize its behavior based on the task you're working on and your preferences.

## Viewing Config

```bash
plandex config           # View current plan's configuration
plandex config default   # View default configuration for new plans
```

## Modifying Config

```bash
plandex set-config                       # Select from a list of options
plandex set-config auto-apply true       # Set a specific option
plandex set-config default auto-mode basic   # Set default for new plans
```

## Key Settings

### Autonomy Level

Autonomy settings control the overall level of automation Plandex will use. See the [Autonomy](./autonomy.md) page for more details and shortcuts for setting autonomy levels.

| Setting               | Description                                                      | Default |
| --------------------- | ---------------------------------------------------------------- | ------- |
| `auto-mode`           | Overall autonomy level (`none`, `basic`, `plus`, `semi`, `full`) | `semi` |

### Plan Control

| Setting               | Description                                                      | Default |
| --------------------- | ---------------------------------------------------------------- | ------- |
| `auto-continue`       | Continue plans until completion                                  | `true`  |
| `auto-build`          | Build changes into pending updates                               | `true`  |
| `auto-apply`          | Apply changes to project files                                   | `false` |

### Context Management

| Setting                 | Description                              | Default |
| ----------------------- | ---------------------------------------- | ------- |
| `auto-update-context` | Update context when files change           | `true`  |
| `auto-load-context`     | Load context using project map           | `true`  |
| `smart-context`         | Load only necessary files for each step  | `true`  |

### Execution

| Setting                 | Description                              | Default |
| ----------------------- | ---------------------------------------- | ------- |
| `can-exec`              | Allow command execution (safety setting) | `true`  |
| `auto-exec`             | Automatically execute commands           | `true` |
| `auto-debug`            | Automatically debug commands             | `false` |
| `auto-debug-tries`      | Number of tries for automatic debugging  | `5`     |

### Version Control

| Setting                 | Description                              | Default |
| ----------------------- | ---------------------------------------- | ------- |
| `auto-commit`           | Commit changes to git when applied       | `true` |
| `auto-revert-on-rewind` | Revert project files when rewinding      | `true`  |

### Changes Menu

| Setting                 | Description                              | Default |
| ----------------------- | ---------------------------------------- | ------- |
| `skip-changes-menu`     | Skip interactive menu when response finishes and changes are pending | `false` |



### Editor

| Setting                 | Description                              | Default |
| ----------------------- | ---------------------------------------- | ------- |
| `editor`                | Editor to use for editing files          |   |




## Command Line Overrides

Many settings can be overridden with command line flags:

```bash
# this will apply changes, automatically execute commands, and automatically debug regardless of your autonomy level and config settings
plandex tell "add a feature" --apply --auto-exec --debug
```

These overrides apply only to the current command execution and don't change the saved configuration.

See the [CLI Reference](../cli-reference.md) for a full list of command line flags for each command.

## REPL Commands

```
\config                # View current plan config
\config default        # View default config
\set-config            # Modify current plan config
\set-config default    # Modify default config for new plans
\set-auto              # Set autonomy level
\set-auto default      # Set default autonomy level for new plans
```


================================================
FILE: docs/docs/core-concepts/context-management.md
================================================
---
sidebar_position: 3
sidebar_label: Context
---

# Context Management

Context in Plandex refers to files, directories, URLs, images, notes, or piped in data that the LLM uses to understand and work on your project. Context is always associated with a [plan](./plans.md).

Changes to context are [version controlled](./version-control.md) and can be [branched](./branches.md).

## Automatic vs. Manual

As of v2, Plandex loads context automatically by default. When a new plan is created, a [project map](#loading-project-maps) is generated and loaded into context. The LLM then uses this map to select relevant context before planning a task or responding to a message.

### Tradeoffs

Automatic context loading makes Plandex more powerful and easier to work with, but there are tradeoffs in terms of cost, focus, and output speed. If you're trying to minimize costs or you know for sure that only one or two files are relevant to a task, you might prefer to load context manually.

### Setting Manual Mode

You can use manual context loading by:

- Using `set-auto` to choose a lower [autonomy level](./autonomy.md) that has auto-load-context disabled (like `plus` or `basic`).

```bash
plandex set-auto plus
plandex set-auto basic
plandex set-auto default plus # set the default value for all new plans
```

- Starting a new REPL or a new plan with the `--plus` or `--basic` flags, which will automatically set the config option to the chosen autonomy level.

```bash
plandex --plus
plandex new --basic
```

- Setting the `auto-load-context` [config option](./configuration.md) to `false`:

```bash
plandex set-config auto-load-context false
plandex set-config default auto-load-context false # set the default value for all new plans
```

### Smart Context Window Management

Another new context management feature in v2 is smart context window management. When making a plan with multiple steps, Plandex will determine which files are relevant to each step. Only those files will be loaded into context during implementation.

When combined with automatic context loading, this effectively creates a sliding context window that grows and shrinks as needed throughout the plan.

Smart context can also be used when you're managing context manually. To give an example: say you've manually loaded a directory with 10 files in it, and you need to make some updates to each one of them. Without smart context, each step of the implementation will load all 10 files into context. But if you use smart context, only the one or two files that are edited in each step will be loaded.

Smart context is enabled in the `plus` autonomy level and above. You can also toggle it with `set-config`:

```bash
plandex set-config smart-context true
plandex set-config smart-context false
plandex set-config default smart-context false # set the default value for all new plans
```

### Automatic Context Updates

When you make your own changes to files in context separately from Plandex, those files need to be updated before the plan can continue. Previously, Plandex would prompt you to update context every time a file was changed. This is now automatic by default.

Automatic updates are enabled in the `plus` autonomy level and above. You can also toggle them with `set-config`:

```bash
plandex set-config auto-update-context true
plandex set-config auto-update-context false
plandex set-config default auto-update-context false # set the default value for all new plans
```

### Autonomy Matrix

Here are the different autonomy levels as they relate to context management config options:

|                       | `none` | `basic` | `plus` | `semi` | `full` |
| --------------------- | ------ | ------- | ------ | ------ | ------ |
| `auto-load-context`   | ❌     | ❌      | ❌     | ✅     | ✅     |
| `smart-context`       | ❌     | ❌      | ✅     | ✅     | ✅     |
| `auto-update-context` | ❌     | ❌      | ✅     | ✅     | ✅     |

### Mixing Automatic and Manual Context

You can manually load additional context even if automatic loading is enabled. The way this additional context is handled works somewhat differently.

First, consider how automatic context loading works across each stage of a plan:

#### Automatic context loading (no manual context added)

1. **Context loading:** Only the project map is initially loaded. The map, along with your prompt, is used to select relevant context.
2. **Planning:** Only context selected in step 1 is loaded.
3. **Implementation:** Smart context (if enabled) filters context again, loading only what's directly relevant to each step.

Here's how it changes when you load manual context on top:

#### Automatic loading + manual context

1. **Context loading:** Your manually loaded context is **always included** alongside the project map.
2. **Planning:** Manually loaded context is always loaded, whether or not it's selected by the map-based context selection step.
3. **Implementation:** Smart context (if enabled) filters all context again (both manual and automatic), loading only what's directly relevant to each implementation step.

Loading files manually when using automatic context loading can sometimes be useful when you **know** certain files are relevant and don't want to risk the LLM leaving them out, or when the LLM is struggling to select the right context. If there are files that can help the LLM select the right context, like READMEs or documentation that describes the structure of the project, those can also be good candidates for manual loading.

Another use for manual context loading is for context types that can't be loaded automatically, like URLs, notes, or piped data (for now Plandex can only automatically load project files and images within the project).

## Manually Loading Context

To load files, directories, directory layouts, urls, images, notes, or piped data into a plan's context, use the `plandex load` command.

### Loading Files

You can pass `load` one or more file paths. File paths are relative to the current directory in your terminal.

```bash
plandex load component.ts # single file
plandex load component.ts action.ts reducer.ts # multiple files
pdx l component.ts # alias
```

You can also load multiple files using glob patterns:

```bash
plandex load tests/**/*.ts # loads all .ts files in 'tests' and its subdirectories
plandex load * # loads all files in the current directory
```

You can load context from parent or sibling directories if needed by using `..` in your load paths.

```bash
plandex load ../file.go # loads file.go from parent directory
plandex load ../sibling-dir/test.go # loads test.go from sibling directory
```

### Loading Directories

You can load an entire directory with the `--recursive/-r` flag:

```bash
plandex load lib -r # loads lib, all its files and all its subdirectories
plandex load * -r # loads all files in the current directory and all its subdirectories
```

### Loading Files and Directories in the REPL

In the [Plandex REPL](../repl.md), you can use the shortcut `@` plus a relative file path to load a file or directory into context.

```bash
@component.ts # loads component.ts
@lib # loads lib directory, and all its files and subdirectories
```

### Loading Directory Layouts

There are tasks where it's helpful for the LLM to the know the structure of your project or sections of your project, but it doesn't necessarily need to the see the content of every file. In that case, you can pass in a directory with the `--tree` flag to load in the directory layout. It will include just the names of all included files and subdirectories (and each subdirectory's files and subdirectories, and so on).

```bash
plandex load . --tree # loads the layout of the current directory and its subdirectories (file names only)
plandex load src/components --tree # loads the layout of the src/components directory
```

### Loading Project Maps

Plandex can create a **project map** for any directory using [tree-sitter](https://tree-sitter.github.io/tree-sitter). This shows all the top-level symbols, like variables, functions, classes, etc. in each file. 30+ languages are supported. For non-supported languages, files are still listed without symbols so that the model is aware of their existence.

Maps are mainly used for selecting context during automatic context loading, but can also be used with manual context management in order to improve output. Maps make it much more likely that an LLM will, for example, use an existing function in your project (and call it correctly) rather than generating a new one that does the same thing.

```bash
plandex load . --map
```

### Loading URLs

Plandex can load the text content of URLs, which can be useful for adding relevant documentation, blog posts, discussions, and the like.

```bash
plandex load https://redux.js.org/usage/writing-tests # loads the text-only content of the url
```

### Loading Images

Plandex can load images into context.

```bash
plandex load ui-mockup.png
```

For most models that support images, png, jpeg, non-animated gif, and webp formats are supported. Some models may support fewer or additional formats.

### Loading Notes

You can add notes to context, which are just simple strings.

```bash
plandex load -n 'add logging statements to all the code you generate.' # load a note into context
```

Notes can be useful as 'sticky' explanations or instructions that will tend to have more prominence throughout a long conversation than normal prompts. That's because long conversations are summarized to stay below a token limit, which can cause some details from your prompts to be dropped along the way. This doesn't happen if you use notes.

### Piping Into Context

You can pipe the results of other commands into context:

```bash
npm test | plandex load # loads the output of `npm test`
```

### Ignoring files

If you're in a git repo, Plandex respects `.gitignore` and won't load any files that you're ignoring. You can also add a `.plandexignore` file with ignore patterns to any directory.

You can force Plandex to load ignored files with the `--force/-f` flag:

```bash
plandex load .env --force # loads the .env file even if it's in .gitignore or .plandexignore
```

## Viewing Context

To list everything in context, use the `plandex ls` command:

```bash
plandex ls
```

You can also see the content of any context item with the `plandex show` command:

```bash
plandex show component.ts # show the content of component.ts
plandex show 2 # show the content of the second item in the `plandex ls` list
```

## Removing Context

To remove selectively remove context, use the `plandex rm` command:

```bash
plandex rm component.ts # remove by name
plandex rm 2 # remove by number in the `plandex ls` list
plandex rm 2-5 # remove a range of indices
plandex rm lib/**/*.js # remove by glob pattern
plandex rm lib # remove whole directory
```

## Clearing Context

To clear all context, use the `plandex clear` command:

```bash
plandex clear
```

## Updating Context

If files, directory layouts, or URLs in context are modified outside of Plandex, they will need to be updated next time you send a prompt.

Whether they'll be updated automatically or you'll be prompted to update them depends on the `auto-update-context` config option.

You can also update any outdated files with the `update` command.

```bash
plandex update # update files in context
```


================================================
FILE: docs/docs/core-concepts/conversations.md
================================================
---
sidebar_position: 9
sidebar_label: Conversations
---

# Conversations

Each time you send a prompt to Plandex or Plandex responds, the plan's **conversation** is updated. Conversations are [version controlled](./version-control.md) and can be [branched](./branches.md).

## Conversation History

You can see the full conversation history with the `convo` command.

```bash
plandex convo # show the full conversation history
```

You can output the conversation in plain text with no ANSI codes with the `--plain` or `-p` flag.

```bash
plandex convo --plain
```

You can also show a specific message number or range of messages.

```bash
plandex convo 1 # show the initial prompt
plandex convo 1-5 # show messages 1 through 5
plandex convo 2- # show messages 2 through the end of the conversation
```

## Conversation Summaries

Every time the AI model replies, Plandex will summarize the conversation so far in the background and store the summary in case it's needed later. When the conversation size in tokens exceeds the model's limit, Plandex will automatically replace some number of older messages with the corresponding summary. It will summarize as many messages as necessary to keep the conversation size under the limit.

Summaries are also used by the model as a form of working memory to keep track of the state of the plan—what's been implemented and what remains to be done.

You can see the latest summary with the `summary` command.

```bash
plandex summary # show the latest conversation summary
```

As with the `convo` command, you can output the summary in plain text with no ANSI codes with the `--plain` or `-p` flag.

```bash
plandex summary --plain
```


================================================
FILE: docs/docs/core-concepts/execution-and-debugging.md
================================================
---
sidebar_position: 6
sidebar_label: Execution and Debugging
---

# Execution and Debugging

Plandex includes command execution and automated debugging capabilities that aim to balance power, control, and safety.

## Command Execution

During a plan, apart from making changes to files, Plandex can write to a special path, `_apply.sh`, with any commands required to complete the plan. This commonly includes installing dependencies, running tests, building and running code, starting servers, and so on.

Commands accumulate in the sandbox just like [pending changes to files](./reviewing-changes.md). If execution fails, you can roll back changes and optionally send the output to the model for automated debugging and retries.

While Plandex will attempt to automatically infer relevant commands to run, it also tries not to overdo it. It generally won't, for example, run a test suite unless you've specifically asked it to, since it may not be desirable after every change. It tries to only run what's strictly necessary, to make local project-level changes instead of global system-wide changes, to check existing dependencies before installing, to write idempotent commands, to avoid hiding output or asking for user input, and to recover gracefully from failures.

If you want specific commands to run and Plandex isn't including automatically them because of it's somewhat conservative approach, you can either mention them in the prompt, or you can use the `plandex debug` command to automatically debug based on the output of any command you choose.

### Debugging Browser Applications

If Chrome is installed, Plandex can automatically debug browser applications by catching errors and reading the console logs.

If a plan calls for starting a browser, Plandex will automatically include a `plandex browser` call to start Chrome and monitor for errors.
   
### Execution Config

Control whether Plandex can execute commands:

```bash
plandex set-config can-exec true  # Allow command execution (default)
plandex set-config can-exec false # Disable command execution
```

If you toggle `can-exec` to `false`, Plandex will completely skip writing any commands to `_apply.sh`.

Control whether commands are executed automatically after applying changes (be careful with this):

```bash
plandex set-config auto-exec true  # Auto-execute commands
plandex set-config auto-exec false # Prompt before executing (default)
```

## Automated Debugging

The `plandex debug` command repeatedly runs a terminal command, making fixes until it succeeds:

```bash
plandex debug 'npm test'  # Try up to 5 times (default)
plandex debug 10 'npm test'  # Try up to 10 times
```

This will:

1. Run the command and check for success/failure
2. If it fails, send the output to the LLM
3. Tentatively apply suggested fixes to your project files
4. If command is succesful after fixes, commit changes (if auto-commit is enabled). Otherwise, roll back changes and return to step 2.
5. Repeat until success or max tries reached

You can configure the default number of tries:

```bash
plandex set-config auto-debug-tries 10  # Set default to 10 tries
```

## Common Debugging Workflows

### Fixing Failing Tests

```bash
plandex debug 'npm test'
plandex debug 'go test ./...'
plandex debug 'pytest'
```

### Fixing Build Errors

```bash
plandex debug 'npm run build'
plandex debug 'go build'
plandex debug 'cargo build'
```

### Fixing Linting Errors

```bash
plandex debug 'npm run lint'
plandex debug 'golangci-lint run'
```

### Fixing Type Errors

```bash
plandex debug 'npm run typecheck'
plandex debug 'tsc --noEmit'
```

## A Manual Alternative

For a less automated approach, you can pipe the output of a command into `plandex chat` or `plandex tell`.

```bash
npm test | plandex tell 'npm test output'
go build | plandex chat 'what could be causing these type errors?'
```

This works similarly to `plandex debug` but without automatically applying changes and retrying.

Note that piping output into a prompt requires using the CLI directly in the terminal. You can't do it from inside the [REPL](../repl.md).

## Autonomy Matrix

Execution and debugging behavior is affected by your [autonomy level](./autonomy.md):

| Setting      | None | Basic | Plus | Semi | Full |
| ------------ | ---- | ----- | ---- | ---- | ---- |
| `can-exec`   | ❌   | ❌    | ✅   | ✅   | ✅   |
| `auto-exec`  | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-debug` | ❌   | ❌    | ❌   | ❌   | ✅   |


With `full` autonomy, commands are automatically executed and debugged after changes are applied. For other levels, you'll be prompted to approve execution and debugging steps.

## Safety

Needless to say, you should be extremely careful when using full auto mode, `auto-exec`, `auto-debug`, and the `debug` command. They can make many changes quickly without any prompting or review, and can run commands that could potentially be destructive to your system. While the best LLMs are quite trustworthy when it comes to running commands and are unlikely to cause harm, it still pays to be cautious.

It's a good idea to make sure your git state is clean, and to check out an isolated branch before using these features.


================================================
FILE: docs/docs/core-concepts/orgs.md
================================================
---
sidebar_position: 13
sidebar_label: Collaboration / Orgs
---

# Collaboration and Orgs

While so far Plandex is mainly focused on a single-user experience, we plan to add features for sharing, collaboration, and team management in the future, and some groundwork has already been done. **Orgs** are the basis for collaboration in Plandex.

## Multiple Users

Orgs are helpful already if you have multiple users using Plandex in the same project. Because Plandex outputs a `.plandex` file containing a bit of non-sensitive config data in each directory a plan is created in, you'll have problems with multiple users unless you either get each user into the same org or put `.plandex` in your `.gitignore` file. Otherwise, each user will overwrite other users' `.plandex` files on every push, and no one will be happy.

## Domain Access

When starting out with Plandex and creating a new org, you have the option of automatically granting access to anyone with an email address on your domain.

## Invitations

If you choose not to grant access to your whole domain, or you want to invite someone from outside your email domain, you can use `plandex invite`:

```bash
plandex invite
```

## Joining an Org

To join an org you've been invited to, use `plandex sign-in`:

```bash
plandex sign-in
```

## Listing Users and Invites

To list users and pending invites, use `plandex users`:

```bash
plandex users
```

## Revoking Users and Invites

To revoke an invite or remove a user, use `plandex revoke`:

```bash
plandex revoke
```


================================================
FILE: docs/docs/core-concepts/plans.md
================================================
---
sidebar_position: 1
sidebar_label: Plans
---

# Plans

A **plan** in Plandex is similar to a conversation in ChatGPT or Claude. It might only include a single prompt and model response that executes one small task, or it could represent a long back and forth with the model that generates dozens of files and builds a whole feature or an entire project.

A plan includes:

- Any [context](./context-management.md) that you or the model have loaded.
- Your [conversation](./conversations.md) with the model.
- Any [pending changes](./reviewing-changes.md) that have been accumulated during the course of the conversation.

Plans support [version control](./version-control.md) and [branches](./branches.md).

## Creating a New Plan

First `cd` into your **project's directory.** Make a new directory first with `mkdir your-project-dir` if you're starting on a new project.

```bash
cd your-project-dir
```

### REPL

To start a new plan with the REPL, just run:

```bash
plandex
```

If you haven't created a new plan in this directory previously, a plan will automatically be created for you when the REPL starts.

If already have a plan loaded in the REPL (you can check with `\current`), you can start a new plan with `\new`.

### CLI

You can create a new plan through the CLI with `plandex new`.

```bash
plandex new
```

## Plan Names and Drafts

When you create a plan, Plandex will automatically name your plan after you send the first prompt, but you can also give it a name up front.

```bash
plandex new -n foo-adapters-component
```

If you don't give your plan a name up front, it will be named `draft` until you send an initial prompt. To keep things tidy, you can only have one active plan named `draft`. If you create a new draft plan, any existing draft plan will be removed.

## Listing Plans

When you have multiple plans, you can list them with the `plans` command.

```bash
plandex plans
```

## The Current Plan

It's important to know what the **current plan** is for any given directory, since most Plandex commands are executed against that plan.

To check the current plan:

```bash
plandex current
```

You can change the current plan with the `cd` command:

```
plandex cd # select from a list of plans
plandex cd some-other-plan # cd to a plan by name
plandex cd 2 # cd to a plan by number in the `plandex plans` list
```

## Deleting Plans

You can delete a plan with the `delete-plan` command:

```bash
plandex delete-plan # select from a list of plans to delete
plandex delete-plan some-plan # delete a plan by name
plandex delete-plan 4 # delete a plan by number in the `plandex plans` list
```

## Archiving Plans

You can archive plans you want to keep around but aren't currently working on with the `archive` command. You can see archived plans in the current directory with `plans --archived`. You can unarchive a plan with the `unarchive` command.

```bash
plandex archive # select from a list of plans to archive
plandex archive some-plan # archive a plan by name
plandex archive 2 # archive a plan by number in the `plandex plans` list

plandex unarchive # select from a list of archived plans to unarchive
plandex unarchive some-plan # unarchive a plan by name
plandex unarchive 2 # unarchive a plan by number in the `plandex plans --archived` list
```

## .plandex Directory

When you run `plandex` (for a REPL) or `plandex new` for the first time in any directory, Plandex will create a `.plandex` directory there for light project-level config.

If multiple people are using Plandex with the same project, you should either:

- **Commit** the `.plandex` directory and get everyone into the same [org](./orgs.md) in Plandex.
- Put `.plandex/` in `.gitignore`

## Project Directories

So far, we've assumed you're running `plandex` or `plandex new` to create plans in your project's root directory. While that is the most common use case, it can be useful to create plans in subdirectories of your project too.

That's because context file paths in Plandex are specified relative to the directory where the plan was created. So if you're working on a plan for just one part of your project, you might want to create the plan in a subdirectory in order to shorten paths when loading context or referencing files in your prompts.

Starting a plan (or REPL) in a subdirectory is also helpful when using [automatic context loading](./context-management.md#automatic-vs-manual) to limit the size of the project map and what files are available for the LLM to load.

It can also help with plan organization if you have a lot of plans.

When you run `plandex plans`, in addition to showing you plans in the current directory, Plandex will also show you plans in nearby parent directories or subdirectories. This helps you keep track of what plans you're working on and where they are in your project hierarchy. If you want to switch to a plan in a different directory, first `cd` into that directory, then run `plandex cd` to select the plan.


================================================
FILE: docs/docs/core-concepts/prompts.md
================================================
---
sidebar_position: 4
sidebar_label: Prompts
---

# Prompts

## Sending Prompts

### In the REPL

To send a prompt in the [REPL](../repl.md), just type your prompt and press enter.

You can also use `\multi` to enable multi-line mode. This will cause enter to produce line breaks. In multi-line mode, you can send your prompt with `\send`.

If you want to pass in a file as a prompt in the REPL, you can use the `\run` command with a relative file path:

```
\run src/components/foobars-form.tsx
```

### With the CLI

To send a prompt with the CLI, use the `plandex tell` command for a task, or the `plandex chat` command to brainstorm or ask questions.

You can pass it in as a file with the `--file/-f` flag:

```bash
plandex tell -f prompt.txt
plandex chat -f prompt.txt
```

Write it in vim:

```bash
plandex tell # tell with no arguments opens vim so you can write your prompt there
plandex chat # chat with no arguments does the same
```

Pass it inline (use enter for line breaks):

```bash
plandex tell "add a new line chart showing the number of foobars over time to components/charts.tsx"
plandex chat "where's the database connection logic in this project?"
```

You can also pipe in the results of another command:

```bash
git diff | plandex tell
git diff | plandex chat
```

When you pipe in results like this, you can also supply an inline string to give a label or additional context to the results:

```bash
git diff | plandex tell "'git diff' output"
```

## Plan Stream TUI

After you send a prompt with the REPL, `plandex tell`, or `plandex chat`, you'll see the plan stream TUI. The model's responses are streamed here. You'll see several hotkeys listed along the bottom row that allow you to stop the plan (s), send the plan to the background (b), scroll/page the streamed text, or jump to the beginning or end of the stream. If you're a vim user, you'll notice Plandex's scrolling hotkeys are the same as vim's.

Note that scrolling the terminal window itself won't work while you're in the stream TUI. Use the scroll hotkeys instead.

## Task Prompts

When you give Plandex a task, it will first break down the task into steps, then it will proceed to implement each step in code. Plandex will automatically continue sending model requests until the task is determined to be complete.

## Chat Prompts

If you want to ask Plandex questions or chat without generating files or making changes, use the `plandex chat` command instead of `plandex tell`.

```bash
plandex chat "explain every function in lib/math.ts"
```

Plandex will reply with just a single response, won't create or update any files, and won't automatically continue.

`plandex chat` has the same options for passing in a prompt as `plandex tell`. You can pass a string inline, give it a file with `--file/-f`, type the prompt in vim by running `plandex chat` with no arguments, or pipe in the results of another command.

### In the REPL

In the REPL, you can control whether prompts are sent to `plandex tell` or `plandex chat` under the hood by toggling `chat mode` with `\chat (\ch)` or `\tell (\t)`.

## Stopping and Continuing

When using `plandex tell`, you can prevent Plandex from automatically continuing for multiple responses by passing the `--stop/-s` flag:

```bash
plandex tell -s "write tests for the charting helpers in lib/chart-helpers.ts"
```

Plandex will then reply with just a single response. From there, you can continue if desired with the `continue` command. Like `tell`, `continue` can also accept a `--stop/-s` flag. Without the `--stop/-s` flag, `continue` will also cause Plandex to continue automatically until the task is done. If you pass the `--stop/-s` flag, it will continue for just one more response.

```bash
plandex continue -s
```

Apart from `--stop/-s` Plandex's plan stream TUI also has an `s` hotkey that allows you to immediately stop a plan.

You can also stop a plan from automatically continuing by setting the `auto-continue` config option to `false` in a plan's [configuration](./configuration.md):

```bash
plandex set-config auto-continue false
plandex set-config default auto-continue false # set the default config's auto-continue to false for all new plans
```

or by setting the `auto-mode` ([autonomy level](./autonomy.md)) to `none`:

```bash
plandex set-auto none
plandex set-default-auto none # set the default auto-mode to none for all new plans
```

## Background Tasks

By default, `plandex tell` opens the plan stream TUI and streams Plandex's response(s) there, but you can also pass the `--bg` flag to run a task in the background instead.

You can learn more about using and interacting with background tasks [here](./background-tasks.md).

## Keeping Context Updated

When you send a prompt, whether through `plandex tell` or `plandex chat`, Plandex will check whether the content of any files, directory layouts, or URLs you've loaded into [context](./context-management.md) have changed. If so, you'll need to update the context before continuing.

By default, Plandex will update any outdated context automatically, but if you'd rather approve these updates, you can set the `auto-update-context` config option to `false`:

```bash
plandex set-config auto-update-context false
plandex set-config default auto-update-context false # set the default config's auto-update-context to false for all new plans
```

or you can set the `auto-mode` to `basic` or `none`:

```bash
plandex set-auto basic
plandex set-auto none
```

## Building Files

As Plandex implements your task, files it creates or updates will appear in the `Building Plan` section of the plan stream TUI. Plandex will **build** all changes proposed by the plan into a set of pending changesets for each affected file.

By default, these changes initially **will not** be directly applied to your project files. Instead, they will be **pending** in Plandex's version-controlled sandbox.

This allows you to review the proposed changes or continue iterating and accumulating more changes. You can view the pending changes with `plandex diff` (for git diff format in the terminal) or `plandex diff --ui` (to view them in a local browser UI). Once you're happy with the changes, you can apply them to your project files with `plandex apply`.

- [Learn more about reviewing changes.](./reviewing-changes.md)
- [Learn more about version control.](./version-control.md)

### Full auto mode

An important caveat to the above: if you set the `auto-mode` to `full`, Plandex _will_ automatically apply the changes to your project files,

### Skipping builds / `plandex build`

You can skip building files when you send a prompt by passing the `--no-build` flag to `plandex tell` or `plandex continue`. This can be useful if you want to ensure that a plan is on the right track before building files.

```bash
plandex tell "implement sign up and sign in forms in src/components" --no-build
```

You can later build any changes that were implemented in the plan with the `plandex build` command:

```bash
plandex build
```

This will show a smaller version of the plan stream TUI that only includes the `Building Plan` section.

Like full plan streams, build streams can be stopped with the `s` hotkey or sent to the background with the `b` hotkey. They can also be run fully in the background with the `--bg` flag:

```bash
plandex build --bg
```

There's one more thing to keep in mind about builds. If you send a prompt with the `--no-build` flag:

```bash
plandex tell "implement a forgot password email in src/emails" --no-build
```

Then you later send _another_ prompt with `plandex tell` or continue the plan with `plandex continue` and you _don't_ include the `--no-build` flag, any changes that were implemented previously but weren't built will immediately start building when the plan stream begins.

```bash
plandex tell "now implement the UI portion of the forgot password flow"
# the above will start building the changes proposed in the earlier prompt that was passed --no-build
```

## Automatically Applying Changes

If you want Plandex to _automatically_ apply changes when a plan is complete, you can pass the `--apply/-a` flag to `plandex tell`, `plandex continue`, or `plandex build`:

```bash
plandex tell "add a new route for updating notification settings to src/routes.ts" --apply
```

The `--apply/-a` flag will also automatically update context if needed, just as the `--yes/-y` flag does.

When passing `--apply/-a`, you can also use the `--commit/-c` flag to commit the changes to git with an auto-generated commit message. This will only commit the specific changes that were made by the plan. Any other changes in your git repository, staged or unstaged, will remain as they are.

```bash
plandex tell "add a new route for updating notification settings to src/routes.ts" --apply --commit
```

## Iterating on a Plan

If you send a prompt:

```bash
plandex tell "implement a fully working and production-ready tic tac toe game, including a computer-controlled AI, in html, css, and javascript"
```

And then you want to iterate on it, whether that's to add more functionality or correct something that went off track, you have a couple options.

### Continue the convo

The most straightforward way to continue iterating is to simply send another `plandex tell` command:

```bash
plandex tell "I plan to seek VC funding for this game, so please implement a dark mode toggle and give all buttons subtle gradient fills"
```

This is generally a good approach when you're happy with the current plan and want to extend it to add more functionality.

Note, you can view the full conversation history with the `plandex convo` command:

```bash
plandex convo
```

### Rewind and iterate

Another option is to use Plandex's [version control](./version-control.md) features to rewind to the point just before your prompt was sent and then update it before sending the prompt again.

You can use `plandex log` to see the plan's history and determine which step to rewind to, then `plandex rewind` with the appropriate hash to rewind to that step:

```bash
plandex log # see the history
plandex rewind accfe9 # rewind to right before your prompt
```

This approach works well in conjunction with **prompt files**. You write your prompts in files somewhere in your codebase, then pass those to `plandex tell` using the `--file/-f` flag:

```bash
plandex tell -f prompts/tic-tac-toe.txt
```

This makes it easy to continuously iterate on your prompt using `plandex rewind` and `plandex tell` until you get a result that you're happy with.

### Which is better?

There's not necessarily one right answer on whether to use an ongoing conversation or the `rewind` approach with prompt files for iteration. Here are a few things to consider when making the choice:

- Bad results tend to beget more bad results. Rewinding and iterating on the prompt is often more effective for correcting a wayward task than continuing to send more `tell` commands. Even if you are specifically prompting the model to _correct_ a problem, having the wrong approach in its context will tend to bias it toward additional errors. Using `rewind` to the give the model a clean slate can work better in these scenarios.

- Iterating on a prompt file with the `rewind` approach until you find your way to an effective prompt has another benefit: you can keep the final version of the prompt that produced a given set of changes right alongside the changes themselves in your codebase. This can be helpful for other developers (or your future self) if you want to revisit a task later.

- A downside of the `rewind` approach is that it can involve re-running early steps of a plan over and over, which can be **a lot** more expensive than iterating with additional `tell` commands.


================================================
FILE: docs/docs/core-concepts/reviewing-changes.md
================================================
---
sidebar_position: 5
sidebar_label: Pending Changes
---

# Pending Changes

When you give Plandex a task, by default the changes aren't applied directly to your project files. Instead, they are accumulated in Plandex's version-controlled **sandbox** so that you can review them first.

## Review Menu

Once Plandex has finished with a task, you'll see a review menu with several hotkey options. These hotkeys act as shortcuts for the commands described below.

## Viewing Changes

### `plandex diff` / `plandex diff --ui`

When Plandex has finished with your task, you can review the proposed changes with the `plandex diff` command, which shows them in `git diff` format:

```bash
plandex diff
```

`--plain/-p`: Outputs the diff in plain text with no ANSI codes.

You can also view the changes in a local browser UI with the `plandex diff --ui` command:

```bash
plandex diff --ui
```

The UI view offers additional options:

- `--side-by-side/-s`: Show diffs in side-by-side view
- `--line-by-line/-l`: Show diffs in line-by-line view (default)

## Rejecting Files

If the plan's changes were applied incorrectly to a file, or you don't want to apply them for another reason, you can either [apply the changes](#applying-changes) and then fix the problems manually, _or_ you can reject the updates to that file and then make the proposed changes yourself manually.

To reject changes to a file (or multiple files), you can run `plandex reject`. You'll be prompted to select which files to reject.

```bash
plandex reject # select files to reject
```

You can reject _all_ currently pending files by passing the `--all` flag to the reject command, or you can pass a list of specific files to reject:

```bash
plandex reject --all
plandex reject file1.ts file2.ts
```

If you rejected a file due to the changes being applied incorrectly, but you still want to use the code, either scroll up and copy the changes from the plan's output or run `plandex convo` to output the full conversation and copy from there. Then apply the updates to that file yourself.

## Applying Changes

Once you're happy with the plan's changes, you can apply them to your project files with `plandex apply`:

```bash
plandex apply
```

### Apply Flags & Config

Plandex v2 introduced several [new config settings and flags](./configuration.md) for the `apply` command that give you control over what happens after changes are applied.

### Command Execution & Debugging

After applying changes, Plandex can automatically execute pending commands. This is useful for running tests, starting servers, or performing other actions that verify the changes work as expected.

If commands fail, the changes are rolled back. Depending on the autonomy level and config, Plandex will then either attempt to debug automatically or prompt you with debugging options.

## Auto-Applying Changes

When `auto-apply` is enabled, Plandex will automatically apply changes after a plan is complete without prompting or review. This is enabled at the `full` [autonomy level](./autonomy.md), and also during auto-debugging.

## Apply + Full Auto

You can also apply changes and debug in full auto mode with the `--full` flag:

```bash
plandex apply --full
```

## Autonomy Matrix

| Setting       | None | Basic | Plus | Semi | Full |
| ------------- | ---- | ----- | ---- | ---- | ---- |
| `auto-apply`  | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-exec`   | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-debug`  | ❌   | ❌    | ❌   | ❌   | ✅   |
| `auto-commit` | ❌   | ❌    | ✅   | ✅   | ✅   |


================================================
FILE: docs/docs/core-concepts/version-control.md
================================================
---
sidebar_position: 7
sidebar_label: Version Control
---

# Version Control

Just about every aspect of a Plandex plan is version-controlled, and anything that can happen during a plan creates a new version in the plan's history. This includes:

- Adding, removing, or updating context (when you do it manually or when Plandex does it automatically).
- When you send a prompt.
- When Plandex responds.
- When Plandex builds the plan's proposed updates to a file into a pending change.
- When pending changes are rejected.
- When pending changes are applied to your project.
- When models or model settings are updated.

## Viewing History

To see the history of your plan, use the `plandex log` command:

```bash
plandex log
```

## Rewinding

To rewind the plan to an earlier state, use the `plandex rewind` command:

```bash
plandex rewind # Select a previous state to rewind to
plandex rewind 3  # Rewind 3 steps
plandex rewind a7c8d66  # Rewind to a specific step
```

## Preventing History Loss With Branches

Note that currently, there's no way to undo a `rewind` and recover any history that may have been cleared as a result. That said, you can use `rewind` without losing any history with [branches](./branches.md). Use `plandex checkout` to a create a new branch before executing `rewind`, and the original branch will still include the history from before the `rewind`.

```bash
plandex checkout undo-changes # create a new branch called 'undo-changes'
plandex rewind ef883a # history is rewound in 'undo-changes' branch
plandex checkout main # main branch still retains original history
```

## Viewing Conversation

While the Plandex history includes an entry for each message in the conversation, message content isn't included. To see the full conversation history, use the `plandex convo` command:

```bash
plandex convo
```

## Rewinding After `plandex apply`

Like any other action that modifies a plan, running `plandex apply` to apply pending changes to your project file creates a new version in the plan's history. The `plandex apply` action can also be undone with `plandex rewind`.

While previous versions Plandex would not also revert the changes to your project files, this is now the default behavior as of v2.0.0. If there are potential conflicts (i.e. you've made changes on top since applying), Plandex will prompt you to decide how to handle the conflict.

This behavior can be disabled if desired by setting the `auto-revert-on-rewind` config setting to `false`:

```bash
plandex set-config auto-revert-on-rewind false
plandex set-config default auto-revert-on-rewind false # set the default value for all new plans
```


================================================
FILE: docs/docs/development.md
================================================
---
sidebar_position: 10
sidebar_label: Development
---

# Development

To set up a development environment, first install dependencies:

- Go 1.23.3 - [install here](https://go.dev/doc/install)
- [reflex](https://github.com/cespare/reflex) 0.3.1 - for watching files and rebuilding in development. Install with `go install github.com/cespare/reflex@v0.3.1`
- PostgreSQL 14 - https://www.postgresql.org/download/
- Python 3 - for LiteLLM passthrough proxy - [install here](https://www.python.org/downloads/)

Make sure `$GOPATH` is in your $PATH

```bash
# print $GOPATH
echo $GOPATH

# if it's empty
export GOPATH=<path-to-go-folder>
```

Make sure the PostgreSQL server is running and create a database called `plandex`.

Then make sure the following environment variables are set:

```bash
export DATABASE_URL=postgres://user:password@host:5432/plandex?sslmode=disable # replace with your own database URL
export GOENV=development
```

Now from the root directory, run the script in `app/scripts/dev.sh`.

On Linux, you'll want to run this as `sudo` for copying the CLI to `/usr/local/bin` after it builds:

```bash
sudo ./app/scripts/dev.sh
```

You might also need sudo on MacOS if you don't have write permissions to `/usr/local/bin`, but this shouldn't be the case for most users. Assuming you have those write permissions, you can run the script without `sudo`:

```bash
./app/scripts/dev.sh
```

This creates watchers with `reflex` to rebuild both the server and the CLI when relevant files change.

The server runs on port 8099 by default.

After each build, the CLI is copied to `/usr/local/bin/plandex-dev`so you can use it with just `plandex-dev` in any directory. A `pdxd` alias is also created. Note the difference from the `plandex` binary and `pdx` aliases which are installed for production usage—aliases are used for development to avoid overwriting the production install.

The output directory can be changed with the `PLANDEX_DEV_CLI_OUT_DIR` environment variable. The binary name can be changed with `PLANDEX_DEV_CLI_NAME` and the alias can be changed with `PLANDEX_DEV_CLI_ALIAS`.

When running the Plandex CLI, set `export PLANDEX_ENV=development` to run in development mode, which connects to the development server by default.


================================================
FILE: docs/docs/environment-variables.md
================================================
---
sidebar_position: 11
sidebar_label: Environment Variables
---

# Environment Variables

This is an overview of all the environment variables that can be used with Plandex.

## CLI

### General

```bash
PLANDEX_ENV=development # Set this to 'development' to default to the local development server instead of Plandex Cloud when working on Plandex itself.
PLANDEX_API_HOST= # Defaults to 'http://localhost:8099' if PLANDEX_ENV is development, otherwise it's 'https://api.plandex.ai'—override this to use a different host.
```

### LLM Providers

```bash
# OpenRouter.ai
OPENROUTER_API_KEY= # Your OpenRouter.ai API key 

# OpenAI
OPENAI_API_KEY= # Your OpenAI key 
OPENAI_ORG_ID= # Your OpenAI organization ID. Defaults to empty.

# Anthropic
ANTHROPIC_API_KEY= # Your Anthropic API key 

# Google AI Studio
GEMINI_API_KEY= # Your Google AI Studio API key 

# Google Vertex AI
GOOGLE_APPLICATION_CREDENTIALS= # Your Google Vertex AI credentials file path
VERTEXAI_PROJECT= # Your Google Vertex AI project ID
VERTEXAI_LOCATION= # Your Google Vertex AI location

# Azure OpenAI
AZURE_OPENAI_API_KEY= # Your Azure OpenAI API key
AZURE_API_BASE= # Your Azure OpenAI API base URL
AZURE_API_VERSION= # Your Azure OpenAI API version
AZURE_DEPLOYMENTS_MAP= # Your Azure OpenAI deployments map—a JSON object mapping model names to deployment names (only needed if deployment names are different from model names)

# DeepSeek
DEEPSEEK_API_KEY= # Your DeepSeek API key

# Perplexity
PERPLEXITY_API_KEY= # Your Perplexity API key

# Amazon Bedrock
PLANDEX_AWS_PROFILE= # Name of AWS profile in ~/.aws/credentials to use for AWS Bedrock. If not set, the credentials file won't be used.
AWS_ACCESS_KEY_ID= # Your AWS access key ID
AWS_SECRET_ACCESS_KEY= # Your AWS secret access key
AWS_REGION= # Your AWS region
AWS_SESSION_TOKEN= # Your AWS session token
AWS_INFERENCE_PROFILE_ARN= # Your AWS inference profile ARN
```

### Upgrades

```bash
PLANDEX_SKIP_UPGRADE= # Set this to '1' to skip the auto-upgrade check when running the CLI.
```

### Development

Check out the [Development Guide](./development.md) for more details.

```bash
PLANDEX_OUT_DIR=/usr/local/bin # Where the development binary should be output when using dev.sh
PLANDEX_DEV_CLI_OUT_DIR=/usr/local/bin # Where the development binary should be output when using dev.sh
PLANDEX_DEV_CLI_NAME=plandex-dev # The name of the development binary when using dev.sh
PLANDEX_DEV_CLI_ALIAS=pdxd # The alias for the development binary when using dev.sh
GOPATH= # This should be already set to your Go folder if you've installed Golang.
```

## Server

Check out the [Self-Hosting Guide](./hosting/self-hosting/local-mode-quickstart.md) for more details.

### General

```bash
GOENV=development # Whether to run in development or production mode. Must be 'development' or 'production'
PLANDEX_BASE_DIR= # The base directory to read and write files. Defaults to '$HOME/plandex-server' in development mode, '/plandex-server' in production.
API_HOST= # The host the API server listens on. Defaults to 'http://localhost:$PORT'. In production mode, should be a host like 'https://api.your-domain.ai'.
PORT=8099 # The port the server listens on. Defaults to 8099.
DATABASE_URL= # The URL of the PostgreSQL database. Defaults to 'postgres://plandex:plandex@plandex-postgres:5432/plandex?sslmode=disable' in development mode
LOCAL_MODE= # Whether to run in local mode
OLLAMA_BASE_URL= # The base URL of the Ollama server—only need when the server is running in a Docker container and needs to access Ollama models running outside of the container
```

### docker-compose

For self-hosting with docker-compose, default values for all necessary environment variables are set in the `app/docker-compose.yml` file. This file is designed to be used with [local mode](./hosting/self-hosting/local-mode-quickstart.md), but you can adapt it to your needs.

### Other methods

If you're *not* using docker-compose, you'll need a `DATABASE_URL` environment variable that points to a PostgreSQL database. For example, if you're running PostgreSQL locally, you might set it to something like this:

```bash
DATABASE_URL=postgres://plandex:<password>@<host>:<port>/plandex?sslmode=disable
```

If you're running in production mode, you'll also need to set `API_HOST` to the host the API server is running on.

```bash
API_HOST= https://api.your-domain.ai # The host of the API server in production mode. Defaults to 'http://localhost:$PORT' in development mode.
```


### SMTP

If you're running in production mode (with `GOENV=production`, typically on a remote server), you'll need SMTP credentials:

```bash
SMTP_HOST= # Your SMTP host.
SMTP_PORT= # Set this to 1025 e.g. if you are using mailhog.
SMTP_USER= # SMTP username.
SMTP_PASSWORD= # SMTP password.
```


================================================
FILE: docs/docs/hosting/_category_.json
================================================
{
  "label": "Hosting",
  "position": 7,
  "collapsible": true,
  "collapsed": false
}

================================================
FILE: docs/docs/hosting/cloud.md
================================================
---
sidebar_position: 1
sidebar_label: Cloud
---

# Plandex Cloud

## Overview

:::info
Plandex Cloud is winding down as of 10/3/2025 and is no longer accepting new users. <a href="https://plandex.ai/blog/winding-down">Learn more.</a>
:::

Plandex Cloud is the easiest and most reliable way to use Plandex. You'll be prompted to start a trial when you launch the [REPL](../repl.md) with `plandex` or create your first plan with `plandex new`.

## Billing Modes

Plandex Cloud has two billing modes:

### Integrated Models

- Use Plandex credits to pay for AI models.
- No separate accounts or API keys are required.
- Credits are deducted at the model's price from the provider plus a small markup to cover credit card processing costs.
- Start with a $10 trial (includes $10 in credits).
- After the trial, you can upgrade to a paid plan for $45 per month—includes $20 in credits every month that never expire.

[Get started with Integrated Models Mode.](https://app.plandex.ai/start?modelsMode=integrated)

### BYO API Key

- Use your own model provider accounts and API keys.
- Start with a free trial up to 10 plans and 20 model responses per plan.
- After the trial, you can upgrade to a paid plan for $30 per month.

[Get started with BYO API Key Mode.](https://app.plandex.ai/start?modelsMode=byo)

## Billing Settings

Run `plandex billing` in the terminal to bring up the billing settings page in your default browser, or go to [your Billing Settings page](https://app.plandex.ai/settings/billing) (sign in if necessary).

Here you can switch billing modes, view your current plan, manage your billing details, pause or cancel your subscription and more.

### Integrated Models Mode

If you're using **Integrated Models Mode**, you can use the billing settings page to view your credits balance, purchase credits, and configure auto-recharge settings to automatically add credits to your account when your balance gets too low. You can also set a monthly budget and an email notification threshold.

### `usage` command

You can see your current balance and a report on recent usage with `plandex usage` (`\usage` in the REPL):

```bash
plandex usage
```

You can see a log of individual transactions that includes every model call with `plandex usage --log`:

```bash
plandex usage --log
```

In the Plandex REPL, `usage` defaults to showing usage for the current REPL session. Otherwise, it defaults to showing usage for the day so far.

You can use the `--today` flag to show usage for the day so far. You can use the `--month` flag to show usage for the current billing month. You can use the `--plan` flag to show usage for the current plan.

```bash
plandex usage --today # show usage for the day so far
plandex usage --month # show usage for the current billing month
plandex usage --plan # show usage for the current plan
```

You can use the `--debits` flag to show only debits in the log. You can use the `--purchases` flag to show only purchases in the log.

```bash
plandex usage --log --debits --month # show only debits for the current billing month
plandex usage --log --purchases --today # show only purchases for the day so far
```

## Privacy / Data Retention

Data you send to Plandex Cloud is retained in order to debug and improve Plandex. In the future, this data may also be used to train and fine-tune models to improve performance and reduce costs.

That said, if you delete your Plandex Cloud account, all associated data will be removed within 14 days (this delay allows for debugging and backups).

Data sent to Plandex Cloud may be shared with the following third parties:

- [OpenAI](https://openai.com) for OpenAI models when using Integrated Models Mode.
- [OpenRouter.ai](https://openrouter.ai/) for Anthropic, Google, and other non-OpenAI models when using Integrated Models Mode.
- [Google Vertex AI](https://cloud.google.com/vertex-ai) for Google and Anthropic models when using Integrated Models Mode.
- [AWS](https://aws.amazon.com/) for hosting and database services. Data is encrypted in transit and at rest.
- Your name and email is shared with [Loops](https://loops.so/), an email marketing service, in order to send you updates on Plandex. You can opt out of these emails at any time with one click.
- Your name and email are shared with our payment processor [Stripe](https://stripe.com/) if you subscribe to a paid plan or purchase the $10 trial.
- Basic usage data is sent to [Google Analytics](https://analytics.google.com/) to help track usage and make improvements.
- [Relace](https://relace.ai/) for an instant apply AI model that speeds up and reduces the cost of file edits. Used as a fallback if Plandex is unable to apply edits deterministically. Inputs are the original file and the edit snippet from a Plandex response.
- [Rollbar](https://rollbar.com/) for error tracking and alerting. It's unlikely that any user data would be shared with Rollbar. If it was, it would be minimal and incidental to error reporting.

Apart from the above list, no other data will be shared with any other third party. The list will be updated if any new third party services are introduced.

Data sent to a model provider like OpenAI or OpenRouter.ai is subject to the model provider's privacy and data retention policies.

See our full [Privacy Policy](https://plandex.ai/privacy) for more details.


================================================
FILE: docs/docs/hosting/self-hosting/_category_.json
================================================
{
  "label": "Self-Hosting",
  "position": 1,
  "collapsible": true,
  "collapsed": false
}

================================================
FILE: docs/docs/hosting/self-hosting/advanced-self-hosting.md
================================================
---
sidebar_position: 2
sidebar_label: Advanced Self-Hosting
---

# Advanced Self-Hosting

The easiest way to self-host Plandex is to use the [Local Mode Quickstart](./local-mode-quickstart.md). But if you need to run Plandex on a remote server with multiple users or orgs, or you want to run it without docker/docker-compose, keep reading below.

## Requirements

The Plandex server requires a PostgreSQL database (ideally v14), a persistent file system, and git.

Due to a dependency on tree-sitter, gcc, g++, and make are also required to build the server.

## Development vs. Production

The Plandex server can be run in development or production mode. The main differences are how authentication pins and emails are handled, and the default path for the persistent file system.

Development mode is designed for local usage with a single user. Email isn't enabled and verification pins are skipped. In development mode, the default base directory is `$HOME/plandex-server`.

Production mode is designed for multiple users or organizations. Email is enabled and SMTP environment variables are required. Authentication pins are sent via email. In production mode, the default base directory is `/plandex-server`.

Development or production mode is set with the `GOENV` environment variable. It should be set to either `development` or `production`.

In both development and production mode, the server runs on port 8099 by default. This can be changed with the `PORT` environment variable.

## PostgreSQL Database

If you aren't using docker-compose to start the server and run the database, you'll need a PostgreSQL database. You can run the following SQL to create a user and database, replacing `user` and `password` with your own values:

```sql
CREATE USER 'user' WITH PASSWORD 'password';
CREATE DATABASE 'plandex' OWNER 'user';
GRANT ALL PRIVILEGES ON DATABASE 'plandex' TO 'user';
```

### Environment Variables

Set `GOENV` to either `development` or `production` as described above in the [Development vs. Production](#development-vs-production) section:

```bash
export GOENV=development
```

or
  
```bash
export GOENV=production
```

You'll also need a `DATABASE_URL`:

```bash
export DATABASE_URL=postgres://user:password@host:5432/plandex # replace with your own database URL
```

In production mode, you'll also need to connect to SMTP to send emails. Set the following environment variables:

```bash
export SMTP_HOST=smtp.example.com
export SMTP_PORT=587
export SMTP_USER=user
export SMTP_PASSWORD=password
export SMTP_FROM=user@example.com # optional, if not set then SMTP_USER is used
```

In either development or production mode, the base directory for the persistent file system can optionally be overridden with the `PLANDEX_BASE_DIR` environment variable:

```bash
export PLANDEX_BASE_DIR=~/some-dir/plandex-server
```

When running the Plandex CLI, to connect to a server running in production mode, set the API_HOST environment variable to the host the server is running on:

```bash
export API_HOST=api.your-domain.ai
```

### Using Docker Build

The server can be run from a Dockerfile at `app/Dockerfile.server`:

```bash
git clone https://github.com/plandex-ai/plandex.git
VERSION=$(cat app/server/version.txt) # or use the version you want
git checkout server/v$VERSION
cd plandex/app
mkdir ~/plandex-server # or another directory where you want to store files
docker build -t plandex-server -f Dockerfile.server .
docker run -p 8099:8099 \
  -v ~/plandex-server:/plandex-server \
  -e DATABASE_URL \
  -e GOENV \
  -e API_HOST \
  -e SMTP_HOST \ 
  -e SMTP_PORT \
  -e SMTP_USER \
  -e SMTP_PASSWORD \
  plandex-server
```

The API_HOST and SMTP environment variables above are only required if you're running in [production mode](#development-vs-production).

### DockerHub Server Images

Apart from building manually with the Dockerfile, server images are also built and pushed to [DockerHub](https://hub.docker.com/r/plandexai/plandex-server/tags) automatically when a new version of the server is released.

You can pull the latest server image with:

```bash
docker pull plandexai/plandex-server:latest
```

### Run From Source

You can also run the server from source:

```bash
git clone https://github.com/plandex-ai/plandex.git
cd plandex/
VERSION=$(cat app/server/version.txt) # or use the version you want
git checkout server/v$VERSION
cd app/server
export GOENV=development # or production
export DATABASE_URL=postgres://user:password@host:5432/plandex # replace with your own database URL
export PLANDEX_BASE_DIR=~/plandex-server # or another directory where you want to store files
go run main.go
```

## Health Check

You can check if the server is running by sending a GET request to `/health`. If all is well, it will return a 200 status code.

## Create a New Account

Once the server is running and you've [installed the Plandex CLI](../../install.md) on your local development machine, you can create a new account by running `plandex sign-in`: 

```bash
plandex sign-in # follow the prompts to create a new account on your self-hosted server
```

## Note On Local CLI Files

If you use the Plandex CLI and then for some reason you reset the database or use a new one, you'll need to remove the local files that the CLI creates in directories where you used Plandex in order to start fresh. Otherwise, the CLI will attempt to authenticate with an account that doesn't exist in the new database and you'll get errors.

To resolve this, remove the following in any directory you used the CLI in:

- `.plandex-dev` directory if you ran the CLI with `PLANDEX_ENV=development`
- `.plandex` directory otherwise

Then run `plandex sign-in` again to create a new account.

If you're still having trouble with accounts, you can also remove the following from your $HOME directory to fully reset them:

- `.plandex-home-dev` directory if you ran the CLI with `PLANDEX_ENV=development`
- `.plandex-home` directory otherwise

================================================
FILE: docs/docs/hosting/self-hosting/local-mode-quickstart.md
================================================
---
sidebar_position: 1
sidebar_label: Local Mode Quickstart
---

# Self-Hosting

Plandex is open source and uses a client-server architecture. The server can be self-hosted. You can either run it locally or on a cloud server that you control. To run it on a cloud server, go to  [Advanced Self-Hosting](advanced-self-hosting.md) section. To run it locally, keep reading below.

## Local Mode Quickstart

The quickstart requires git, docker, and docker-compose. It's designed for local use with a single user.

1. Run the server in local mode: 

```bash
git clone https://github.com/plandex-ai/plandex.git
cd plandex/app
./start_local.sh
```

2. In a new terminal session, install the Plandex CLI if you haven't already:

```bash
curl -sL https://plandex.ai/install.sh | bash
```

3. Run:

```bash
plandex sign-in
```

4. When prompted 'Use Plandex Cloud or another host?', select 'Local mode host'. Confirm the default host, which is `http://localhost:8099`.

5. Decide on the model provider(s) you want to use. The quickest option is to use OpenRouter.ai, but you can also use [many other providers](https://docs.plandex.ai/models/model-providers).

If you're using OpenRouter.ai, first [sign up here.](https://openrouter.ai/signup) Then [generate an API key here.](https://openrouter.ai/keys) Set the `OPENROUTER_API_KEY` environment variable:

```bash
export OPENROUTER_API_KEY=...
```

6. In a project directory, start the Plandex REPL:

```bash
plandex
```

You're ready to start building!

## Upgrade

To upgrade after a new release, just use `ctrl-c` to stop the server, then run the script again:

```bash
./start_local.sh
```

The script will pull the latest image before the server starts.




================================================
FILE: docs/docs/install.md
================================================
---
sidebar_position: 1
sidebar_label: Install
---

# Install Plandex

## Quick Install

```bash
curl -sL https://plandex.ai/install.sh | bash
```

## Manual install

Grab the appropriate binary for your platform from the latest [release](https://github.com/plandex-ai/plandex/releases) and put it somewhere in your `PATH`.

## Build from source

```bash
git clone https://github.com/plandex-ai/plandex.git
cd plandex/app/cli
go build -ldflags "-X plandex/version.Version=$(cat version.txt)"
mv plandex /usr/local/bin # adapt as needed for your system
```

## Windows

Windows is supported via [WSL](https://learn.microsoft.com/en-us/windows/wsl/about).

Plandex only works correctly in the WSL shell. It doesn't work in the Windows CMD prompt or PowerShell.

================================================
FILE: docs/docs/models/_category_.json
================================================
{
  "label": "Models",
  "position": 6,
  "collapsible": true,
  "collapsed": false
}

================================================
FILE: docs/docs/models/built-in/_category_.json
================================================
{
  "label": "Built-In",
  "position": 9,
  "collapsible": true,
  "collapsed": false
}

================================================
FILE: docs/docs/models/built-in/built-in-models.md
================================================
---
sidebar_position: 1
sidebar_label: Models
---

# Built-In Models

Plandex includes a curated selection of built-in models.

## OpenAI

### `openai/o3-high`

- OpenAI o3 (high reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/o3-medium`

- OpenAI o3 (medium reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/o3-low`

- OpenAI o3 (low reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/o4-mini-high`

- OpenAI o4-mini (high reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 40k
- Effective Input: 160k
- Features: JSON output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/o4-mini-medium`

- OpenAI o4-mini (medium reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 30k
- Effective Input: 170k
- Features: JSON output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/o4-mini-low`

- OpenAI o4-mini (low reasoning)
- Max Tokens: 200k
- Max Output: 100k
- Reserved Output: 20k
- Effective Input: 180k
- Features: JSON output, no system prompt, fixed parameters, reasoning effort
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/gpt-4.1`

- OpenAI GPT-4.1
- Max Tokens: 1,047,576
- Max Output: 32,768
- Reserved Output: 32,768
- Effective Input: 1,014,808
- Features: JSON output, full compatibility
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/gpt-4.1-mini`

- OpenAI GPT-4.1 Mini
- Max Tokens: 1,047,576
- Max Output: 32,768
- Reserved Output: 32,768
- Effective Input: 1,014,808
- Features: JSON output, full compatibility
- Providers: OpenAI, Azure OpenAI, OpenRouter

### `openai/gpt-4.1-nano`

- OpenAI GPT-4.1 Nano
- Max Tokens: 1,047,576
- Max Output: 32,768
- Reserved Output: 32,768
- Effective Input: 1,014,808
- Features: JSON output, full compatibility
- Providers: OpenAI, Azure OpenAI, OpenRouter

## Anthropic

### `anthropic/claude-opus-4`

- Anthropic Claude Opus 4
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 20k
- Effective Input: 180k
- Features: XML output, cache control, single message mode
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-sonnet-4`

- Anthropic Claude Sonnet 4
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, cache control, single message mode
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-sonnet-4-thinking`

- Claude Sonnet 4 (visible reasoning)
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, cache control, single message mode, reasoning budget 32k
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-sonnet-4-thinking-hidden`

- Claude Sonnet 4 (hidden reasoning)
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 40k
- Effective Input: 160k
- Features: XML output, cache control, single message mode, reasoning budget 32k
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-3.7-sonnet`

- Anthropic Claude 3.7 Sonnet
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 20k
- Effective Input: 180k
- Features: XML output, cache control, single message mode
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-3.7-sonnet-thinking`

- Claude 3.7 Sonnet (visible reasoning)
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 20k
- Effective Input: 180k
- Features: XML output, cache control, single message mode, reasoning budget 32k
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-3.7-sonnet-thinking-hidden`

- Claude 3.7 Sonnet (hidden reasoning)
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 20k
- Effective Input: 180k
- Features: XML output, cache control, single message mode, reasoning budget 32k
- Providers: Anthropic, AWS Bedrock, Google Vertex, OpenRouter

### `anthropic/claude-3.5-sonnet`

- Anthropic Claude 3.5 Sonnet
- Max Tokens: 200k
- Max Output: 128k
- Reserved Output: 20k
- Effective Input: 180k
- Features: XML output, cache control, single message mode
- Providers: Anthropic, Google Vertex, AWS Bedrock, OpenRouter

### `anthropic/claude-3.5-haiku`

- Anthropic Claude 3.5 Haiku
- Max Tokens: 200k
- Max Output: 8,192
- Reserved Output: 8,192
- Effective Input: 191,808
- Features: XML output, cache control, single message mode
- Providers: Anthropic, Google Vertex, AWS Bedrock, OpenRouter

## Google

### `google/gemini-2.5-pro`

- Google Gemini 2.5 Pro
- Max Tokens: 1,048,576
- Max Output: 65,535
- Reserved Output: 65,535
- Effective Input: 983,041
- Features: XML output
- Providers: Google AI Studio, Google Vertex, OpenRouter

### `google/gemini-2.5-flash`

- Google Gemini 2.5 Flash
- Max Tokens: 1,048,576
- Max Output: 65,535
- Reserved Output: 65,535
- Effective Input: 983,041
- Features: XML output
- Providers: Google AI Studio, Google Vertex, OpenRouter

### `google/gemini-2.5-flash-thinking`

- Gemini 2.5 Flash (visible reasoning)
- Max Tokens: 1,048,576
- Max Output: 65,535
- Reserved Output: 65,535
- Effective Input: 983,041
- Features: XML output, visible reasoning
- Providers: Google AI Studio, Google Vertex, OpenRouter

### `google/gemini-2.5-flash-thinking-hidden`

- Gemini 2.5 Flash (hidden reasoning)
- Max Tokens: 1,048,576
- Max Output: 65,535
- Reserved Output: 65,535
- Effective Input: 983,041
- Features: XML output, hidden reasoning
- Providers: Google AI Studio, Google Vertex, OpenRouter

### `google/gemini-pro-1.5`

- Google Gemini 1.5 Pro
- Max Tokens: 2M
- Max Output: 8,192
- Reserved Output: 8,192
- Effective Input: 1,991,808
- Features: XML output
- Providers: Google AI Studio, Google Vertex, OpenRouter

## DeepSeek

### `deepseek/v3`

- DeepSeek V3
- Max Tokens: 64k
- Max Output: 8,192
- Reserved Output: 8,192
- Effective Input: 55,808
- Features: XML output
- Providers: DeepSeek, OpenRouter

### `deepseek/r1`

- DeepSeek R1 (visible reasoning)
- Max Tokens: 164k
- Max Output: 33k
- Reserved Output: 20k
- Effective Input: 144k
- Features: XML output, visible reasoning
- Providers: DeepSeek, OpenRouter

### `deepseek/r1-hidden`

- DeepSeek R1 (hidden reasoning)
- Max Tokens: 164k
- Max Output: 33k
- Reserved Output: 20k
- Effective Input: 144k
- Features: XML output, hidden reasoning
- Providers: DeepSeek, OpenRouter

### `deepseek/r1-70b`

- DeepSeek R1 70B (Ollama only)
- Max Tokens: 131,072
- Max Output: 131,072
- Reserved Output: 20k
- Effective Input: 111,072
- Features: XML output
- Providers: Ollama

### `deepseek/r1-32b`

- DeepSeek R1 32B (Ollama only)
- Max Tokens: 131,072
- Max Output: 131,072
- Reserved Output: 20k
- Effective Input: 111,072
- Features: XML output
- Providers: Ollama

### `deepseek/r1-14b`

- DeepSeek R1 14B (Ollama only)
- Max Tokens: 131,072
- Max Output: 131,072
- Reserved Output: 20k
- Effective Input: 111,072
- Features: XML output
- Providers: Ollama

### `deepseek/r1-8b`

- DeepSeek R1 8B (Ollama only)
- Max Tokens: 131,072
- Max Output: 131,072
- Reserved Output: 20k
- Effective Input: 111,072
- Features: XML output
- Providers: Ollama

## Perplexity

### `perplexity/r1-1776`

- Perplexity R1-1776 (visible reasoning)
- Max Tokens: 128k
- Max Output: 128k
- Reserved Output: 30k
- Effective Input: 98k
- Features: XML output, visible reasoning
- Providers: Perplexity, OpenRouter

### `perplexity/r1-1776-hidden`

- Perplexity R1-1776 (hidden reasoning)
- Max Tokens: 128k
- Max Output: 128k
- Reserved Output: 30k
- Effective Input: 98k
- Features: XML output, hidden reasoning
- Providers: Perplexity, OpenRouter

### `perplexity/r1-1776-70b`

- Perplexity R1-1776 70B (Ollama only)
- Max Tokens: 131,072
- Max Output: 131,072
- Reserved Output: 20k
- Effective Input: 111,072
- Features: XML output
- Providers: Ollama

### `perplexity/sonar-reasoning`

- Perplexity Sonar Reasoning (visible reasoning)
- Max Tokens: 127k
- Max Output: 127k
- Reserved Output: 30k
- Effective Input: 97k
- Features: XML output, visible reasoning
- Providers: Perplexity, OpenRouter

### `perplexity/sonar-reasoning-hidden`

- Perplexity Sonar Reasoning (hidden reasoning)
- Max Tokens: 127k
- Max Output: 127k
- Reserved Output: 30k
- Effective Input: 97k
- Features: XML output, hidden reasoning
- Providers: Perplexity, OpenRouter

## Qwen

### `qwen/qwen-2.5-coder-32b-instruct`

- Qwen 2.5 Coder 32B
- Max Tokens: 128k
- Max Output: 8,192
- Reserved Output: 8,192
- Effective Input: 119,808
- Features: XML output
- Providers: OpenRouter

### `qwen/qwen3-235b-local`

- Qwen 3-235B (Ollama only)
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: Ollama

### `qwen/qwen3-235b-a22b-cloud`

- Qwen 3-235B A22B
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: OpenRouter

### `qwen/qwen3-32b-local`

- Qwen 3-32B (Ollama only)
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: Ollama

### `qwen/qwen3-32b-cloud`

- Qwen 3-32B
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: OpenRouter

### `qwen/qwen3-14b-local`

- Qwen 3-14B (Ollama only)
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: Ollama

### `qwen/qwen3-14b-cloud`

- Qwen 3-14B
- Max Tokens: 40,960
- Max Output: 40,960
- Reserved Output: 8,192
- Effective Input: 32,768
- Features: XML output
- Providers: OpenRouter

### `qwen/qwen3-8b-local`

- Qwen 3-8B (Ollama only)
- Max Tokens: 32,768
- Max Output: 32,768
- Reserved Output: 8,192
- Effective Input: 24,576
- Features: XML output
- Providers: Ollama

### `qwen/qwen3-8b-cloud`

- Qwen 3-8B
- Max Tokens: 128k
- Max Output: 20k
- Reserved Output: 20k
- Effective Input: 108k
- Features: XML output
- Providers: OpenRouter

## Mistral

### `mistral/devstral-small`

- Mistral Devstral Small
- Max Tokens: 128k
- Max Output: 128k
- Reserved Output: 16,384
- Effective Input: 111,616
- Features: XML output
- Providers: Ollama, OpenRouter

================================================
FILE: docs/docs/models/built-in/built-in-packs.md
================================================
---
sidebar_position: 2
sidebar_label: Model Packs
---

# Built-In Model Packs

Plandex includes a curated selection of built-in model packs that have been tested and optimized for different use cases.

*A model pack is a mapping of [model roles](../roles.md) to [models](./built-in-models.md).*

*They can also define fallback models for large context, large output, error handling, as well as a strong variant for the `builder` role.*

## Core Packs

### `daily-driver`
*A mix of models from Anthropic, OpenAI, and Google that balances speed, quality, and cost. Supports up to 2M context.*

- **planner** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `google/gemini-2.5-pro`
    - largeContextFallback → `google/gemini-pro-1.5`
- **architect** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `google/gemini-2.5-pro`
    - largeContextFallback → `google/gemini-pro-1.5`
- **coder** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `openai/gpt-4.1`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `reasoning`
*Like the daily driver, but uses sonnet-4-thinking with reasoning enabled for planning and coding. Supports up to 160k input context.*

- **planner** → `anthropic/claude-sonnet-4-thinking-hidden`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4-thinking-hidden`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `strong`
*For difficult tasks where slower responses and builds are ok. Uses o3-high for architecture and planning, claude-sonnet-4 thinking for implementation. Supports up to 160k input context.*

- **planner** → `openai/o3-high`
- **architect** → `openai/o3-high`
- **coder** → `anthropic/claude-sonnet-4-thinking-hidden`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-high`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-medium`

### `cheap`
*Cost-effective models that can still get the job done for easier tasks. Supports up to 160k context. Uses OpenAI's o4-mini model for planning, GPT-4.1 for coding, and GPT-4.1 Mini for lighter tasks.*

- **planner** → `openai/o4-mini-medium`
- **architect** → Uses planner model
- **coder** → `openai/gpt-4.1`
- **summarizer** → `openai/gpt-4.1-mini`
- **builder** → `openai/o4-mini-low`
- **wholeFileBuilder** → `openai/o4-mini-low`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `oss`
*An experimental mix of the best open source models for coding. Supports up to 144k context, 33k per file.*

- **planner** → `deepseek/r1`
- **architect** → Uses planner model
- **coder** → `deepseek/v3`
- **summarizer** → `deepseek/r1-hidden`
- **builder** → `deepseek/r1-hidden`
- **wholeFileBuilder** → `deepseek/r1-hidden`
- **names** → `qwen/qwen3-8b-cloud`
- **commitMessages** → `qwen/qwen3-8b-cloud`
- **autoContinue** → `deepseek/r1-hidden`

## Provider Packs


### `openai`
*OpenAI blend. Supports up to 1M context. Uses OpenAI's GPT-4.1 model for heavy lifting, GPT-4.1 Mini for lighter tasks.*

- **planner** → `openai/gpt-4.1`
- **architect** → Uses planner model
- **coder** → Uses planner model
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `anthropic`
*Anthropic blend. Supports up to 180k context. Uses Claude Sonnet 4 for heavy lifting, Claude 3 Haiku for lighter tasks.*

- **planner** → `anthropic/claude-sonnet-4`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
- **summarizer** → `anthropic/claude-3.5-haiku`
- **builder** → `anthropic/claude-sonnet-4`
- **wholeFileBuilder** → `anthropic/claude-sonnet-4`
- **names** → `anthropic/claude-3.5-haiku`
- **commitMessages** → `anthropic/claude-3.5-haiku`
- **autoContinue** → `anthropic/claude-sonnet-4`

### `gemini-planner`
*Uses Gemini 2.5 Pro for planning, default models for other roles. Supports up to 1M input context.*

- **planner** → `google/gemini-2.5-pro`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `openai/gpt-4.1`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `opus-planner`
*Uses Claude Opus 4 for planning, default models for other roles. Supports up to 180k input context.*

- **planner** → `anthropic/opus-4`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `openai/gpt-4.1`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `o3-planner`
*Uses OpenAI o3-medium for planning, default models for other roles. Supports up to 160k input context.*

- **planner** → `openai/o3-medium`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `openai/gpt-4.1`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-low`

### `r1-planner`
*Uses DeepSeek R1 for planning, Qwen for light tasks, and default models for implementation. Supports up to 56k input context.*

- **planner** → `deepseek/r1`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
- **wholeFileBuilder** → `openai/o4-mini-low`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-medium`

### `perplexity-planner`
*Uses Perplexity Sonar for planning, Qwen for light tasks, and default models for implementation. Supports up to 97k input context.*

- **planner** → `perplexity/sonar-reasoning`
- **architect** → Uses planner model
- **coder** → `anthropic/claude-sonnet-4`
- **summarizer** → `openai/o4-mini-low`
- **builder** → `openai/o4-mini-medium`
- **wholeFileBuilder** → `openai/o4-mini-low`
- **names** → `openai/gpt-4.1-mini`
- **commitMessages** → `openai/gpt-4.1-mini`
- **autoContinue** → `openai/o4-mini-medium`

## Local Packs

### `ollama`
*Ollama experimental local blend. Supports up to 110k context. For now, more for experimentation and benchmarking than getting work done.*

- **localProvider** → `ollama`
- **planner** → `qwen/qwen3-32b-local`
- **architect** → Uses planner model
- **coder** → Uses planner model
- **summarizer** → `mistral/devstral-small`
- **builder** → `mistral/devstral-small`
- **wholeFileBuilder** → `mistral/devstral-small`
- **names** → `qwen/qwen3-8b-local`
- **commitMessages** → `qwen/qwen3-8b-local`
- **autoContinue** → `mistral/devstral-small`

### `ollama-daily`
*Ollama adaptive/daily-driver blend. Uses 'daily-driver' for heavy lifting, local models for lighter tasks.*

- **localProvider** → `ollama`
- **planner** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `google/gemini-2.5-pro`
    - largeContextFallback → `google/gemini-pro-1.5`
- **architect** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `google/gemini-2.5-pro`
    - largeContextFallback → `google/gemini-pro-1.5`
- **coder** → `anthropic/claude-sonnet-4`
  - largeContextFallback → `openai/gpt-4.1`
- **summarizer** → `mistral/devstral-small`
- **builder** → `openai/o4-mini-medium`
  - strongModel → `openai/o4-mini-high`
- **wholeFileBuilder** → `openai/o4-mini-medium`
- **names** → `qwen/qwen3-8b-local`
- **commitMessages** → `qwen/qwen3-8b-local`
- **autoContinue** → `openai/o4-mini-low`

### `ollama-oss`
*Ollama adaptive/oss blend. Uses local models for planning and context selection, open source cloud models for implementation and file edits. Supports up to 110k context.*

- **localProvider** → `ollama`
- **planner** → `deepseek/r1`
- **architect** → Uses planner model
- **coder** → `deepseek/v3`
- **summarizer** → `mistral/devstral-small`
- **builder** → `deepseek/r1-hidden`
- **wholeFileBuilder** → `deepseek/r1-hidden`
- **names** → `qwen/qwen3-8b-local`
- **commitMessages** → `qwen/qwen3-8b-local`
- **autoContinue** → `deepseek/r1-hidden`


================================================
FILE: docs/docs/models/claude-subscription.md
================================================
---
sidebar_position: 3
sidebar_label: Claude Pro/Max
---

# Claude Pro/Max Subscription

If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. You can use it in either Integrated Models Mode on Plandex Cloud, or in BYO Key Mode (whether on Cloud or self-hosting).

## Startup Prompt

Assuming you're using Anthropic models (which the default model pack does), you'll be asked if you want to connect your Claude subscription the first time you run Plandex. Follow the instructions to connect.

## CLI Commands

### `connect-claude`

You can connect your subscription with the `connect-claude` command.

```bash
plandex connect-claude # CLI
\connect-claude  # REPL
```

### `disconnect-claude`

You can disconnect your subscription and clear credentials from your device with the `disconnect-claude` command.

```bash
plandex disconnect-claude # CLI
\disconnect-claude  # REPL
```

### `claude-status`

You can check whether a subscription is connected with `claude-status`

```bash
plandex claude-status # CLI
\claude-status  # REPL
```

This command will also tell you if the subscription's quota has been exceeded and a backup provider is being used instead.

## Quota Exhaustion

If you're using Plandex Cloud with Integrated Models Mode, Anthropic model calls will use your Claude subscription until it runs out of quota, then switch to using Plandex credits until the quota resets.

If you're self-hosting or using Plandex Cloud in BYO API Key Mode, Anthropic model calls will use your Claude subscription until it runs out of quota, then:

- If you have an API key or credentials set for an [Anthropic provider](./model-providers.md) (like the Anthropic API, Google Vertex AI, AWS Bedrock, or OpenRouter), Plandex will switch to the backup provider until the quota resets.

- If you have no API key or credentials set for an Anthropic provider, you'll get a rate limit error until your quota resets.

================================================
FILE: docs/docs/models/custom-models.md
================================================
---
sidebar_position: 5
sidebar_label: Custom Models
---

# Custom Models, Providers, and Model Packs

You can extend Plandex with custom models, providers, and model packs using a JSON file.

```bash
plandex models custom # edit the custom models file
\models custom # REPL
```

The first time you run this command, a template file with examples will be created and opened in your preferred editor.

The template file uses a JSON schema, allowing most editors to provide autocomplete, validation, and inline documentation.

## Support Levels

The level of custom model support depends on how you use Plandex.

**Self-hosted**: Everything - custom models, providers, and model packs are fully supported.

**Cloud with BYO API Keys**: Custom models and model packs. Models can only use built-in providers.

**Cloud with Integrated Models**: Custom model packs. Model packs can only use built-in models.

## Basic Example

Here's a minimal example that adds a model from Together.ai:

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "providers": [
    {
      "name": "togetherai",
      "baseUrl": "https://api.together.xyz/v1",
      "apiKeyEnvVar": "TOGETHER_API_KEY"
    }
  ],
  "models": [
    {
      "modelId": "meta-llama/llama-4-maverick",
      "publisher": "meta-llama",
      "description": "Meta Llama 4 Maverick",
      "defaultMaxConvoTokens": 75000,
      "maxTokens": 1048576,
      "maxOutputTokens": 16000,
      "reservedOutputTokens": 16000,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "togetherai",
          "modelName": "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8"
        }
      ]
    }
  ]
}
```

## Custom Providers

Define providers that use OpenAI-compatible APIs:

```json
{
  "providers": [
    {
      "name": "local-llm",
      "baseUrl": "http://localhost:8080/v1",
      "skipAuth": true
    },
    {
      "name": "my-provider",
      "baseUrl": "https://api.myprovider.com/v1",
      "apiKeyEnvVar": "MY_PROVIDER_API_KEY"
    }
  ]
}
```

### Provider Settings

- `name` - Unique identifier for the provider
- `baseUrl` - API endpoint (must be OpenAI-compatible)
- `apiKeyEnvVar` - Environment variable containing the API key
- `skipAuth` - Set to `true` for local models that don't need authentication
- `extraAuthVars` - Additional authentication variables if needed

## Custom Models

Define models with their capabilities and provider mappings:

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "models": [
    {
      "modelId": "my-model",
      "publisher": "My Company",
      "description": "My Custom Model",
      "defaultMaxConvoTokens": 50000,
      "maxTokens": 128000,
      "maxOutputTokens": 8192,
      "reservedOutputTokens": 8192,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "my-provider",
          "modelName": "exact-model-name-on-provider"
        },
        {
          "provider": "openrouter",
          "modelName": "my-company/my-model"
        }
      ]
    }
  ]
}
```

### Model Settings

- `modelId` - Unique identifier used in model packs
- `maxTokens` - Total token limit (input + output)
- `maxOutputTokens` - Maximum output tokens the model can generate
- `reservedOutputTokens` - Tokens reserved for output (affects effective input limit)
- `preferredOutputFormat` - Either `"xml"` or `"tool-call-json"`
- `providers` - List of providers that can serve this model

## Custom Model Packs

Create your own combinations of models for different roles:

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "modelPacks": [
    {
      "name": "custom-pack",
      "description": "Custom model pack for my use case",
      "planner": "custom-model-publisher/model-name",
      "coder": "anthropic/claude-sonnet-4",
      "architect": "custom-model-publisher/model-name",
      "summarizer": "openai/gpt-4.1",
      "builder": {
        "modelId": "anthropic/claude-sonnet-4",
        "strongModel": "openai/o3-medium"
      },
      "wholeFileBuilder": {
        "modelId": "anthropic/claude-sonnet-4",
        "largeContextFallback": {
          "modelId": "google/gemini-2.5-pro",
          "largeOutputFallback": "openai/o4-mini-low"
        },
        "errorFallback": "openai/gpt-4.1"
      },
      "names": "openai/gpt-4.1-mini",
      "commitMessages": "openai/gpt-4.1-mini",
      "autoContinue": "openai/o4-mini-medium"
    }
  ]
}
```

### Model Pack Settings

- `name` - The name of the model pack
- `description` - A description of the model pack
- `localProvider` - The local provider to default to for the model pack. Currently only `ollama` is supported. This must be set for the model pack to use local models via ollama.

Custom model packs can be configured with the same [roles](./roles.md) as built-in model packs:

- `planner` (required)
- `architect` (optional, defaults to `planner`)
- `coder` (optional, defaults to `planner`)
- `summarizer` (required)
- `builder` (required)
- `wholeFileBuilder` (optional, defaults to `builder`)
- `names` (optional)
- `commitMessages` (optional)
- `autoContinue` (optional)

### Role Config

For each role set in the model pack, you can either use a simple string (the model ID) or a config object with these settings:

- `modelId` - The model to use (required when using object form)
- `temperature` - Controls randomness (0-2, role-specific defaults)
- `topP` - Alternative randomness control (0-1)
- `largeContextFallback` - Model to use when context is large
- `largeOutputFallback` - Model to use when output needs to be large
- `errorFallback` - Model to use if the primary model fails
- `strongModel` - Stronger model for complex tasks

When using a config object, all settings except `modelId` are optional.

## Complete Example

Here's a full example combining `providers`, `models`, and `modelPacks`:

```json
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "providers": [
    {
      "name": "replicate",
      "baseUrl": "https://api.replicate.com/v1",
      "apiKeyEnvVar": "REPLICATE_API_KEY"
    }
  ],
  "models": [
    {
      "modelId": "llama-4-maverick-70b",
      "publisher": "meta",
      "description": "Llama 4 Maverick 70B",
      "defaultMaxConvoTokens": 50000,
      "maxTokens": 128000,
      "maxOutputTokens": 8192,
      "reservedOutputTokens": 8192,
      "preferredOutputFormat": "xml",
      "providers": [
        {
          "provider": "custom",
          "customProvider": "replicate",
          "modelName": "meta/llama-4-maverick-70b"
        }
      ]
    }
  ],
  "modelPacks": [
    {
      "name": "hybrid-local-cloud",
      "description": "Local models for simple tasks, cloud for complex",
      "planner": "anthropic/claude-opus-4",
      "coder": "anthropic/claude-sonnet-4",
      "architect": "anthropic/claude-sonnet-4",
      "summarizer": "llama-4-maverick-70b",
      "builder": "anthropic/claude-sonnet-4",
      "names": "llama-4-maverick-70b",
      "commitMessages": "llama-4-maverick-70b",
      "autoContinue": "llama-4-maverick-70b"
    }
  ]
}
```

## Notes

- All custom providers must be OpenAI-compatible.
- Model IDs must be unique across built-in and custom models.
- Provider names must be unique across built-in and custom providers.

================================================
FILE: docs/docs/models/model-providers.md
================================================
---
sidebar_position: 2
sidebar_label: Providers
---

# Model Providers

If you use [Plandex Cloud](../hosting/cloud.md) in **Integrated Models Mode**, you can use Plandex credits to pay for AI models. No separate accounts or API keys are required in this case.

If you instead use **BYO API Key Mode** with Plandex Cloud, or if you self-host Plandex, you'll need to set API keys (or other credentials) for the providers you want to use.

To see available providers, run:

```bash
\providers # REPL
plandex providers # CLI
```

## API Keys / Environment Variables

API keys or credentials are set through **environment variables** when running the Plandex CLI. For example:

```bash
export OPENROUTER_API_KEY=...
export OPENAI_API_KEY=...
export ANTHROPIC_API_KEY=...

plandex # start the Plandex REPL
```

## Provider Selection

Many models can be served by multiple different providers. For example, OpenAI models are available via OpenAI, Microsoft Azure, and OpenRouter.

When multiple providers are available for a model, which provider is selected depends on the authentication environment variables that are set when running the CLI or REPL. If environment variables are set for multiple providers, the direct provider takes precedence. For example, if you set both `ANTHROPIC_API_KEY` (for the direct Anthropic API) and `OPENROUTER_API_KEY` (for OpenRouter), Plandex will use the direct Anthropic API for Anthropic models.

## Claude Pro/Max Subscription

If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. [Learn more.](./claude-subscription.md)

## Built-In Providers

### OpenRouter

Apart from Plandex Cloud's Integrated Models Mode, the quickest way to get started is to use [OpenRouter.ai](https://openrouter.ai/), which allows you to use a wide range of models—including all those Plandex uses by default—with a single account and API key.

To use OpenRouter, you'll need to create an account and generate an API key, then set the `OPENROUTER_API_KEY` environment variable.

```bash
export OPENROUTER_API_KEY=...

plandex # start the Plandex REPL
```

You can also use OpenRouter alongside other providers. For example, if you set both `OPENROUTER_API_KEY` and `OPENAI_API_KEY`, Plandex will use the OpenAI API directly for OpenAI models and OpenRouter for other models. Using direct providers offers slightly lower latency and costs about 5% less than OpenRouter.

If you set a `OPENROUTER_API_KEY` and are also using other providers, Plandex will also **fail over** to OpenRouter if another provider has an error. This offers a strong layer of redundancy since OpenRouter itself routes model calls across a number of different upstream providers.

### OpenAI

You can optionally set an `OPENAI_API_KEY` to use the OpenAI API directly with your own OpenAI account when calling OpenAI models.

```bash
export OPENAI_API_KEY=... # set your OpenAI API key for OpenAI models
export OPENAI_ORG_ID=... # optionally set your OpenAI OrgID if you have multiple orgs
```

### Anthropic

You can optionally set an `ANTHROPIC_API_KEY` to use the Anthropic API directly with your own Anthropic account when calling Anthropic models.

```bash
export ANTHROPIC_API_KEY=... # set your Anthropic API key for Anthropic models
```

### Google AI Studio

You can optionally set a `GEMINI_API_KEY` to use Google Gemini models with your own Google account via Google AI Studio.

```bash
export GEMINI_API_KEY=... # set your Google AI Studio API key for Google Gemini models
```

### Google Vertex AI

You can optionally use Google Vertex AI, which offers models from Gemini, Anthropic, and more. Vertex authentication requires a few environment variables to be set.

```bash
export GOOGLE_APPLICATION_CREDENTIALS=... # either a path to a JSON file, the JSON itself as a string, or the base64 encoded JSON
export VERTEXAI_PROJECT=... # your Vertex project ID
export VERTEXAI_LOCATION=... # your Vertex location (e.g. us-east5)
```

### Azure

You can optionally use Microsoft Azure for OpenAI models. Azure authentication requires both an API key and a base URL.

```bash
export AZURE_OPENAI_API_KEY=... # set your Azure OpenAI API key
export AZURE_API_BASE=... # set your Azure API base URL (required)
export AZURE_API_VERSION=... # optionally set your Azure API version - defaults to 2025-04-01-preview
export AZURE_DEPLOYMENTS_MAP='{"gpt-4.1": "gpt-4.1-deployment-name"}' # optionally set a map of model names to deployment names with a JSON object (only needed if deployment names are different from model names)
```

### AWS Bedrock

You can optionally use AWS Bedrock for Anthropic models.

If you have an AWS credentials file at `~/.aws/credentials`, you can use that to authenticate by setting the `PLANDEX_AWS_PROFILE` environment variable:

```bash
export PLANDEX_AWS_PROFILE=... # set the name of the profile in ~/.aws/credentials to use
```

Note that the credentials file will _only_ be read if `PLANDEX_AWS_PROFILE` is set.

You can also use environment variables for AWS authentication:

```bash
export AWS_ACCESS_KEY_ID=... # set your AWS access key ID
export AWS_SECRET_ACCESS_KEY=... # set your AWS secret access key
export AWS_REGION=... # set your AWS region (e.g. us-east-1)

export AWS_SESSION_TOKEN=... # optionally set your AWS session token
export AWS_INFERENCE_PROFILE_ARN=... # optionally set your AWS inference profile ARN
```

### DeepSeek

You can optionally use DeepSeek models with your own DeepSeek account.

```bash
export DEEPSEEK_API_KEY=... # set your DeepSeek API key for DeepSeek models
```

### Perplexity

You can optionally use Perplexity models with your own Perplexity account.

```bash
export PERPLEXITY_API_KEY=... # set your Perplexity API key for Perplexity models
```

## Custom Providers

If you're self-hosting Plandex, you can also use with models from any provider that provides an OpenAI-compatible API.

To configure custom providers, you can use a dev-friendly JSON config file:

```bash
\models custom # REPL
plandex models custom # CLI
```

[More details on custom providers](./custom-models.md)

## Local Models

Plandex supports local models via [Ollama](https://ollama.com/). It doesn't require any authentication or API keys.
 
For more details, see the [Ollama Quickstart](./ollama.md).

================================================
FILE: docs/docs/models/model-settings.md
================================================
---
sidebar_position: 4
sidebar_label: Settings
---

# Model Settings

Plandex gives you a number of ways to control the models used in your plans. Changes to models are [version controlled](../core-concepts/version-control.md) and can be [branched](../core-concepts/branches.md).

## `models` and `set-model`

You can see the current plan's models with the `models` command and change them with the `set-model` command.

```bash
plandex models # show the current models
plandex set-model # select a model pack or configure model settings in JSON
```

## Model Defaults 

`set-model` updates model settings for the current plan. If you want to change the default model settings for all new plans, use `set-model default`.

```bash
plandex models default # show the default models for new plans
plandex set-model default # select a default model pack for new plans or configure default model settings in JSON
```

## Model Settings JSON

If you select the 'edit JSON' option in either the `set-model` or `set-model default` commands, or you use the `--json` flag, you can edit the model settings in a JSON file in your preferred editor.

The models file lets you configure which model to use for each role, along with settings like temperature/top-p and fallback models. It uses a JSON schema, allowing most editors to provide autocomplete, validation, and inline documentation.

Model roles can either be a string (the model ID) or an object with model config.

### Basic Example

```json
{
  "$schema": "https://plandex.ai/schemas/model-pack-inline.schema.json",
  "planner": "anthropic/claude-opus-4",
  "coder": "anthropic/claude-sonnet-4",
  "architect": "anthropic/claude-sonnet-4",
  "summarizer": "anthropic/claude-3.5-haiku",
  "builder": "anthropic/claude-sonnet-4",
  "names": "anthropic/claude-3.5-haiku",
  "commitMessages": "anthropic/claude-3.5-haiku",
  "autoContinue": "anthropic/claude-3.5-haiku"
}
```

### Advanced Example

You can also configure individual role settings and fallbacks with an object:

```json
{
  "$schema": "https://plandex.ai/schemas/model-pack-inline.schema.json",
  "planner": {
    "modelId": "anthropic/claude-opus-4",
    "temperature": 0.7,
    "topP": 0.9,
    "largeContextFallback": "google/gemini-2.5-pro"
  },
  "coder": "anthropic/claude-sonnet-4",
  "architect": "anthropic/claude-sonnet-4",
  "summarizer": "anthropic/claude-3.5-haiku",
  "builder": {
    "modelId": "anthropic/claude-sonnet-4",
    "errorFallback": "openai/gpt-4.1"
  },
  "wholeFileBuilder": {
    "modelId": "anthropic/claude-sonnet-4",
    "largeContextFallback": {
      "modelId": "google/gemini-2.5-pro",
      "largeOutputFallback": "openai/o4-mini-low"
    }
  },
  "names": "anthropic/claude-3.5-haiku",
  "commitMessages": "anthropic/claude-3.5-haiku",
  "autoContinue": "anthropic/claude-3.5-haiku"
}
```

### Role Config

For each role, you can either use a simple string (the model ID) or a config object with these settings:

- `modelId` - The model to use (required when using object form)
- `temperature` - Controls randomness (0-2, role-specific defaults)
- `topP` - Alternative randomness control (0-1)
- `largeContextFallback` - Model to use when context is large
- `largeOutputFallback` - Model to use when output needs to be large
- `errorFallback` - Model to use if the primary model fails
- `strongModel` - Stronger model for complex tasks

When using a config object, all settings except `modelId` are optional.

## Local Provider

You can set the top-level `localProvider` key to `ollama` to use local models via [Ollama](https://ollama.com/):

```json
{
  "$schema": "https://plandex.ai/schemas/model-pack-inline.schema.json",
  "localProvider": "ollama",
  "planner": "ollama/deepseek-r1:14b",
  ...
}
```


================================================
FILE: docs/docs/models/models-overview.md
================================================
---
sidebar_position: 1
sidebar_label: Overview
---

# Models Overview

By default, Plandex uses a mix of Anthropic, OpenAI, and Google models. While this is a good starting point, and is the recommended way to use Plandex for most users, full customization of models and providers is also supported.

## Roles and Model Packs

Plandex has multiple [roles](./roles.md) which are responsible for different aspects of planning, coding, and applying changes. Each role can be assigned a different model. A **model pack** is a mapping of roles to specific models.

## Built-in Models and Model Packs

Plandex provides a curated set of built-in models and model packs.

You can see the list of available model packs with:

```bash
\model-packs # REPL
plandex model-packs # CLI
```

You can see the details of a specific model pack with:

```bash
\model-packs show model-pack-name # REPL
plandex model-packs show model-pack-name # CLI
```

You can see the list of available models with:

```bash
\models available # REPL
plandex models available # CLI
```

## Model Settings

You can see the model settings for the current plan with:

```bash
\models # REPL
plandex models # CLI
```

And you can see the default model settings for new plans with:

```bash
\models default # REPL
plandex models default # CLI
```

You can change the model settings for the current plan with:

```bash
\set-model # REPL
plandex set-model # CLI
```

And you can set the default model settings for new plans with:

```bash
\set-model default # REPL
plandex set-model default # CLI
```

[More details on model settings](./model-settings.md)

## Providers

Plandex offers flexibility on the providers you can use to serve models.

If you use [Plandex Cloud](../hosting/cloud.md) in **Integrated Models Mode**, you can use Plandex credits to pay for AI models. In that case, you won't need to worry about providers, provider accounts, or API keys.

If instead you use **BYO API Key Mode** with Plandex Cloud, or if you [self-host](../hosting/self-hosting/local-mode-quickstart.md) Plandex, you'll need to set API keys (or other credentials) for the providers you want to use. Multiple built-in providers are supported. 

If you're self-hosting, you can also configure custom providers—they just need to be OpenAI-compatible.

[More details on providers](./model-providers.md)

## Custom Models, Providers, and Model Packs

You can configure custom models, providers, and model packs with a dev-friendly JSON config file:

```bash
\models custom # REPL
plandex models custom # CLI
```

[More details on custom models, providers, and model packs](./custom-models.md)

## Model Performance

While you can use Plandex with many different providers and models as described above, Plandex's prompts have mainly been written and tested against the built-in models and model packs, so you should expect them to give the best results.

## Local Models

Plandex supports local models via [Ollama](https://ollama.com/). For more details, see the [Ollama Quickstart](./ollama.md).




================================================
FILE: docs/docs/models/ollama.md
================================================
---
sidebar_position: 8
sidebar_label: Ollama Quickstart
---

# Ollama Quickstart

Plandex works with [Ollama](https://ollama.com/) models. To use them, you need to [self-host Plandex.](../hosting/self-hosting/local-mode-quickstart.md)
**Ollama isn't supported with Plandex Cloud.**

## Disclaimer

While local models are supported via Ollama, small models that can be run locally often aren't strong enough to produce usable results for the [heavy-lifting roles](./roles.md) like `planner`, `architect`, `coder`, and `builder`. The prompts for these roles require strong instruction following that can be hard to achieve with small models.

The strongest open source models _are_ capable enough for decent results, but these models are quite large for running locally without a very powerful system. This isn't meant to discourage experimentation with local models, but to set expectations for what is achievable.

To help bridge the gap as local models continue to improve their capabilities, two 'adaptive' model packs are available: `ollama-oss` and `ollama-daily`. These model packs use local Ollama models for less demanding roles, plus larger remote models for heavy-lifting (open source models for the `oss` variant, and the same models used in the default `daily-driver` model pack for the `daily` variant).

Over time, as local models improve, these adaptive model packs will be updated to use local models for more roles.

There's also a built-in experimental `ollama` model pack that uses local models for all roles—this is recommended for testing and benchmarking, but not (yet) for getting real work done.

## System requirements

To use Ollama models, you need enough system resources to run the models you want to use. To use the built-in experimental `ollama` model pack (with qwen3:32b as the largest model), at least 32GB of RAM is recommended as an absolute minimum—48GB or more is recommended for breathing room. For the `ollama-daily` and `ollama-oss` model packs (with devstral:24b as the largest model), at least 16GB of RAM is recommended as an absolute minimum—24GB or more is recommended for breathing room.

If you use [custom models and a custom model pack](./custom-models.md), you'll have full flexibility to choose the appropriate models for your system. Just remember that running Plandex prompts successfully is a challenge for even the largest local models.

## Install and run Ollama

[Download and install ollama](https://ollama.com/download) for your platform.

Then make sure the Ollama server is running:

```bash
ollama serve
```

## Pull Ollama models

Pull the models you want to use. 

For the built-in `ollama` model pack, pull the following models:

```bash
ollama pull qwen3:8b
ollama pull qwen3:14b
ollama pull qwen3:32b
ollama pull devstral:24b
```

For the `ollama-daily` and `ollama-oss` model packs, pull the following models:

```bash
ollama pull qwen3:8b
ollama pull devstral:24b
```

## Use Ollama in Plandex

### Built-in model packs

To use one of the built-in Ollama model packs in Plandex, decide whether you want to use `ollama`, which uses local models for all roles, but may struggle in practice, `ollama-daily`, which uses local models for less demanding roles, plus the default Plandex models from the `daily-driver` model pack for heavy-lifting, or `ollama-oss`, which uses local models for less demanding roles, plus the open source Plandex models from the `oss` model pack for heavy-lifting.

```bash
\set-model ollama # REPL
plandex set-model ollama # CLI
```

Or:

```bash
\set-model ollama-daily # REPL
\set-model ollama-oss
plandex set-model ollama-daily # CLI
plandex set-model ollama-oss
```

### Custom models and model packs

You can also setup [custom models and model packs](./custom-models.md) for use with Ollama.

When configuring a custom model, be sure you add the `ollama` provider to the `providers` array with the `modelName` set to the name of the model you want to use, exactly as it appears in the [Ollama model list](https://ollama.com/models), prefixed with `ollama_chat/`. For example, to use the `qwen3:32b` model, you would add the following to the `providers` array:

```json
"providers": [
  {
    "provider": "ollama",
    "modelName": "ollama_chat/qwen3:32b"
  }
]
```

When configuring a custom model pack to use Ollama, set the top-level `localProvider` key to `ollama`. For example:

```json
{
  ...
  "modelPacks": [
    {
      "localProvider": "ollama",
      ...
    }
  ]
}
```

## Contributors

If you experiment with Plandex and Ollama and you find model combinations that work better than the built-in model packs, please chime in on [Discord](https://discord.gg/plandex-ai) or [open a PR](https://github.com/plandex-ai/plandex/pulls). The world of local models moves fast, and we can't always keep up with the cutting edge ourselves, so it would be great to have community help on filling in the gaps. With your help, we'd love to get to a place where Plandex can work effectively with 100% local models.

================================================
FILE: docs/docs/models/roles.md
================================================
---
sidebar_position: 6
sidebar_label: Roles
---

# Model Roles

Plandex has multiple **roles** that are used for different aspects of its functionality.

## Roles

### `planner`

This is the 'main' role that replies to prompts and makes plans.

Can optionally have a 'large context fallback' set, which is the model to use when the context input limit is exceeded.

### `architect`

When auto-context is enabled, this role makes a high-level plan using the project map, then determines what context to provide for the 'planner' role.

This role is optional. It falls back to the `planner` role if not set.

### `coder`

This role writes code to implement each step of the plan made by the `planner` role during the planning stage.

Instruction-following is important for this role as it needs to follow specific formatting rules.

This role is optional. It falls back to the `planner` role if not set.

### `summarizer`

Summarizes conversations to stay under the limit set in `max-convo-tokens`.

### `auto-continue`

Determines whether a plan is finished or should automatically continue based on the previous response.

### `builder`

Builds the proposed changes described by the `planner` role into pending file updates.

### `whole-file-builder`

Builds the proposed changes described by the `planner` role into pending file updates by writing the entire file. Used as a fallback if more targeted edits fail.

This role is optional. It falls back to the `builder` role if not set.

### `names`

Gives automatically-generated names to plans and context.

### `commit-messages`

Automatically generates commit messages for a set of pending updates.

================================================
FILE: docs/docs/quick-start.md
================================================
---
sidebar_position: 2
sidebar_label: Quickstart
---

# Quickstart

## Install Plandex

```bash
curl -sL https://plandex.ai/install.sh | bash
```

[Click here for more installation options.](./install.md)

Note that Windows is supported via [WSL](https://learn.microsoft.com/en-us/windows/wsl/about). Plandex only works correctly on Windows in the WSL shell. It doesn't work in the Windows CMD prompt or PowerShell.

## Hosting Options

| Option                     | Description                                                                                                                                                                                                                                                                                                           |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plandex Cloud**          | Winding down as of 10/3/2025 and no longer accepting new users. <a href="https://plandex.ai/blog/winding-down">Learn more.</a>                                                                                                                                                                                        |
| **Self-hosted/Local Mode** | • Run Plandex locally with Docker or host on your own server.<br/>• Use your own [OpenRouter.ai](https://openrouter.ai) key (or [other model provider](./models/model-providers.md) accounts and API keys).<br/>• Follow the [local-mode quickstart](./hosting/self-hosting/local-mode-quickstart.md) to get started. |

If you're going with a 'BYO API Key' option above (whether cloud or self-hosted), decide on the model provider(s) you want to use. The quickest option is to use OpenRouter.ai, but you can also use [many other providers](./models/model-providers.md).

If you're using OpenRouter.ai, first [sign up here.](https://openrouter.ai/signup) Then [generate an API key here.](https://openrouter.ai/keys) Set the `OPENROUTER_API_KEY` environment variable:

```bash
export OPENROUTER_API_KEY=...
```

## Get Started

If you're starting on a new project, make a directory first:

```bash
mkdir your-project-dir
```

Now `cd` into your **project's directory.**

```bash
cd your-project-dir
```

Then just give a quick the REPL help text a quick read, and you're ready go. The REPL starts in _chat mode_ by default, which is good for fleshing out ideas before moving to implementation. Once the task is clear, Plandex will prompt you to switch to _tell mode_ to make a detailed plan and start writing code.

```bash
plandex
```

or for short:

```bash
pdx
```

Then just give the REPL help text a quick read, and you're ready go.


================================================
FILE: docs/docs/repl.md
================================================
---
sidebar_position: 4
sidebar_label: REPL
---

# REPL

The Plandex REPL is a developer-friendly chat interface. It's the easiest way to use Plandex.

## Start

To start the REPL, just run `plandex` or `pdx` in any project directory (or sub-directory).

If you don't have a current plan in the directory, the REPL will create a new one. Otherwise, it will use the current plan.

## Commands

All Plandex CLI commands are available in the REPL. Just type a backslash (`\`) followed by the command.

The REPL also has a few special commands of its own:

- `\quit` or `\q` to quit the REPL
- `\help` or `\h` for help
- `@` plus a relative file path for loading files into context (note that if you're using auto-context mode, loading files yourself is optional)
- `\run` or `\r` plus a relative file path for using a file as a prompt
- `\chat` or `\ch` to switch to chat mode and have a conversation without making changes
- `\tell` or `\t` to switch to tell mode and implement tasks
- `\multi` or `\m` to switch to multi-line mode
- `\send` or `\s` to send the current prompt to Plandex (for sending a prompt in multi-line mode, since enter gives you a newline)

## REPL Flags

The REPL has a few convenient flags you can use to start it with different modes, autonomy settings, and model packs. You can pass any of these to `plandex` or `pdx` when starting the REPL.

```
  Mode
    --chat, -c     Start in chat mode (for conversation without making changes)
    --tell, -t     Start in tell mode (for implementation)

  Autonomy
    --no-auto      None → step-by-step, no automation
    --basic        Basic → auto-continue plans, no other automation
    --plus         Plus → auto-update context, smart context, auto-commit changes
    --semi         Semi-Auto → auto-load context
    --full         Full-Auto → auto-apply, auto-exec, auto-debug

  Models
    --daily        Daily driver pack (default models, balanced capability, cost, and speed)
    --strong       Strong pack (more capable models, higher cost and slower)
    --cheap        Cheap pack (less capable models, lower cost and faster)
    --oss          Open source pack (open source models)

    --gemini-planner       Gemini pack (Gemini 2.5 Pro for planning, default models for other roles)
    --o3-planner           OpenAI o3-medium for planning, default models for other roles
    --r1-planner           DeepSeek R1 for planning, default models for other roles
    --perplexity-planner   Perplexity for planning, default models for other roles
    --opus-planner         Anthropic Opus 4 for planning, default models for other roles

```


================================================
FILE: docs/docs/security.md
================================================
---
sidebar_position: 9
sidebar_label: Security
---

# Security
## Ignoring Sensitive Files

Plandex respects `.gitignore` and won't load any files that you're ignoring unless you use the `--force/-f` flag with `plandex load`. You can also add a `.plandexignore` file with ignore patterns to any directory.

## API Key Security

When [self-hosting](./hosting/self-hosting/local-mode-quickstart.md) or using [Plandex Cloud](./hosting/cloud.md) in BYO API Key Mode, API keys are only stored ephemerally in RAM while they are in active use. They are never written to disk, logged, or stored in a database. As soon as a plan stream ends, the API key is removed from memory and no longer exists anywhere on the Plandex server.

It's also up to you to manage your API keys securely. Try to avoid storing them in multiple places, exposing them to third party services, or sending them around in plain text.

You may also want to consider using Plandex Cloud in [Integrated Models Mode](./hosting/cloud.md#integrated-models-mode), which lets you skip dealing with API keys at all.

================================================
FILE: docs/docusaurus.config.ts
================================================
import {themes as prismThemes} from 'prism-react-renderer';
import type {Config} from '@docusaurus/types';
import type * as Preset from '@docusaurus/preset-classic';
// import search from "docusaurus-lunr-search"
// import redirect from "@docusaurus/plugin-client-redirects"

const config: Config = {
  title: 'Plandex Docs',
  tagline: 'An AI coding engine for large, real-world tasks',
  favicon: 'img/favicon.ico',

  // Set the production url of your site here
  url: 'https://docs.plandex.ai',
  // Set the /<baseUrl>/ pathname under which your site is served
  // For GitHub pages deployment, it is often '/<projectName>/'
  baseUrl: '/',

  onBrokenLinks: 'throw',
  onBrokenMarkdownLinks: 'warn',

  // Even if you don't use internationalization, you can use this field to set
  // useful metadata like html lang. For example, if your site is Chinese, you
  // may want to replace "en" with "zh-Hans".
  i18n: {
    defaultLocale: 'en',
    locales: ['en'],
  },

  presets: [
    [
      'classic',
      {
        docs: {
          sidebarPath: './sidebars.ts',
          routeBasePath: '/', // Serve the docs at the site's root
          editUrl:
            'https://github.com/plandex-ai/plandex/tree/main/docs/',
        },
        blog: false, // Disable the blog
        theme: {
          customCss: './src/css/custom.css',
        },
        
      } satisfies Preset.Options,
    ],
  ],
  themeConfig: {
    // Replace with your project's social card
    image: 'img/plandex-social-preview.png',
    colorMode: {
      defaultMode: "dark",
    },  
    navbar: {
      title: '',
      logo: {
        alt: 'Plandex Logo',
        src: 'img/plandex-logo-light.png',
        srcDark: 'img/plandex-logo-dark.png',
        href: "https://plandex.ai",
        height: "2.7rem",
      },
      items: [
        {
          href: 'https://github.com/plandex-ai/plandex',
          label: 'GitHub',
          position: 'right',
        },
        {
          label: 'Discord',
          href: 'https://discord.gg/plandex-ai',
          position: 'right',
        },
        {
          label: 'X',
          href: 'https://x.com/PlandexAI',
          position: 'right',
        },
        {
          label: 'YouTube',
          href: 'https://www.youtube.com/@plandex-ny5ry',
          position: 'right',
        },
      ],
    },
    footer: {
      style: 'dark',      
      copyright: `Copyright © ${new Date().getFullYear()} PlandexAI, Inc.`,
    },
    prism: {
      theme: prismThemes.github,
      darkTheme: prismThemes.dracula,
    },

    algolia: {
      // The application ID provided by Algolia
      appId: 'EG57NOYLYX',
      // Public API key: it is safe to commit it
      apiKey: 'a811f8bcdd87a8b3fe7f22a353b968ef',
      indexName: 'plandex',
    }
  } satisfies Preset.ThemeConfig,

  // plugins: [
  //   search,
  //   // [
  //   //   '@docusaurus/plugin-client-redirects',
  //   //   { redirects: [{ from: '/', to: '/intro'}] },
  //   // ],
  // ]
};

export default config;


================================================
FILE: docs/package.json
================================================
{
  "name": "docs",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "docusaurus": "docusaurus",
    "start": "docusaurus start",
    "build": "docusaurus build",
    "swizzle": "docusaurus swizzle",
    "deploy": "docusaurus deploy",
    "clear": "docusaurus clear",
    "serve": "docusaurus serve",
    "write-translations": "docusaurus write-translations",
    "write-heading-ids": "docusaurus write-heading-ids",
    "typecheck": "tsc"
  },
  "dependencies": {
    "@docusaurus/core": "3.4.0",
    "@docusaurus/plugin-client-redirects": "^3.4.0",
    "@docusaurus/preset-classic": "3.4.0",
    "@docusaurus/theme-search-algolia": "^3.4.0",
    "@mdx-js/react": "^3.0.0",
    "clsx": "^2.0.0",
    "docusaurus-lunr-search": "^3.4.0",
    "prism-react-renderer": "^2.3.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0"
  },
  "devDependencies": {
    "@docusaurus/module-type-aliases": "3.4.0",
    "@docusaurus/tsconfig": "3.4.0",
    "@docusaurus/types": "3.4.0",
    "typescript": "~5.2.2"
  },
  "browserslist": {
    "production": [
      ">0.5%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 3 chrome version",
      "last 3 firefox version",
      "last 5 safari version"
    ]
  },
  "engines": {
    "node": ">=18.0"
  }
}


================================================
FILE: docs/sidebars.ts
================================================
import type {SidebarsConfig} from '@docusaurus/plugin-content-docs';

/**
 * Creating a sidebar enables you to:
 - create an ordered group of docs
 - render a sidebar for each doc of that group
 - provide next/previous navigation

 The sidebars can be generated from the filesystem, or explicitly defined here.

 Create as many sidebars as you want.
 */
const sidebars: SidebarsConfig = {
  // By default, Docusaurus generates a sidebar from the docs folder structure
  tutorialSidebar: [{type: 'autogenerated', dirName: '.'}],

  // But you can create a sidebar manually
  /*
  tutorialSidebar: [
    'intro',
    'hello',
    {
      type: 'category',
      label: 'Tutorial',
      items: ['tutorial-basics/create-a-document'],
    },
  ],
   */
};

export default sidebars;


================================================
FILE: docs/src/css/custom.css
================================================
/**
 * Any CSS included here will be global. The classic template
 * bundles Infima by default. Infima is a CSS framework designed to
 * work well for content-centric websites.
 */

/* You can override the default Infima variables here. */
:root {
  --ifm-color-primary: #2e8555;
  --ifm-color-primary-dark: #29784c;
  --ifm-color-primary-darker: #277148;
  --ifm-color-primary-darkest: #205d3b;
  --ifm-color-primary-light: #33925d;
  --ifm-color-primary-lighter: #359962;
  --ifm-color-primary-lightest: #3cad6e;
  --ifm-code-font-size: 95%;
  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
}

/* For readability concerns, you should choose a lighter palette in dark mode. */
[data-theme='dark'] {
  --ifm-color-primary: #25c2a0;
  --ifm-color-primary-dark: #21af90;
  --ifm-color-primary-darker: #1fa588;
  --ifm-color-primary-darkest: #1a8870;
  --ifm-color-primary-light: #29d5b0;
  --ifm-color-primary-lighter: #32d8b4;
  --ifm-color-primary-lightest: #4fddbf;
  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
}

.navbar__logo img {
  height: 145%;
  margin-top: -6px;
}

================================================
FILE: docs/static/.nojekyll
================================================


================================================
FILE: docs/static/_redirects
================================================
/ /install 301!

================================================
FILE: docs/tsconfig.json
================================================
{
  // This file is not used in compilation. It is here just for a nice editor experience.
  "extends": "@docusaurus/tsconfig",
  "compilerOptions": {
    "baseUrl": "."
  }
}


================================================
FILE: plans/invite-commands.txt
================================================
Let's add the following commands to the 'app/cli/cmd' directory.

For all commands, look at the cli/types/api.go and shared/req_res.go files for the API request and response types.

Commands:

invite.go - invite a new user to the org. look at the 'checkout' command on accepting optional parameters or prompting if parameters aren't provided.

users.go - list all users in the org, as well as all pending invites in the org, then list them in a table like the one in the 'plans' command.

revoke.go - revoke an invite or remove a user from the org. optionally accept an email parameter. if email is supplied, revoke the user or invite with that email. if email is not supplied, prompt the user to select a user or invite to revoke, similar to how branches are selected in the 'checkout' command.





================================================
FILE: plans/model-sets-custom-models-crud.txt
================================================
I want to add functionality on both the CLI (cobra commands, api calls) and server (routes, handlers, db access functions) that allow a user to create, list, and delete custom models, and also create, list, or delete model sets for their org. I also want to add commands that list all the available models and model sets, including both built-in and user-created models and model sets.

Use the existing functionality for models and model sets as a guide and follow the same architecture, coding style, and ux.

Here are the commands/subcommands I want to add:

`plandex models available` - list all available models, both built-in and custom, in a nicely formatted table (use tablewriter like the other commands)

`plandex models create` - use terminal prompts in a similar way to the 'set-model' command to prompt the user for all necessary values to create a custom model, then call the api function to store it on the server

`plandex models delete` - prompt the user to choose from a list of custom models to delete 

`plandex model-sets` - list all available model sets, both built-in and user-created

`plandex model-sets create` - use terminal prompts in a similar way to the 'set-model' command to prompt the user for all necessary values to create a model set, then call the api function to store it on the server

Add all the required CLI and server code to make this work. Put the server-side handlers in 'app/server/handlers/models.go'. Create a new file in 'app/server/db/' for the db access functions.

On the client-side, update the Api interface and implementation to add the new api calls.




================================================
FILE: plans/pdx-file.md
================================================


================================================
FILE: plans/race_cond_chatgpt.txt
================================================
Based on conversation below with ChatGPT, I want you to fix the race condition as described with a retry mechanism similar to deadlock handling. I want it to be absolutely fucking impossible to have a race condition no matter the fuck what.

Convo with chatgpt:

locks.go:

```
package db

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"math/rand"
	"time"

	"github.com/lib/pq"
)

const lockHeartbeatInterval = 700 * time.Millisecond
const lockHeartbeatTimeout = 4 * time.Second

// distributed locking to ensure only one user can write to a plan repo at a time
// multiple readers are allowed, but read locks block writes
// write lock is exclusive (blocks both reads and writes)

type LockRepoParams struct {
	OrgId       string
	UserId      string
	PlanId      string
	Branch      string
	Scope       LockScope
	PlanBuildId string
	Ctx         context.Context
	CancelFn    context.CancelFunc
}

func LockRepo(params LockRepoParams) (string, error) {
	return lockRepo(params, 0)
}

func lockRepo(params LockRepoParams, numRetry int) (string, error) {
	log.Println("locking repo")
	// spew.Dump(params)

	orgId := params.OrgId
	userId := params.UserId
	planId := params.PlanId
	branch := params.Branch
	scope := params.Scope
	planBuildId := params.PlanBuildId
	ctx := params.Ctx
	cancelFn := params.CancelFn

	tx, err := Conn.BeginTxx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})
	if err != nil {
		return "", fmt.Errorf("error starting transaction: %v", err)
	}

	// Ensure that rollback is attempted in case of failure
	defer func() {
		if err != nil {
			if rbErr := tx.Rollback(); rbErr != nil {
				log.Printf("transaction rollback error: %v\n", rbErr)
			} else {
				log.Println("transaction rolled back")
			}
		}
	}()

	query := "SELECT id, org_id, user_id, plan_id, plan_build_id, scope, branch, created_at FROM repo_locks WHERE plan_id = $1 FOR UPDATE"
	queryArgs := []interface{}{planId}

	var locks []*repoLock

	fn := func() error {
		rows, err := tx.Query(query, queryArgs...)
		if err != nil {
			if pqErr, ok := err.(*pq.Error); ok && (pqErr.Code == "40001" || pqErr.Code == "40P01") {
				// return concurrency errors directly for retries
				return err
			}

			return fmt.Errorf("error getting repo locks: %v", err)
		}

		defer rows.Close()

		var expiredLockIds []string

		now := time.Now()
		for rows.Next() {
			var lock repoLock
			if err := rows.Scan(&lock.Id, &lock.OrgId, &lock.UserId, &lock.PlanId, &lock.PlanBuildId, &lock.Scope, &lock.Branch, &lock.CreatedAt); err != nil {
				return fmt.Errorf("error scanning repo lock: %v", err)
			}

			// ensure heartbeat hasn't timed out
			if now.Sub(lock.LastHeartbeatAt) < lockHeartbeatTimeout {
				locks = append(locks, &lock)
			} else {
				expiredLockIds = append(expiredLockIds, lock.Id)
			}
		}

		if len(expiredLockIds) > 0 {
			query := "DELETE FROM repo_locks WHERE id = ANY($1)"
			_, err := tx.Exec(query, pq.Array(expiredLockIds))
			if err != nil {
				return fmt.Errorf("error removing expired locks: %v", err)
			}
		}

		return nil
	}
	err = fn()
	if err != nil {
		if pqErr, ok := err.(*pq.Error); ok && (pqErr.Code == "40001" || pqErr.Code == "40P01") {
			if numRetry > 10 {
				err = fmt.Errorf("plan is currently being updated by another user")
				return "", err
			}

			log.Printf("Serialization or deadlock error, retrying transaction: %v\n", err)

			wait := time.Duration(numRetry) * 300 * time.Millisecond * time.Duration(rand.Intn(500)*int(time.Millisecond))

			select {
			case <-ctx.Done():
				return "", fmt.Errorf("context finished during retry transaction")
			case <-time.After(wait):
				return lockRepo(params, numRetry+1)
			}
		}

		return "", err
	}

	canAcquire := true
	canRetry := true

	// log.Println("locks:")
	// spew.Dump(locks)

	for _, lock := range locks {
		lockBranch := ""
		if lock.Branch != nil {
			lockBranch = *lock.Branch
		}

		if scope == LockScopeRead {
			canAcquireThisLock := lock.Scope == LockScopeRead && lockBranch == branch
			if !canAcquireThisLock {
				canAcquire = false
			}
		} else if scope == LockScopeWrite {
			canAcquire = false

			// if lock is for the same plan plan and branch, allow parallel writes
			if planId == lock.PlanId && branch == lockBranch {
				canAcquire = true
			}

			if lock.Scope == LockScopeWrite && lockBranch == branch {
				canRetry = false
			}
		} else {
			err = fmt.Errorf("invalid lock scope: %v", scope)
			return "", err
		}
	}

	if !canAcquire {
		log.Println("can't acquire lock. canRetry:", canRetry, "numRetry:", numRetry)

		if canRetry {
			// 10 second timeout
			if numRetry > 20 {
				err = fmt.Errorf("plan is currently being updated by another user")
				return "", err
			}
			time.Sleep(500 * time.Millisecond)
			return lockRepo(params, numRetry+1)
		}
		err = fmt.Errorf("plan is currently being updated by another user")
		return "", err
	}

	// Insert the new lock
	var lockPlanBuildId *string
	if planBuildId != "" {
		lockPlanBuildId = &planBuildId
	}

	var lockBranch *string
	if branch != "" {
		lockBranch = &branch
	}

	newLock := &repoLock{
		OrgId:       orgId,
		UserId:      userId,
		PlanId:      planId,
		PlanBuildId: lockPlanBuildId,
		Scope:       scope,
		Branch:      lockBranch,
	}
	// log.Println("newLock:")
	// spew.Dump(newLock)

	insertQuery := "INSERT INTO repo_locks (org_id, user_id, plan_id, plan_build_id, scope, branch) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id"
	err = tx.QueryRow(
		insertQuery,
		newLock.OrgId,
		newLock.UserId,
		newLock.PlanId,
		newLock.PlanBuildId,
		newLock.Scope,
		newLock.Branch,
	).Scan(&newLock.Id)
	if err != nil {
		return "", fmt.Errorf("error inserting new lock: %v", err)
	}

	// check if git lock file exists
	// remove it if so
	err = gitRemoveIndexLockFileIfExists(getPlanDir(orgId, planId))
	if err != nil {
		return "", fmt.Errorf("error removing lock file: %v", err)
	}

	branches, err := GitListBranches(orgId, planId)
	if err != nil {
		return "", fmt.Errorf("error getting branches: %v", err)
	}

	log.Println("branches:", branches)

	if branch != "" {
		// checkout the branch
		err = gitCheckoutBranch(getPlanDir(orgId, planId), branch)
		if err != nil {
			return "", fmt.Errorf("error checking out branch: %v", err)
		}
	}

	// Commit the transaction
	if err = tx.Commit(); err != nil {
		return "", fmt.Errorf("error committing transaction: %v", err)
	}

	// Start a goroutine to keep the lock alive
	go func() {
		numErrors := 0
		for {
			select {
			case <-ctx.Done():
				// log.Printf("case <-stream.Ctx.Done(): %s\n", newLock.Id)
				err := UnlockRepo(newLock.Id)
				if err != nil {
					log.Printf("Error unlocking repo: %v\n", err)
				}
				return

			default:
				res, err := Conn.Exec("UPDATE repo_locks SET last_heartbeat_at = NOW() WHERE id = $1", newLock.Id)

				if err != nil {
					log.Printf("Error updating repo lock last heartbeat: %v\n", err)
					numErrors++

					if numErrors > 5 {
						log.Printf("Too many errors updating repo lock last heartbeat: %v\n", err)
						cancelFn()
						return
					}
				}

				// check if 0 rows were updated
				rowsAffected, err := res.RowsAffected()
				if err != nil {
					log.Printf("Error getting rows affected: %v\n", err)
					cancelFn()
					return
				}

				if rowsAffected == 0 {
					log.Printf("Lock not found: %s | stopping heartbeat loop\n", newLock.Id)
					return
				}

				time.Sleep(lockHeartbeatInterval)
			}

		}
	}()

	log.Println("repo locked. id:", newLock.Id)

	return newLock.Id, nil
}

func UnlockRepo(id string) error {
	log.Println("unlocking repo:", id)

	query := "DELETE FROM repo_locks WHERE id = $1"
	_, err := Conn.Exec(query, id)
	if err != nil {
		return fmt.Errorf("error removing lock: %v", err)
	}

	log.Println("repo unlocked successfully:", id)

	return nil
}
```

git.go:


```
package db

import (
	"bytes"
	"fmt"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/fatih/color"
)

func init() {
	// ensure git is available
	cmd := exec.Command("git", "--version")
	if err := cmd.Run(); err != nil {
		panic(fmt.Errorf("error running git --version: %v", err))
	}
}

func InitGitRepo(orgId, planId string) error {
	dir := getPlanDir(orgId, planId)
	return initGitRepo(dir)
}

func initGitRepo(dir string) error {
	// Set the default branch name to 'main' for the new repository
	res, err := exec.Command("git", "-C", dir, "init", "-b", "main").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error initializing git repository with 'main' as default branch for dir: %s, err: %v, output: %s", dir, err, string(res))
	}

	// Configure user name and email for the repository
	if err := setGitConfig(dir, "user.email", "server@plandex.ai"); err != nil {
		return err
	}
	if err := setGitConfig(dir, "user.name", "Plandex"); err != nil {
		return err
	}

	return nil
}

func GitAddAndCommit(orgId, planId, branch, message string) error {
	dir := getPlanDir(orgId, planId)

	err := gitAdd(dir, ".")
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
	}

	err = gitCommit(dir, message)
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v", dir, err)
	}

	return nil
}

// func GitAddAndAmendCommit(orgId, planId, branch, addMessage string) error {
// 	dir := getPlanDir(orgId, planId)

// 	err := gitAdd(dir, ".")
// 	if err != nil {
// 		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v", dir, err)
// 	}

// 	// Get the latest commit message
// 	_, latestCommitMsg, err := getLatestCommit(dir)
// 	if err != nil {
// 		return fmt.Errorf("error getting latest commit message for dir: %s, err: %v", dir, err)
// 	}

// 	// Amend the latest commit with the new message
// 	message := latestCommitMsg + "\n\n" + addMessage
// 	res, err := exec.Command("git", "-C", dir, "commit", "--amend", "-m", message).CombinedOutput()

// 	if err != nil {
// 		return fmt.Errorf("error amending commit for dir: %s, err: %v, output: %s", dir, err, string(res))
// 	}

// 	return nil
// }

func GitRewindToSha(orgId, planId, branch, sha string) error {
	dir := getPlanDir(orgId, planId)

	err := gitRewindToSha(dir, sha)
	if err != nil {
		return fmt.Errorf("error rewinding git repository for dir: %s, err: %v", dir, err)
	}

	return nil
}

func GetGitCommitHistory(orgId, planId, branch string) (body string, shas []string, err error) {
	dir := getPlanDir(orgId, planId)

	body, shas, err = getGitCommitHistory(dir)
	if err != nil {
		return "", nil, fmt.Errorf("error getting git history for dir: %s, err: %v", dir, err)
	}

	return body, shas, nil
}

func GetLatestCommit(orgId, planId, branch string) (sha, body string, err error) {
	dir := getPlanDir(orgId, planId)

	sha, body, err = getLatestCommit(dir)
	if err != nil {
		return "", "", fmt.Errorf("error getting latest commit for dir: %s, err: %v", dir, err)
	}

	return sha, body, nil
}

func GitListBranches(orgId, planId string) ([]string, error) {
	dir := getPlanDir(orgId, planId)

	var out bytes.Buffer
	cmd := exec.Command("git", "branch", "--format=%(refname:short)")
	cmd.Dir = dir
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		return nil, fmt.Errorf("error getting git branches for dir: %s, err: %v", dir, err)
	}

	branches := strings.Split(strings.TrimSpace(out.String()), "\n")

	if len(branches) == 0 || (len(branches) == 1 && branches[0] == "") {
		return []string{"main"}, nil
	}

	return branches, nil
}

func GitCreateBranch(orgId, planId, branch, newBranch string) error {
	dir := getPlanDir(orgId, planId)

	res, err := exec.Command("git", "-C", dir, "checkout", "-b", newBranch).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error creating git branch for dir: %s, err: %v, output: %s", dir, err, string(res))
	}

	return nil
}

func GitDeleteBranch(orgId, planId, branchName string) error {
	dir := getPlanDir(orgId, planId)

	res, err := exec.Command("git", "-C", dir, "branch", "-D", branchName).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error deleting git branch for dir: %s, err: %v, output: %s", dir, err, string(res))
	}

	return nil
}

func GitClearUncommittedChanges(orgId, planId string) error {
	dir := getPlanDir(orgId, planId)

	// Reset staged changes
	res, err := exec.Command("git", "-C", dir, "reset", "--hard").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error resetting staged changes | err: %v, output: %s", err, string(res))
	}

	// Clean untracked files
	res, err = exec.Command("git", "-C", dir, "clean", "-d", "-f").CombinedOutput()
	if err != nil {
		return fmt.Errorf("error cleaning untracked files | err: %v, output: %s", err, string(res))
	}

	return nil
}

// Not used currently but may be good to handle these errors specifically later if locking can't fully prevent them
// func isLockFileError(output string) bool {
// 	return strings.Contains(output, "fatal: Unable to create") && strings.Contains(output, ".git/index.lock': File exists")
// }

func gitCheckoutBranch(repoDir, branch string) error {
	// get current branch and only checkout if it's not the same
	// trying to check out the same branch will result in an error
	var out bytes.Buffer
	cmd := exec.Command("git", "-C", repoDir, "branch", "--show-current")
	cmd.Stdout = &out
	err := cmd.Run()
	if err != nil {
		return fmt.Errorf("error getting current git branch for dir: %s, err: %v", repoDir, err)
	}

	currentBranch := strings.TrimSpace(out.String())

	log.Println("currentBranch:", currentBranch)

	if currentBranch == branch {
		return nil
	}

	log.Println("checking out branch:", branch)

	res, err := exec.Command("git", "-C", repoDir, "checkout", branch).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error checking out git branch for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}

	return nil
}

func gitRewindToSha(repoDir, sha string) error {
	res, err := exec.Command("git", "-C", repoDir, "reset", "--hard",
		sha).CombinedOutput()

	if err != nil {
		return fmt.Errorf("error executing git reset for dir: %s, sha: %s, err: %v, output: %s", repoDir, sha, err, string(res))
	}

	return nil
}

func getLatestCommit(dir string) (sha, body string, err error) {
	var out bytes.Buffer
	cmd := exec.Command("git", "log", "--pretty=%h@@|@@%at@@|@@%B@>>>@")
	cmd.Dir = dir
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		return "", "", fmt.Errorf("error getting git history for dir: %s, err: %v",
			dir, err)
	}

	// Process the log output to get it in the desired format.
	history := processGitHistoryOutput(strings.TrimSpace(out.String()))

	first := history[0]

	sha = first[0]
	body = first[1]

	return sha, body, nil
}

func getGitCommitHistory(dir string) (body string, shas []string, err error) {
	var out bytes.Buffer
	cmd := exec.Command("git", "log", "--pretty=%h@@|@@%at@@|@@%B@>>>@")
	cmd.Dir = dir
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		return "", nil, fmt.Errorf("error getting git history for dir: %s, err: %v",
			dir, err)
	}

	// Process the log output to get it in the desired format.
	history := processGitHistoryOutput(strings.TrimSpace(out.String()))

	var output []string
	for _, el := range history {
		shas = append(shas, el[0])
		output = append(output, el[1])
	}

	return strings.Join(output, "\n\n"), shas, nil
}

// processGitHistoryOutput processes the raw output from the git log command and returns a formatted string.
func processGitHistoryOutput(raw string) [][2]string {
	var history [][2]string
	entries := strings.Split(raw, "@>>>@") // Split entries using the custom separator.

	for _, entry := range entries {
		// First clean up any leading/trailing whitespace or newlines from each entry.
		entry = strings.TrimSpace(entry)

		// Now split the cleaned entry into its parts.
		parts := strings.Split(entry, "@@|@@")
		if len(parts) == 3 {
			sha := parts[0]
			timestampStr := parts[1]
			message := strings.TrimSpace(parts[2]) // Trim whitespace from message as well.

			// Extract and format timestamp.
			timestamp, err := strconv.ParseInt(timestampStr, 10, 64)
			if err != nil {
				continue // Skip entries with invalid timestamps.
			}

			dt := time.Unix(timestamp, 0).UTC()
			formattedTs := dt.Format("Mon Jan 2, 2006 | 3:04:05pm MST")

			// Prepare the header with colors.
			headerColor := color.New(color.FgCyan, color.Bold)
			dateColor := color.New(color.FgCyan)

			// Combine sha, formatted timestamp, and message header into one string.
			header := fmt.Sprintf("%s | %s", headerColor.Sprintf("📝 Update %s", sha), dateColor.Sprintf("%s", formattedTs))

			// Combine header and message with a newline only if the message is not empty.
			fullEntry := header
			if message != "" {
				fullEntry += "\n" + message
			}

			history = append(history, [2]string{sha, fullEntry})
		}
	}

	return history
}

func gitAdd(repoDir, path string) error {
	res, err := exec.Command("git", "-C", repoDir, "add", path).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error adding files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}

	return nil
}

func gitCommit(repoDir, commitMsg string) error {
	res, err := exec.Command("git", "-C", repoDir, "commit", "-m", commitMsg).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error committing files to git repository for dir: %s, err: %v, output: %s", repoDir, err, string(res))
	}

	return nil
}

func gitRemoveIndexLockFileIfExists(repoDir string) error {
	// Remove the lock file if it exists
	lockFilePath := filepath.Join(repoDir, ".git", "index.lock")
	_, err := os.Stat(lockFilePath)

	// log.Println("lockFilePath:", lockFilePath)
	// log.Println("exists:", err == nil)

	if err == nil {
		if err := os.Remove(lockFilePath); err != nil {
			if os.IsNotExist(err) {
				return nil
			}

			return fmt.Errorf("error removing lock file: %v", err)
		}
	} else if !os.IsNotExist(err) {
		return fmt.Errorf("error checking lock file: %v", err)
	}

	return nil
}

func setGitConfig(repoDir, key, value string) error {
	res, err := exec.Command("git", "-C", repoDir, "config", key, value).CombinedOutput()
	if err != nil {
		return fmt.Errorf("error setting git config %s to %s for dir: %s, err: %v, output: %s", key, value, repoDir, err, string(res))
	}
	return nil
}
```

somehow a race condition is still possible here even though it shouldn't be. definitely rare but a user reported this -- image attached for ya

ChatGPT
It looks like you're encountering a fatal: unable to write new_index file error while trying to commit files to a Git repository. This issue is typically caused by an existing .git/index.lock file that was not properly removed after an operation, possibly due to a previous Git operation that didn't complete normally or was interrupted.

Here are a few steps you can take to resolve the issue:

Ensure No Git Processes Are Running: Make sure there are no ongoing Git operations that might be holding the lock. You can check and terminate any such processes if necessary.

Remove the Lock File Manually:

Navigate to the .git directory in your repository.
Check for the presence of an index.lock file.
If it exists, manually delete the index.lock file. Ensure that no Git operations are running when you do this.
Check File System Permissions: Verify that your user account has the necessary permissions to write to the files in the .git directory of your repository.

File System Issues: Sometimes, a corrupted file system or hardware issues can also lead to this error. Ensure that the disk is not full or read-only, and run a disk check if necessary.

Retry the Operation: After taking the above steps, try to commit again.

If these steps don't resolve the issue, it could be helpful to review the code surrounding your Git operations, especially how locks are managed in cases of concurrent access or failed operations. Your existing mechanism may need additional handling to ensure that locks are always released properly, even in error conditions.

Also, it’s worth checking the logic in your custom distributed locking system implemented in your locks.go to ensure that it’s effectively preventing race conditions and properly handling retries and rollbacks in case of errors. The issue might be tied to subtle timing issues or edge cases not covered by the current retry and locking logic.

i'm thinking i should be treating this ephemeral weird error kinda like a deadlock and have a retry with some kind of backoff maybe??
ChatGPT
Adding retry logic with exponential backoff is a good strategy to handle transient errors like this, particularly in distributed systems where race conditions or temporary file locking issues might occur. This method can help in overcoming temporary glitches without failing the operation immediately, especially when the error is likely to resolve itself in a short period, such as a locked file or a network glitch.

Here's a general approach you can adopt:

Retry with Exponential Backoff: Implement a retry mechanism that waits for an increasing amount of time before retrying the failed operation. The delay prevents immediate retries, which could exacerbate the problem, especially under high load or when many instances are competing for the same resources.

Limit the Number of Retries: Set a reasonable limit on the number of retries to avoid endless loops. After the maximum number of retries, log the error and potentially alert for manual intervention.

Logging: Log each retry attempt with its waiting time and reason for failure. This logging will be crucial for diagnosing issues in production environments.

Handle Specific Errors: If possible, identify and handle specific errors that should trigger a retry, such as the "unable to write new_index file" error. You might want to handle other errors differently.

Here’s a simple example in pseudocode to implement exponential backoff:

pseudo
Copy code
maxRetries := 5
retryInterval := 100 // milliseconds

for attempt := 0; attempt < maxRetries; attempt++ {
    err := performGitOperation()
    if err == nil {
        break
    } else if isRetryableError(err) {
        log("Retry attempt", attempt + 1, "failed. Waiting", retryInterval, "ms before retry.")
        sleep(retryInterval)
        retryInterval *= 2 // Double the interval for the next retry
    } else {
        log("Non-retryable error encountered:", err)
        break
    }
}

if err != nil {
    log("Operation failed after", maxRetries, "attempts.")
}
Implementation Notes:
Function performGitOperation would encapsulate the Git commands that might fail due to the lock issue.
Function isRetryableError would check if the error should trigger a retry (e.g., checking the error message for specific text).
Sleep and Logging: Handling actual sleep and logging based on your environment (consider appropriate logging framework or system sleep functions).
This pattern ensures that temporary problems can be mitigated by giving the system a brief period to stabilize (e.g., releasing locks) before retrying, thereby improving robustness against transient faults.

please output the error message i paste in as a screenshot in *text*
ChatGPT
Since I can't directly view images, I can't extract text from the screenshot you uploaded. To help you further with the error message, you could either type it out or use an OCR (Optical Character Recognition) tool to convert the screenshot to text and then paste it here.

don't you already have it in your context? ocr it dude
ChatGPT
Sorry for the oversight! Let me extract the text from your screenshot. Here's the error message from your screenshot:

vbnet
Copy code
src/modules/CrudProducts.astro | src/services/products.ts
Server error
  * Stream error
  * Failed to commit
  * Error committing files to git repository for dir
    /plandex-server/orgs/d17f7c27-9314-4b63-9d79-8a09825f92b/plans/7738457c-f419-4f33-81ff-056949a3c6d8, err
    * Exit status 128, output
      * Fatal: unable to write new_index file
It seems like you're facing a Git-related issue where it's unable to write to the new_index file. This problem could be due to an existing lock file, permission issues, or a corrupt repository state. As previously suggested, you might want to manually check for .git/index.lock file and ensure your directory permissions are correctly set to allow write operations.

--

fix this problem please so I never have to worry about it again and it will be impossible for anyone to get this error. but also be conservative and make sure you change the minimum necessary to accomplish this and don't introduce any new bugs or race conditions.


================================================
FILE: releases/cli/CHANGELOG.md
================================================
## CLI Version 2.2.1
## 🖇️  Connect your Claude Pro or Max subscription

If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. You can use it in either Integrated Models Mode on Plandex Cloud, or in BYO Key Mode (whether on Cloud or self-hosting).

Assuming you're using Anthropic models (which the default model pack does), you'll be asked if you want to connect your Claude subscription the first time you run Plandex. Follow the instructions to connect.

[Learn more in the docs.](https://docs.plandex.ai/models/claude-subscription)

## 🐞  Bug fixes

Fixed an [issue](https://github.com/plandex-ai/plandex/issues/291) with custom models and providers.

## CLI Version 2.2.0
This is a big release that is mainly focused on Plandex's model provider and model config system. It significantly increases model provider flexibility, makes custom model configuration much easier, reduces costs on Cloud, and adds built-in support for Ollama.

## 🔌  Model provider flexibility for BYO key mode

- Now when using Plandex in BYO key mode (either Cloud or self-hosted), you can easily use Plandex with a wide range of built-in model providers.

- Apart from OpenRouter and the OpenAI API (which were already built-in), built-in providers now include:
  - Anthropic API
  - Google AI Studio
  - Google Vertex AI
  - Azure OpenAI
  - AWS Bedrock
  - DeepSeek API
  - Perplexity API
  - Ollama (for local models—see below for details)

- See the new [model provider docs](https://docs.plandex.ai/models/model-providers) for more details.

![plandex-model-providers](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/new-providers.gif)

## 🛟  Provider fallback

- When API keys/credentials are provided for multiple providers for a model, Plandex will fail over to the last valid provider if the first one fails. This is especially useful when using a direct provider (like OpenAI or Anthropic) alongside OpenRouter. If the direct call fails, Plandex will fall back to OpenRouter, which has its *own* internal fallback system across multiple providers. You get the best of both worlds: direct access by default, with no additional cost or latency, plus multi-layered resilience in case of stability issues.

## 💰  5.5% price reduction for Plandex Cloud Integrated Models mode

- Thanks to the new model provider system described above, Plandex Cloud with Integrated Models mode can now make direct provider calls under the hood rather than defaulting to OpenRouter, which allows us to avoid OpenRouter's 5.5% surcharge on model calls and pass the savings on to you. OpenRouter is still used as a fallback for added resilience.

## ⚙️  JSON-based model config with IDE support

- Plandex now supports JSON-based model config, which make it much easier to try out different models, different settings, and to use custom models, providers, and model packs.

- The new JSON model config system integrates cleanly with your IDE or editor. When you first edit model settings, Plandex will prompt you to set a preferred editor, and the JSON config file will be opened in that editor.

- Model config files use JSON schemas, which allows for autocomplete, validation, and inline documentation/type hints in most IDEs and editors.

- Check out the new docs for [model settings](https://docs.plandex.ai/models/model-settings) and [custom models](https://docs.plandex.ai/models/custom-models) for full details.

### `set-model` and `set-model default` commands

- `set-model` has been simplified to work with the new system. If run without arguments, you'll be prompted to either select a built-in or custom model pack, or to directly edit the current plan's model config inline in JSON. You can also pass it a model pack name (`set-model daily-driver`) or jump straight to the JSON settings with `set-model --json`.

- `set-model default` works the same way, but allows you to configure the default model settings for new plans.

![plandex-model-settings-json](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/model-settings-json.gif)


### `models custom` command

- `models custom` is a new all-in-one command for managing custom providers, models, and model packs in one place. It replaces the `models add`, `models delete`, `model-packs create`, `model-packs update`, and `model-packs delete` commands.

- The first time you run it, if you haven't already configured any custom models or model packs, an example config file will be created to get you started. If you *do* already have custom models or model packs configured, the config file will be populated with those models and model packs.

![plandex-custom-models-json](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/custom-models-json.gif)

### `models` and `models default` commands

- The `models` and `models default` commands now show simplified output by default, with a new `--all` flag to show all properties.

- These commands also now show all fallback models (for large context, large output, errors, etc.) for each role, including multiple levels of fallback, which previously weren't always included in the output.

## 🦙  Built-in Ollama support

- Plandex now offers built-in support for Ollama, which makes it much easier to use local models. Check out the new [Ollama quickstart](https://docs.plandex.ai/models/ollama) for details.

![plandex-ollama](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/ollama.gif)

## 📖  Built-in models and models packs

- The docs now include all built-in [models](https://docs.plandex.ai/models/built-in/built-in-models) and [model packs](https://docs.plandex.ai/models/built-in/built-in-packs), making it easier to see what's available, and the settings for each model/model pack.

## 🧠  New built-in models

- `mistral/devstral-small`, with both OpenRouter and Ollama providers.

- The Qwen 3 series of models, from 8B to 235B, available with `cloud` variants for OpenRouter and `local` variants for Ollama.

- Distilled local versions of `deepseek/r1`, from 8b to 70b, available with Ollama provider.

## 🎛️  New model packs

- The `gemini-exp` model pack has been removed, and in its place there's now a new `gemini-planner` model pack, which uses Gemini 2.5 Pro for planning and context selection, and the default models for other roles, as well as a new `google` model pack, which uses either Gemini 2.5 Pro or Gemini 2.5 Flash for all roles.

- A new `o3-planner` model pack has been added, which uses OpenAI o3-medium for planning and context selection, and the default models for other roles.

## 🔄  Other built-in model updates

- Built-in Gemini 2.5 Pro and Gemini 2.5 Flash models now use the latest model identifiers (replacing old 2.5 Pro Preview and 2.5 Flash Preview identifiers)

- The `gemini-preview` model pack has been removed, and a new `gemini-planner` model pack has been added, which uses Gemini 2.5 Pro for planning and context selection, and the default models for other roles.

- OpenAI o3 models have had their pricing drastically reduced when using Plandex Cloud with Integrated Models mode—input tokens now cost $2/M, output $8/M, an 80% reduction.

- The `deepseek/r1` model has been updated to use the latest model identifier (`deepseek/deepseek-r1-0528`) on OpenRouter.

## 🐞  Bug fixes

- Fixed a file mapping bug for TypeScript files that caused directly exported symbols like `export const foo = 'bar'` to be omitted from map files. Also improved TypeScript mapping support for some other constructs like `declare global`, `namespace`, and `enum` blocks, and improved handling of arrow functions. Thanks to @mnahkies for the [PR](https://github.com/plandex-ai/plandex/pull/239) identifying this.

## 🔧  Other changes

- `plandex checkout` now has a `--yes/-y` flag to auto-confirm creating a new branch if it doesn't exist, so the command can be used for scripting with no user interaction.

- `plandex tell`, `plandex continue`, and `plandex build` all now support a `--skip-menu` flag to skip the interactive menu that appears when the response finishes and changes are pending. There's also a new `skip-changes-menu` config setting that can be set to `true` to skip this menu by default.

## CLI Version 2.1.6+1
- Error handling fix
- Fix for some roles in the `daily-driver` model pack that weren't correctly updated to Sonnet 4 in 2.1.6
- Added fallback from Sonnet 4 to Sonnet 3.7 to deal with occasional provider errors and rate limit issues

## CLI Version 2.1.6
- The newly released Claude Sonnet 4 is now stable in testing, so it now replaces Sonnet 3.7 as the default model for context sizes under 200k across all model packs where 3.7 was previously used.
- A new `strong-opus` model pack is now available. It uses Claude Opus 4 for planning and coding, and is otherwise the same as the 'strong' pack. Use it with `\set-model strong-opus` to try it out.
- The `opus-4-planner` model pack that was introduced in 2.1.5 has been renamed to `opus-planner`, but the old name is still supported. This model pack uses Claude Opus 4 for planning, and the default models for other roles.
- Fix for occasional garbled error message when the model is unresponsive.
- Fix for occasional 'couldn't aquire lock' error after stream finishes.
- Additional retry when model is unresponsive or hits provider rate limits—helps particularly with new Opus 4 model on OpenRouter.

## CLI Version 2.1.5
- Added newly released Claude Sonnet 4 and Claude Opus 4 as built-in models.
- Sonnet 4 isn't yet used in the default 'daily-driver' model pack due to sporadic errors in early testing, but it can be used with the 'sonnet-4-daily' model pack (use '\set-model sonnet-4-daily' to use it). It will be promoted to the default model pack soon.
- Opus 4 can be used with the 'opus-4-planner' model pack ( '\set-model opus-4-planner'), which uses Opus 4 for planning and Sonnet 4 for coding.
- Removed error fallbacks for o4-mini and gemini-2.5-pro-preview.

## CLI Version 2.1.3
- Fix for default model pack not being correctly applied to new plans
- Fix for potential crash on Linux when applying a plan

## CLI Version 2.1.2
- Fix for rare auto-load context timeout error when no files are loaded.

## CLI Version 2.1.1
- Fix for free Gemini 2.5 Pro Experimental OpenRouter endpoint.
- Retries for "No endpoints found that support cache control" error that showed up when OpenRouter temporarily disabled caching for Gemini 2.5 Pro Preview.
- Other minor improvements to error handling and retries.

## CLI Version 2.1.0+1
- Fix for potential encoding issue when loading files into context.

## CLI Version 2.1.0
## 🚀  OpenRouter only for BYO key

- When using a BYO key mode (either cloud or self-hosted), you can now use Plandex with **only** an OpenRouter.ai account and `OPENROUTER_API_KEY` set. A separate OpenAI account is no longer required.

- You can still use a separate OpenAI account if desired by setting the `OPENAI_API_KEY` environment variable in addition to `OPENROUTER_API_KEY`. This will cause OpenAI models to make direct calls to OpenAI, which is slightly faster and cheaper.

## 🧠  New Models

### Gemini

- Google's Gemini 2.5 Pro Preview is now available as a built-in model, and is the new default model when context is between 200k and 1M tokens.

- A new `gemini-preview` model pack has been added, which uses Gemini 2.5 Pro Preview for planning and coding, and default models for other roles. You can use this pack by running the REPL with the `--gemini-preview` flag (`plandex --gemini-preview`), or with `\set-model gemini-preview` from inside the REPL. Because this model is still in preview, a fallback to Gemini 1.5 Pro is used on failure.

- Google's Gemini Flash 2.5 Preview is also now available as a built-in model. While it's not currently used by default in any built-in model packs, you can use with `\set-model` or a custom model pack.

### OpenAI

- OpenAI's o4-mini is now available as a built-in model with `high`, `medium`, and `low` reasoning effort levels. o3-mini has been replaced by the corresponding o4-mini models across all model packs, with a fallback to o3-mini on failure. This improves Plandex's file edit reliability and performance with no increase in costs. o4-mini-medium is also the new default planning model for the `cheap` model pack.

- OpenAI's o3 is now available as a built-in model with `high`, `medium`, and `low` reasoning effort levels. Note that if you're using Plandex in BYO key mode, OpenAI requires an organization verification step before you can use o3.

- o3-high is the new default planning model for the `strong` model pack, replacing o1. Due to the verification requirements for o3, the `strong` pack falls back to o4-mini-high for planning if o3 is not available.

- OpenAI's gpt-4.1, gpt-4.1-mini, and gpt-4.1-nano have been added as built-in models, replacing gpt-4o and gpt-4o-mini in all model packs that used them previously.

- gpt-4.1 is now used as a large context fallback for the default `coder` role, effectively increasing the context limit for the implementation phase from 200k to 1M tokens.

- gpt-4.1 is also the new `coder` model in the `cheap` model pack, and is also the new main planning and coding model in the `openai` model pack.

## 🛟  Model Fallbacks

- In order to better incorporate newly released models and preview models that may have initial reliability or capacity issues, a more robust fallback and retry system has been implemented. This will allow for faster introduction of new models in the future while still maintaining a high level of reliability.

- Fallbacks for 'context length exceeded' errors have also been improved, so that these errors will now trigger an automatic fallback to a model with a larger context limit if one is defined in the model pack. This will fix issues like https://github.com/plandex-ai/plandex/issues/232 where the stream errors with a 400 or 413 error when context is exceeded instead of falling back correctly.

## 💰  Gemini Caching

- Gemini models now support prompt caching, significantly reducing costs and latency during planning, implementation, and builds when using Gemini models.

## 🤫  Quieter Reasoning

- When using Claude 3.7 Sonnet thinking model in the `reasoning` AND `strong` model packs, reasoning is no longer included by default. This clears up some issues that were caused by output with specific formatting that Plandex takes action on being duplicated between the reasoning and the main output. It also feels a bit more relaxed to keep the reasoning behind-the-scenes, even though there can be a longer wait for the initial output.

## 💻  REPL Improvements

- Additional handling of possibly incorrect or mistyped commands in the REPL. Now apart from suggesting commands only based on possibly mistyped backslash commands, any likely command with or without the backslash will suggest possible commands rather than sending the prompt straight to the AI model, which can waste tokens due to minor typos or a missing backslash.

## ☁️  Plandex Cloud

- If you started a free trial of Plandex Cloud with BYO Key mode, you can now switch to a trial of Integrated Models mode if desired from your [billing dashboard](https://app.plandex.ai/settings/billing) (use `illing` from the REPL to open the dashboard).

- When doing a trial in Integrated Models mode, you will now be warned when your trial credits balance goes below $1.00.

- In Integrated Models mode, the required number of credits to send a prompt is now much lower, so you can use more credits before getting an 'Insufficient credits' message.

## 🐞  Bug Fixes

- Fix for 'Plan replacement failed' error during file edits on Windows that was caused by mismatched line endings.

- Fix for 'tool calls not supported' error for custom models that use the XML output format (https://github.com/plandex-ai/plandex/issues/238).

- Fix for errors in some roles with Anthropic models when only a single system message was sent (https://github.com/plandex-ai/plandex/issues/208).

- Fix for potential back-pressure issue with large/concurrent project map operations.

- Plandex Cloud: fix for JSON parsing error on payment form when the card is declined. It will now show the proper error message.

## CLI Version 2.0.7+1
- Small adjustment to previous release: in the REPL, select the first auto-complete suggestion on 'enter' if any suggestions are listed.

## CLI Version 2.0.7
- Better handling of partial or mistyped commands in the REPL. Rather than falling through to the AI model, a partial `\` command that matches only a single option will default to that command. If multiple commands could match, you'll be given a list of options. For input that begins with a `\` but doesn't match any command, there is now a confirmation step. This helps to prevent accidentally sending mistyped commands the model and burning tokens.

## CLI Version 2.0.6
- Timeout for 'plandex browser' log capture command
- Better failure handling for 'plandex browser' command

## CLI Version 2.0.5
- Consolidated to a single model pack for Gemini 2.5 Pro Experimental: 'gemini-exp'. Use it with 'plandex --gemini-exp' or '\set-model gemini-exp' in the REPL.
- Prevent the '\send' command from being included in the prompt when using multi-line mode in the REPL.

## CLI Version 2.0.4
- **Models**
  - Claude Sonnet 3.7 thinking is now available as a built-in model. Try the `reasoning` model pack for more challenging tasks.
  - Gemini 2.5 pro (free/experimental version) is now available. Try the 'gemini-planner' or 'gemini-experimental' model packs to use it.
  - DeepSeek V3 03-24 version is available as a built-in model and is now used in the `oss` pack in the in the the `coder` role. 
  - OpenAI GPT 4.5 is available as a built-in model. It's not in any model packs so far due to rate limits and high cost, but is available to use via `set-model`
  
- **Debugging**
  - Plandex can now directly debug browser applications by catching errors and reading the console logs (requires Chrome).
  - Enhanced signal handling and subprocess termination robustness for execution control.

- **Model Packs**
  - Added commands:
    - `model-packs update`
    - `model-packs show`

- **Reliability**
  - Implemented HTTP retry logic with exponential backoff for transient errors.    

- **REPL**
  - Fixed whitespace handling issues.
  - Improved command execution flow.

- **Installation**
  - Clarified support for WSL-only environments.
  - Better handling of sudo and alias creation on Linux.

## CLI Version 2.0.3
- Fix potential race condition/goroutine explosion/crash in context update.
- Prevent crash with negative viewport height in stream tui.

## CLI Version 2.0.2
- Fixed bug where context auto-load would hang if there was no valid context to load (for example, if they're all directories, which is only discovered client-side, and which can't be auto-loaded)
- Fixed bug where the build output would sometimes wrap incorrectly, causing the Plan Stream TUI to get out of sync with the build output.
- Fixed bug where build output would jump between collapsed and expanded states during a stream, after the user manually expanded.

## CLI Version 2.0.1
- Fix for REPL startup failing when self-hosting or using BYOK cloud mode (https://github.com/plandex-ai/plandex/issues/216)
- Fix for potential crash with custom model pack (https://github.com/plandex-ai/plandex/issues/217)

## CLI Version 2.0.0
👋 Hi, Dane here. I'm the creator and lead developer of Plandex.

I'm excited to announce the beta release of Plandex v2, featuring major improvements in capabilities, user experience, and automation.

Plandex

## 🤖  Overview

While built on the same basic foundations as v1, v2 is best thought of as a new project with far more ambitious goals. 

Plandex is now a top-tier coding agent with fully autonomous capabilities.

By default, it combines the strengths of three top foundation model providers—Anthropic, OpenAI, and Google—to achieve significantly better coding results than can be achieved with only a single provider's models.

You get the coding abilities of Anthropic, the cost-effectiveness and speed of OpenAI's o3 mini, and the massive 2M token context window of Google Gemini, each used in the roles they're best suited for.

Plandex can: 
  - Discuss a project or feature at a high level
  - Load relevant context as needed throughout the discussion
  - Solidify the discussion into a detailed plan
  - Implement the changes
  - Apply the changes to your files
  - Run necessary commands
  - Automatically debug failures

Adding these capabilities together, Plandex can handle complex tasks that span entire large features or entire projects, generating 50-100 files or more in a single run.

Below is a more detailed look at what's new. You can also check out the updated [README](https://github.com/plandex-ai/plandex/blob/main/README.md), [website](https://plandex.ai), and [docs](https://docs.plandex.ai).

## 🧠  Newer, Smarter Models

- New default model pack combining Claude 3.7 Sonnet, o3-mini, and Gemini 1.5 Pro.

- A new set of built-in models and model packs for different use cases, including `daily-driver` (the default pack), `strong`, `cheap`, and `oss` packs, among others.

- New `architect` and `coder` roles that make it easier to use different models for different stages in the planning and implementation process.

## 📥  Better Context Management

- Automatic context selection with tree-sitter project maps (30+ languages supported).

- Effective 2M token context window for large tasks (massive codebases of ~20M tokens and more can be indexed for automatic context selection).

- Smart context management limits implementation steps to necessary files only, reducing costs and latency.

- Prompt caching for OpenAI and Anthropic models further reduces latency and costs.

## 📝  Reliable File Edits

- Much improved file editing performance and reliability, especially for large files.

- Simple edits can often be applied deterministically without a model call, reducing costs and latency.

- For more complex edits, validation and multiple fallbacks help ensure a very low failure rate.

- Supports individual files up to 100k tokens.

- On Plandex Cloud, a fine-tuned "instant apply" model further speeds up and reduces the cost of editing files up to 32k tokens in size. This is offered at no additional cost.

## 💻  New Developer Experience

- v2 includes a new default way to use Plandex: the Plandex REPL. Just type `plandex` in any project directory to start the REPL.

- Simple and intuitive chat-like experience.

- Fuzzy autocomplete for commands and files, 'chat' vs. 'tell' modes that separate ideation from implementation, and a multi-line mode for friendly editing of long prompts.

- All commands are still available as CLI calls directly from the terminal.

## 🚀  Configurable Automation

- Plandex is now capable of full autonomy with 'full auto' mode. It can load necessary context, apply changes, execute commands, and automatically debug problems.

- The automation level can be precisely configured depending on the task and your comfort level. A `basic` mode works just like Plandex v1, where files are loaded manually and execution is disabled. The new default in v2 is `semi-auto`, which enables automatic context loading, but still requires approval to apply changes and execute commands.

- By default, Plandex now includes command execution (with approval) in its planning process. It can install dependencies, build and run code, run tests, and more.

- Command execution is integrated with Plandex's diff review sandbox. Changes are tentatively applied before running commands, then rolled back if the command fails.

- A new `debug` command allows for automated debugging of any terminal command. Use it with type checkers, linters, builds, tests, and more.

## 💳  Built-in Payments, Credits, and Budgeting on Plandex Cloud

- Apart from the open source version of Plandex, which includes **all core features**, Plandex Cloud is a full-fledged product.

- It offers two subscription options: an **Integrated Models** mode that requires no additional accounts or API keys, and a **BYO API Key** mode that allows you to use your own OpenAI and OpenRouter.ai accounts and API keys. 

- In Integrated Models mode, you buy credits from Plandex Cloud and manage billing centrally. It includes usage tracking and reporting via the `usage` command, as well as convenience and budgeting features like an auto-recharge threshold, a notification threshold on monthly spend, and an overall monthly limit. You can [learn more about pricing here](https://plandex.ai#pricing).

- Billing settings are managed with a web dashboard (it can be accessed via the CLI with the `billing` command).

## 🪪  License Update

- Plandex has transitioned from AGPL 3.0 to the MIT License, simplifying future open-source contributions and allowing easier integration of proprietary enhancements in Plandex Cloud and related products.

- If you’ve previously contributed under AGPL and have concerns about this relicensing, please [reach out.](mailto:dane@plandex.ai)

## 🧰  And More

This isn't an exhaustive list! Apart from the above, there are many smaller features, bug fixes, and quality of life improvements. Give the updated [docs](https://docs.plandex.ai) a read for a full accounting of all commands and functionality.

## 🌟  Get Started

Go to the [quickstart](https://docs.plandex.ai/quickstart) to get started with v2 in minutes.

**Note:** while built on the same foundations, Plandex v2 is designed to be a run separately and independently from v1. It's not an in-place upgrade. So there's nothing in particular you need to do to upgrade; just follow the quickstart as if you were a brand new user. [More details here.](https://docs.plandex.ai/upgrading-v1-to-v2)

## 🙌  Don't Be A Stranger

- Jump into the [Plandex Discord](https://discord.gg/plandex-ai) if you have questions or feedback, or just want to hang out.

- You can [post an issue on GitHub](https://github.com/plandex-ai/plandex/issues) or [start a discussion](https://github.com/plandex-ai/plandex/discussions).

- You can reach out by email: [support@plandex.ai](mailto:support@plandex.ai).

- You can follow [@PlandexAI](https://x.com/plandexai) or my personal account [@Danenania](https://x.com/danenania) on X for updates, announcements, and random musings.

- You can subscribe on [YouTube](https://www.youtube.com/@plandex-ny5ry) for demonstrations, tutorials, and AI coding projects.

## Version 1.1.1
## Fix for terminal flickering when streaming plans 📺

Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.

## Claude 3.5 Sonnet model pack is now built-in 🧠

You can now easily use Claude 3.5 Sonnet with Plandex through OpenRouter.ai.

1. Create an account at [OpenRouter.ai](https://openrouter.ai) if you don't already have one.
2. [Generate an OpenRouter API key](https://openrouter.ai/keys).
3. Run `export OPENROUTER_API_KEY=...` in your terminal.
4. Run `plandex set-model`, select `choose a model pack to change all roles at once` and then choose either `anthropic-claude-3.5-sonnet` (which uses Claude 3.5 Sonnet for all heavy lifting and Claude 3 Haiku for lighter tasks) or `anthropic-claude-3.5-sonnet-gpt-4o` (which uses Claude 3.5 Sonnet for planning and summarization, gpt-4o for builds, and gpt-3.5-turbo for lighter tasks)

[plandex-claude-3.5-sonnet](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.1/clause-3-5-sonnet.gif)

Remember, you can run `plandex model-packs` for details on all built-in model packs.

## Version 1.1.0
## Support for loading images into context with gpt-4o 🖼️

- You can now load images into context with `plandex load path/to/image.png`. Supported image formats are png, jpeg, non-animated gif, and webp. So far, this feature is only available with the default OpenAI GPT-4o model.

![plandex-load-images](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.0/plandex-images.gif)

## No more hard OpenAI requirement for builder, verifier, and auto-fix roles 🧠

- Non-OpenAI models can now be used for *all* roles, including the builder, verifier, and auto-fix roles, since streaming function calls are no longer required for these roles.

- Note that reliable function calling is still required for these roles. In testing, it was difficult to find models that worked reliably enough for these roles, despite claimed support for function calling. For this reason, using non-OpenAI models for these roles should be considered experimental. Still, this provides a path forward for using open source, local, and other non-OpenAI models for these roles in the future as they improve.

## Reject pending changes with `plandex reject` 🚫

- You can now reject pending changes to one or more files with the `plandex reject` command. Running it with no arguments will reject all pending changes after confirmation. You can also reject changes to specific files by passing one or more file paths as arguments.

![plandex-reject](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.0/plandex-reject.gif)

## Summarization and auto-continue fixes 🛤 ️

- Fixes for summarization and auto-continue issues that could Plandex to lose track of where it is in the plan and repeat tasks or do tasks out of order, especially when using `tell` and `continue` after the initial `tell`.

## Verification and auto-fix improvements 🛠️

- Improvements to the verification and auto-fix step. Plandex is now more likely to catch and fix placeholder references like "// ... existing code ..." as well as incorrect removal or overwriting of code.

## Stale context fixes 🔄

- After a context file is updated, Plandex is less likely to use an old version of the code from earlier in the conversation--it now uses the latest version much more reliably.

## `plandex convo` command improvements 🗣️

- Added a `--plain / -p` flag to `plandex convo` and `plandex summary` that outputs the conversation/summary in plain text with no ANSI codes.
- `plandex convo` now accepts a message number or range of messages to display (e.g. `plandex convo 1`, `plandex convo 1-5`, `plandex convo 2-`). Use `plandex convo 1` to show the initial prompt.

## Context management improvements 📄

- Give notes added to context with `plandex load -n 'some note'` an auto-generated name in the `context ls` list.
- `plandex rm` can now accept a range of indices to remove (e.g. `plandex rm 1-5`)
- Better help text if `plandex load` is run with incorrect arguments
- Fix for `plandex load` issue loading paths that begin with `./`

## Better rate limit tolerance 🕰️

- Increase wait times when receiving rate limit errors from OpenAI API (common with new OpenAI accounts that haven't spent $50)

## Built-in model updates 🧠

- Removed 'gpt-4-turbo-preview' from list of built-in models and model packs

## Other fixes 🐞

- Fixes for some occasional rendering issues when streaming plans and build counts
- Fix for `plandex set-model` model selection showing built-in model options that aren't compatible with the selected role--now only compatible models are shown

## Help updates 📚

- `plandex help` now shows a brief overview on getting started with Plandex rather than the full command list
- `plandex help --all` or `plandex help -a` shows the full command list

## Version 1.0.0
- CLI updates for the 1.0.0 release
- See the [server/v1.0.0 release notes](https://github.com/plandex-ai/plandex/releases/tag/server%2Fv1.0.0) for full details

## Version 0.9.1
- Fix for occasional stream TUI panic during builds with long file paths (https://github.com/plandex-ai/plandex/issues/105)
- If auto-upgrade fails due to a permissions issue, suggest re-running command with `sudo` (https://github.com/plandex-ai/plandex/issues/97 - thanks @kalil0321!)
- Include 'openrouter' in list of model providers when adding a custom model (https://github.com/plandex-ai/plandex/issues/107)
- Make terminal prompts that shouldn't be optional (like the Base URL for a custom model) required across the board (https://github.com/plandex-ai/plandex/issues/108)
- Data that is piped into `plandex load` is now automatically given a name in `context ls` via a call to the `namer` role model (previously it had no name, making multiple pipes hard to disambiguate).
- Still show the '(r)eject file' hotkey in the `plandex changes` TUI when the current file isn't scrollable. 

## Version 0.9.0
## Major file update improvements 📄
- Much better accuracy for updates to existing files.
- Plandex is much less likely to screw up braces, parentheses, and other code structures.
- Plandex is much less likely to mistakenly remove code that it shouldn't.

## Major improvements to long plans with many steps 🛤️
- Plandex's 'working memory' has been upgraded. It is now much better at working through very long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.

## 'plandex diff' command ⚖️

![plandex-diff](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-diff.gif)

- New `plandex diff` command shows pending plan changes in `git diff` format.

## Plans can be archived 🗄️

![plandex-archive](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-archive.gif)

- If you aren't using a plan anymore, but you don't want to delete it, you can now archive it.
- Use `plandex archive` (or `plandex arc` for short) to archive a plan.
- Use `plandex plans --archived` (or `plandex plans -a`) to see archived plans in the current directory.
- Use `plandex unarchive` (or `plandex unarc`) to restore an archived plan.

## Custom models!! 🧠
### Use Plandex with models from OpenRouter, Together.ai, and more

![plandex-models](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-models.gif)

- Use `plandex models add` to add a custom model and use any provider that is compatible with OpenAI, including OpenRouter.ai, Together.ai, Ollama, Replicate, and more.
- Anthropic Claude models are available via OpenRouter.ai. Google Gemini 1.5 preview is also available on OpenRouter.ai but was flakey in initial testing. Tons of open source models are available on both OpenRouter.ai and Together.ai, among other providers.
- Some built-in models and model packs (see 'Model packs' below) have been included as a quick way to try out a few of the more powerful model options. Just use `plandex set-model` to try these.
- You can use a custom model you've added with `plandex set-model`, or add it to a model pack (see 'Model packs' below) with `plandex model-packs create`. Delete custom models you've added with `plandex models delete`.
- The roles a custom model can be used for depend on its OpenAI compatibility.
- Each model provider has an `ApiKeyEnvVar` associated with it, like `OPENROUTER_API_KEY`, `TOGETHER_API_KEY`, etc. You will need to have the appropriate environment variables set with a valid api key for each provider that you're using.
- Because all of Plandex's prompts have been tested against OpenAI models, support for new models should be considered **experimental**.
- If you find prompting patterns that are effective for certain models, please share them on Discord (https://discord.gg/plandex-ai) or GitHub (https://github.com/plandex-ai/plandex/discussions) and they may be included in future releases.

## Model packs 🎛️
- Instead of changing models for each role one by one, a model packs let you switch out all roles at once.
- Use `plandex model-packs create` qto create your own model packs. 
- Use `plandex model-packs` to list built-in and custom model packs. 
- Use `plandex set-model` to load a model pack.
- Use `plandex model-packs delete` to remove a custom model pack.

## Model defaults ⚙️
- Instead of only changing models on a per-plan basis, you can set model defaults that will apply to all new plans you start.
- Use `plandex models default` to see default model settings and `plandex set-model default` to update them. 

## More commands 💻
- `plandex summary` to see the latest plan summary
- `plandex rename` to rename the current plan

## Quality of life improvements 🧘‍♀️
- Descriptive top-line for `plandex apply` commit messages instead of just "applied pending changes".

![plandex-commit](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-commit.png)

- Better message in `plandex log` when a single piece of context is loaded or updated.
- Abbreviate really long file paths in `plandex ls`.
- Changed `OPENAI_ENDPOINT` env var to `OPENAI_API_BASE`, which is more standardized. OPENAI_ENDPOINT is still quietly supported.
- guides/ENV_VARS.md now lists environment variables you can use with Plandex (and a few convenience varaiables have been addded) - thanks @knno! → https://github.com/plandex-ai/plandex/pull/94

## Bug fixes 🐞
- Fix for potential crash in `plandex changes` TUI.
- Fixes for some rare potential deadlocks and conflicts when building a file or stopping a plan stream.

## Version 0.8.3
- Add support for new OpenAI models: `gpt-4-turbo` and `gpt-4-turbo-2024-04-09`
- Make `gpt-4-turbo` model the new default model for the planner, builder, and auto-continue roles -- in testing it seems to be better at reasoning and significantly less lazy than the previous default for these roles, `gpt-4-turbo-preview` -- any plan that has not previously had its model settings modified will now use `gpt-4-turbo` by default (those that have been modified will need to be updated manually) -- remember that you can always use `plandex set-model` to change models for your plans
- Fix for `set-model` command argument parsing (https://github.com/plandex-ai/plandex/issues/75)
- Fix for panic during plan stream when a file name's length exceeds the terminal width (https://github.com/plandex-ai/plandex/issues/84)
- Fix for handling files that are loaded into context and later deleted from the file system (https://github.com/plandex-ai/plandex/issues/47)
- Fix to prevent loading of duplicate files, directory trees, or urls into context (https://github.com/plandex-ai/plandex/issues/57)

## Version 0.8.2
- Fix root level --help/-h to use custom help command rather than cobra's help message (re: https://github.com/plandex-ai/plandex/issues/25)
- Include 'survey' fork (https://github.com/plandex-ai/survey) as a proper module instead of a local reference (https://github.com/plandex-ai/plandex/pull/37)
- Add support for OPENAI_ENDPOINT environment variable for custom OpenAI endpoints (https://github.com/plandex-ai/plandex/pull/46)
- Add support for OPENAI_ORG_ID environment variable for setting the OpenAI organization ID when using an API key with multiple OpenAI organizations.

## Version 0.8.1
- Fix for missing 'host' key when creating an account or signing in to a self-hosted server (https://github.com/plandex-ai/plandex/issues/11)
- `add` alias for `load` command + `unload` alias for `rm` command (https://github.com/plandex-ai/plandex/issues/12)
- Add `invite`, `revoke`, and `users` commands to `plandex help` output
- A bit of cleanup of extraneous logging

## Version 0.8.0
- `plandex invite` command to invite users to an org
- `plandex users` command to list users and pending invites for an org
- `plandex revoke` command to revoke an invite or remove a user from an org
- `plandex sign-in` fixes
- Fix for context update of directory tree when some paths are ignored
- Fix for `plandex branches` command showing no branches immediately after plan creation rather than showing the default 'main' branch

## Version 0.7.3
- Fixes for changes TUI replacement view
- Fixes for changes TUI text encoding issue
- Fixes context loading
- `plandex rm` can now remove a directory from context
- `plandex apply` fixes to avoid possible conflicts
- `plandex apply` ask user whether to commit changes
- Context update fixes
- Command suggestions can be disabled with PLANDEX_DISABLE_SUGGESTIONS environment variable

## Version 0.7.2
- PLANDEX_SKIP_UPGRADE environment variable can be used to disable upgrades
- Color fixes for light backgrounds

## Version 0.7.1
- Fix for re-running command after an upgrade
- Fix for user input prompts


================================================
FILE: releases/cli/versions/0.7.1.md
================================================
- Fix for re-running command after an upgrade
- Fix for user input prompts


================================================
FILE: releases/cli/versions/0.7.2.md
================================================
- PLANDEX_SKIP_UPGRADE environment variable can be used to disable upgrades
- Color fixes for light backgrounds


================================================
FILE: releases/cli/versions/0.7.3.md
================================================
- Fixes for changes TUI replacement view
- Fixes for changes TUI text encoding issue
- Fixes context loading
- `plandex rm` can now remove a directory from context
- `plandex apply` fixes to avoid possible conflicts
- `plandex apply` ask user whether to commit changes
- Context update fixes
- Command suggestions can be disabled with PLANDEX_DISABLE_SUGGESTIONS environment variable

================================================
FILE: releases/cli/versions/0.8.0.md
================================================
- `plandex invite` command to invite users to an org
- `plandex users` command to list users and pending invites for an org
- `plandex revoke` command to revoke an invite or remove a user from an org
- `plandex sign-in` fixes
- Fix for context update of directory tree when some paths are ignored
- Fix for `plandex branches` command showing no branches immediately after plan creation rather than showing the default 'main' branch

================================================
FILE: releases/cli/versions/0.8.1.md
================================================
- Fix for missing 'host' key when creating an account or signing in to a self-hosted server (https://github.com/plandex-ai/plandex/issues/11)
- `add` alias for `load` command + `unload` alias for `rm` command (https://github.com/plandex-ai/plandex/issues/12)
- Add `invite`, `revoke`, and `users` commands to `plandex help` output
- A bit of cleanup of extraneous logging



================================================
FILE: releases/cli/versions/0.8.2.md
================================================
- Fix root level --help/-h to use custom help command rather than cobra's help message (re: https://github.com/plandex-ai/plandex/issues/25)
- Include 'survey' fork (https://github.com/plandex-ai/survey) as a proper module instead of a local reference (https://github.com/plandex-ai/plandex/pull/37)
- Add support for OPENAI_ENDPOINT environment variable for custom OpenAI endpoints (https://github.com/plandex-ai/plandex/pull/46)
- Add support for OPENAI_ORG_ID environment variable for setting the OpenAI organization ID when using an API key with multiple OpenAI organizations.


================================================
FILE: releases/cli/versions/0.8.3.md
================================================
- Add support for new OpenAI models: `gpt-4-turbo` and `gpt-4-turbo-2024-04-09`
- Make `gpt-4-turbo` model the new default model for the planner, builder, and auto-continue roles -- in testing it seems to be better at reasoning and significantly less lazy than the previous default for these roles, `gpt-4-turbo-preview` -- any plan that has not previously had its model settings modified will now use `gpt-4-turbo` by default (those that have been modified will need to be updated manually) -- remember that you can always use `plandex set-model` to change models for your plans
- Fix for `set-model` command argument parsing (https://github.com/plandex-ai/plandex/issues/75)
- Fix for panic during plan stream when a file name's length exceeds the terminal width (https://github.com/plandex-ai/plandex/issues/84)
- Fix for handling files that are loaded into context and later deleted from the file system (https://github.com/plandex-ai/plandex/issues/47)
- Fix to prevent loading of duplicate files, directory trees, or urls into context (https://github.com/plandex-ai/plandex/issues/57)


================================================
FILE: releases/cli/versions/0.9.0.md
================================================
## Major file update improvements 📄
- Much better accuracy for updates to existing files.
- Plandex is much less likely to screw up braces, parentheses, and other code structures.
- Plandex is much less likely to mistakenly remove code that it shouldn't.

## Major improvements to long plans with many steps 🛤️
- Plandex's 'working memory' has been upgraded. It is now much better at working through very long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.

## 'plandex diff' command ⚖️

![plandex-diff](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-diff.gif)

- New `plandex diff` command shows pending plan changes in `git diff` format.

## Plans can be archived 🗄️

![plandex-archive](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-archive.gif)

- If you aren't using a plan anymore, but you don't want to delete it, you can now archive it.
- Use `plandex archive` (or `plandex arc` for short) to archive a plan.
- Use `plandex plans --archived` (or `plandex plans -a`) to see archived plans in the current directory.
- Use `plandex unarchive` (or `plandex unarc`) to restore an archived plan.

## Custom models!! 🧠
### Use Plandex with models from OpenRouter, Together.ai, and more

![plandex-models](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-models.gif)

- Use `plandex models add` to add a custom model and use any provider that is compatible with OpenAI, including OpenRouter.ai, Together.ai, Ollama, Replicate, and more.
- Anthropic Claude models are available via OpenRouter.ai. Google Gemini 1.5 preview is also available on OpenRouter.ai but was flakey in initial testing. Tons of open source models are available on both OpenRouter.ai and Together.ai, among other providers.
- Some built-in models and model packs (see 'Model packs' below) have been included as a quick way to try out a few of the more powerful model options. Just use `plandex set-model` to try these.
- You can use a custom model you've added with `plandex set-model`, or add it to a model pack (see 'Model packs' below) with `plandex model-packs create`. Delete custom models you've added with `plandex models delete`.
- The roles a custom model can be used for depend on its OpenAI compatibility.
- Each model provider has an `ApiKeyEnvVar` associated with it, like `OPENROUTER_API_KEY`, `TOGETHER_API_KEY`, etc. You will need to have the appropriate environment variables set with a valid api key for each provider that you're using.
- Because all of Plandex's prompts have been tested against OpenAI models, support for new models should be considered **experimental**.
- If you find prompting patterns that are effective for certain models, please share them on Discord (https://discord.gg/plandex-ai) or GitHub (https://github.com/plandex-ai/plandex/discussions) and they may be included in future releases.

## Model packs 🎛️
- Instead of changing models for each role one by one, a model packs let you switch out all roles at once.
- Use `plandex model-packs create` qto create your own model packs. 
- Use `plandex model-packs` to list built-in and custom model packs. 
- Use `plandex set-model` to load a model pack.
- Use `plandex model-packs delete` to remove a custom model pack.

## Model defaults ⚙️
- Instead of only changing models on a per-plan basis, you can set model defaults that will apply to all new plans you start.
- Use `plandex models default` to see default model settings and `plandex set-model default` to update them. 

## More commands 💻
- `plandex summary` to see the latest plan summary
- `plandex rename` to rename the current plan

## Quality of life improvements 🧘‍♀️
- Descriptive top-line for `plandex apply` commit messages instead of just "applied pending changes".

![plandex-commit](https://github.com/plandex-ai/plandex/blob/03263a83d76785846fd472693aed03d36a68b86c/releases/images/cli/0.9.0/plandex-commit.png)

- Better message in `plandex log` when a single piece of context is loaded or updated.
- Abbreviate really long file paths in `plandex ls`.
- Changed `OPENAI_ENDPOINT` env var to `OPENAI_API_BASE`, which is more standardized. OPENAI_ENDPOINT is still quietly supported.
- guides/ENV_VARS.md now lists environment variables you can use with Plandex (and a few convenience varaiables have been addded) - thanks @knno! → https://github.com/plandex-ai/plandex/pull/94

## Bug fixes 🐞
- Fix for potential crash in `plandex changes` TUI.
- Fixes for some rare potential deadlocks and conflicts when building a file or stopping a plan stream.


================================================
FILE: releases/cli/versions/0.9.1.md
================================================
- Fix for occasional stream TUI panic during builds with long file paths (https://github.com/plandex-ai/plandex/issues/105)
- If auto-upgrade fails due to a permissions issue, suggest re-running command with `sudo` (https://github.com/plandex-ai/plandex/issues/97 - thanks @kalil0321!)
- Include 'openrouter' in list of model providers when adding a custom model (https://github.com/plandex-ai/plandex/issues/107)
- Make terminal prompts that shouldn't be optional (like the Base URL for a custom model) required across the board (https://github.com/plandex-ai/plandex/issues/108)
- Data that is piped into `plandex load` is now automatically given a name in `plandex ls` via a call to the `namer` role model (previously it had no name, making multiple pipes hard to disambiguate).
- Still show the '(r)eject file' hotkey in the `plandex changes` TUI when the current file isn't scrollable. 

================================================
FILE: releases/cli/versions/1.0.0.md
================================================
- CLI updates for the 1.0.0 release
- See the [server/v1.0.0 release notes](https://github.com/plandex-ai/plandex/releases/tag/server%2Fv1.0.0) for full details

================================================
FILE: releases/cli/versions/1.1.0.md
================================================
## Support for loading images into context with gpt-4o 🖼️

- You can now load images into context with `plandex load path/to/image.png`. Supported image formats are png, jpeg, non-animated gif, and webp. So far, this feature is only available with the default OpenAI GPT-4o model.

![plandex-load-images](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.0/plandex-images.gif)

## No more hard OpenAI requirement for builder, verifier, and auto-fix roles 🧠

- Non-OpenAI models can now be used for *all* roles, including the builder, verifier, and auto-fix roles, since streaming function calls are no longer required for these roles.

- Note that reliable function calling is still required for these roles. In testing, it was difficult to find models that worked reliably enough for these roles, despite claimed support for function calling. For this reason, using non-OpenAI models for these roles should be considered experimental. Still, this provides a path forward for using open source, local, and other non-OpenAI models for these roles in the future as they improve.

## Reject pending changes with `plandex reject` 🚫

- You can now reject pending changes to one or more files with the `plandex reject` command. Running it with no arguments will reject all pending changes after confirmation. You can also reject changes to specific files by passing one or more file paths as arguments.

![plandex-reject](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.0/plandex-reject.gif)

## Summarization and auto-continue fixes 🛤 ️

- Fixes for summarization and auto-continue issues that could Plandex to lose track of where it is in the plan and repeat tasks or do tasks out of order, especially when using `tell` and `continue` after the initial `tell`.

## Verification and auto-fix improvements 🛠️

- Improvements to the verification and auto-fix step. Plandex is now more likely to catch and fix placeholder references like "// ... existing code ..." as well as incorrect removal or overwriting of code.

## Stale context fixes 🔄

- After a context file is updated, Plandex is less likely to use an old version of the code from earlier in the conversation--it now uses the latest version much more reliably.

## `plandex convo` command improvements 🗣️

- Added a `--plain / -p` flag to `plandex convo` and `plandex summary` that outputs the conversation/summary in plain text with no ANSI codes.
- `plandex convo` now accepts a message number or range of messages to display (e.g. `plandex convo 1`, `plandex convo 1-5`, `plandex convo 2-`). Use `plandex convo 1` to show the initial prompt.

## Context management improvements 📄

- Give notes added to context with `plandex load -n 'some note'` an auto-generated name in the `context ls` list.
- `plandex rm` can now accept a range of indices to remove (e.g. `plandex rm 1-5`)
- Better help text if `plandex load` is run with incorrect arguments
- Fix for `plandex load` issue loading paths that begin with `./`

## Better rate limit tolerance 🕰️

- Increase wait times when receiving rate limit errors from OpenAI API (common with new OpenAI accounts that haven't spent $50)

## Built-in model updates 🧠

- Removed 'gpt-4-turbo-preview' from list of built-in models and model packs

## Other fixes 🐞

- Fixes for some occasional rendering issues when streaming plans and build counts
- Fix for `plandex set-model` model selection showing built-in model options that aren't compatible with the selected role--now only compatible models are shown

## Help updates 📚

- `plandex help` now shows a brief overview on getting started with Plandex rather than the full command list
- `plandex help --all` or `plandex help -a` shows the full command list

================================================
FILE: releases/cli/versions/1.1.1.md
================================================
## Fix for terminal flickering when streaming plans 📺

Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.

## Claude 3.5 Sonnet model pack is now built-in 🧠

You can now easily use Claude 3.5 Sonnet with Plandex through OpenRouter.ai.

1. Create an account at [OpenRouter.ai](https://openrouter.ai) if you don't already have one.
2. [Generate an OpenRouter API key](https://openrouter.ai/keys).
3. Run `export OPENROUTER_API_KEY=...` in your terminal.
4. Run `plandex set-model`, select `choose a model pack to change all roles at once` and then choose either `anthropic-claude-3.5-sonnet` (which uses Claude 3.5 Sonnet for all heavy lifting and Claude 3 Haiku for lighter tasks) or `anthropic-claude-3.5-sonnet-gpt-4o` (which uses Claude 3.5 Sonnet for planning and summarization, gpt-4o for builds, and gpt-3.5-turbo for lighter tasks)

![plandex-claude-3.5-sonnet](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/1.1.1/claude-3-5-sonnet.gif)

Remember, you can run `plandex model-packs` for details on all built-in model packs.


================================================
FILE: releases/cli/versions/1.1.2.md
================================================
- Minor updates to command help and aliases.
- Fix for help message shown on invalid command or flags.
- Fix for `set-model` not updating settings for auto-fix and verifier roles (https://github.com/plandex-ai/plandex/issues/171)

================================================
FILE: releases/cli/versions/2.0.0.md
================================================
👋 Hi, Dane here. I'm the creator and lead developer of Plandex.

I'm excited to announce the beta release of Plandex v2, featuring major improvements in capabilities, user experience, and automation.

Plandex

## 🤖  Overview

While built on the same basic foundations as v1, v2 is best thought of as a new project with far more ambitious goals. 

Plandex is now a top-tier coding agent with fully autonomous capabilities.

By default, it combines the strengths of three top foundation model providers—Anthropic, OpenAI, and Google—to achieve significantly better coding results than can be achieved with only a single provider's models.

You get the coding abilities of Anthropic, the cost-effectiveness and speed of OpenAI's o3 mini, and the massive 2M token context window of Google Gemini, each used in the roles they're best suited for.

Plandex can: 
  - Discuss a project or feature at a high level
  - Load relevant context as needed throughout the discussion
  - Solidify the discussion into a detailed plan
  - Implement the changes
  - Apply the changes to your files
  - Run necessary commands
  - Automatically debug failures

Adding these capabilities together, Plandex can handle complex tasks that span entire large features or entire projects, generating 50-100 files or more in a single run.

Below is a more detailed look at what's new. You can also check out the updated [README](https://github.com/plandex-ai/plandex/blob/main/README.md), [website](https://plandex.ai), and [docs](https://docs.plandex.ai).

## 🧠  Newer, Smarter Models

- New default model pack combining Claude 3.7 Sonnet, o3-mini, and Gemini 1.5 Pro.

- A new set of built-in models and model packs for different use cases, including `daily-driver` (the default pack), `strong`, `cheap`, and `oss` packs, among others.

- New `architect` and `coder` roles that make it easier to use different models for different stages in the planning and implementation process.

## 📥  Better Context Management

- Automatic context selection with tree-sitter project maps (30+ languages supported).

- Effective 2M token context window for large tasks (massive codebases of ~20M tokens and more can be indexed for automatic context selection).

- Smart context management limits implementation steps to necessary files only, reducing costs and latency.

- Prompt caching for OpenAI and Anthropic models further reduces latency and costs.

## 📝  Reliable File Edits

- Much improved file editing performance and reliability, especially for large files.

- Simple edits can often be applied deterministically without a model call, reducing costs and latency.

- For more complex edits, validation and multiple fallbacks help ensure a very low failure rate.

- Supports individual files up to 100k tokens.

- On Plandex Cloud, a fine-tuned "instant apply" model further speeds up and reduces the cost of editing files up to 32k tokens in size. This is offered at no additional cost.

## 💻  New Developer Experience

- v2 includes a new default way to use Plandex: the Plandex REPL. Just type `plandex` in any project directory to start the REPL.

- Simple and intuitive chat-like experience.

- Fuzzy autocomplete for commands and files, 'chat' vs. 'tell' modes that separate ideation from implementation, and a multi-line mode for friendly editing of long prompts.

- All commands are still available as CLI calls directly from the terminal.

## 🚀  Configurable Automation

- Plandex is now capable of full autonomy with 'full auto' mode. It can load necessary context, apply changes, execute commands, and automatically debug problems.

- The automation level can be precisely configured depending on the task and your comfort level. A `basic` mode works just like Plandex v1, where files are loaded manually and execution is disabled. The new default in v2 is `semi-auto`, which enables automatic context loading, but still requires approval to apply changes and execute commands.

- By default, Plandex now includes command execution (with approval) in its planning process. It can install dependencies, build and run code, run tests, and more.

- Command execution is integrated with Plandex's diff review sandbox. Changes are tentatively applied before running commands, then rolled back if the command fails.

- A new `debug` command allows for automated debugging of any terminal command. Use it with type checkers, linters, builds, tests, and more.

## 💳  Built-in Payments, Credits, and Budgeting on Plandex Cloud

- Apart from the open source version of Plandex, which includes **all core features**, Plandex Cloud is a full-fledged product.

- It offers two subscription options: an **Integrated Models** mode that requires no additional accounts or API keys, and a **BYO API Key** mode that allows you to use your own OpenAI and OpenRouter.ai accounts and API keys. 

- In Integrated Models mode, you buy credits from Plandex Cloud and manage billing centrally. It includes usage tracking and reporting via the `usage` command, as well as convenience and budgeting features like an auto-recharge threshold, a notification threshold on monthly spend, and an overall monthly limit. You can [learn more about pricing here](https://plandex.ai#pricing).

- Billing settings are managed with a web dashboard (it can be accessed via the CLI with the `billing` command).

## 🪪  License Update

- Plandex has transitioned from AGPL 3.0 to the MIT License, simplifying future open-source contributions and allowing easier integration of proprietary enhancements in Plandex Cloud and related products.

- If you’ve previously contributed under AGPL and have concerns about this relicensing, please [reach out.](mailto:dane@plandex.ai)

## 🧰  And More

This isn't an exhaustive list! Apart from the above, there are many smaller features, bug fixes, and quality of life improvements. Give the updated [docs](https://docs.plandex.ai) a read for a full accounting of all commands and functionality.

## 🌟  Get Started

Go to the [quickstart](https://docs.plandex.ai/quickstart) to get started with v2 in minutes.

**Note:** while built on the same foundations, Plandex v2 is designed to be a run separately and independently from v1. It's not an in-place upgrade. So there's nothing in particular you need to do to upgrade; just follow the quickstart as if you were a brand new user. [More details here.](https://docs.plandex.ai/upgrading-v1-to-v2)

## 🙌  Don't Be A Stranger

- Jump into the [Plandex Discord](https://discord.gg/plandex-ai) if you have questions or feedback, or just want to hang out.

- You can [post an issue on GitHub](https://github.com/plandex-ai/plandex/issues) or [start a discussion](https://github.com/plandex-ai/plandex/discussions).

- You can reach out by email: [support@plandex.ai](mailto:support@plandex.ai).

- You can follow [@PlandexAI](https://x.com/plandexai) or my personal account [@Danenania](https://x.com/danenania) on X for updates, announcements, and random musings.

- You can subscribe on [YouTube](https://www.youtube.com/@plandex-ny5ry) for demonstrations, tutorials, and AI coding projects.





================================================
FILE: releases/cli/versions/2.0.1.md
================================================
- Fix for REPL startup failing when self-hosting or using BYOK cloud mode (https://github.com/plandex-ai/plandex/issues/216)
- Fix for potential crash with custom model pack (https://github.com/plandex-ai/plandex/issues/217)

================================================
FILE: releases/cli/versions/2.0.2.md
================================================
- Fixed bug where context auto-load would hang if there was no valid context to load (for example, if they're all directories, which is only discovered client-side, and which can't be auto-loaded)
- Fixed bug where the build output would sometimes wrap incorrectly, causing the Plan Stream TUI to get out of sync with the build output.
- Fixed bug where build output would jump between collapsed and expanded states during a stream, after the user manually expanded.

================================================
FILE: releases/cli/versions/2.0.3.md
================================================
- Fix potential race condition/goroutine explosion/crash in context update.
- Prevent crash with negative viewport height in stream tui.


================================================
FILE: releases/cli/versions/2.0.4.md
================================================
- **Models**
  - Claude Sonnet 3.7 thinking is now available as a built-in model. Try the `reasoning` model pack for more challenging tasks.
  - Gemini 2.5 pro (free/experimental version) is now available. Try the 'gemini-planner' or 'gemini-experimental' model packs to use it.
  - DeepSeek V3 03-24 version is available as a built-in model and is now used in the `oss` pack in the in the the `coder` role. 
  - OpenAI GPT 4.5 is available as a built-in model. It's not in any model packs so far due to rate limits and high cost, but is available to use via `set-model`
  
- **Debugging**
  - Plandex can now directly debug browser applications by catching errors and reading the console logs (requires Chrome).
  - Enhanced signal handling and subprocess termination robustness for execution control.

- **Model Packs**
  - Added commands:
    - `model-packs update`
    - `model-packs show`

- **Reliability**
  - Implemented HTTP retry logic with exponential backoff for transient errors.    

- **REPL**
  - Fixed whitespace handling issues.
  - Improved command execution flow.

- **Installation**
  - Clarified support for WSL-only environments.
  - Better handling of sudo and alias creation on Linux.

================================================
FILE: releases/cli/versions/2.0.5.md
================================================
- Consolidated to a single model pack for Gemini 2.5 Pro Experimental: 'gemini-exp'. Use it with 'plandex --gemini-exp' or '\set-model gemini-exp' in the REPL.
- Prevent the '\send' command from being included in the prompt when using multi-line mode in the REPL.


================================================
FILE: releases/cli/versions/2.0.6.md
================================================
- Timeout for 'plandex browser' log capture command
- Better failure handling for 'plandex browser' command

================================================
FILE: releases/cli/versions/2.0.7+1.md
================================================
- Small adjustment to previous release: in the REPL, select the first auto-complete suggestion on 'enter' if any suggestions are listed.

================================================
FILE: releases/cli/versions/2.0.7.md
================================================
- Better handling of partial or mistyped commands in the REPL. Rather than falling through to the AI model, a partial `\` command that matches only a single option will default to that command. If multiple commands could match, you'll be given a list of options. For input that begins with a `\` but doesn't match any command, there is now a confirmation step. This helps to prevent accidentally sending mistyped commands the model and burning tokens.

================================================
FILE: releases/cli/versions/2.0.8.md
================================================
- Additional handling of possibly incorrect or mistyped commands in the REPL. Now apart from suggesting commands only based on possibly mistyped backslash commands, any likely command with or without the backslash will will suggest possible commands rather than sending the prompt straight to the AI model, which can waste tokens due to minor typos or a missing backslash.

================================================
FILE: releases/cli/versions/2.1.0+1.md
================================================
- Fix for potential encoding issue when loading files into context.

================================================
FILE: releases/cli/versions/2.1.0.md
================================================
## 🚀  OpenRouter only for BYO key

- When using a BYO key mode (either cloud or self-hosted), you can now use Plandex with **only** an OpenRouter.ai account and `OPENROUTER_API_KEY` set. A separate OpenAI account is no longer required.

- You can still use a separate OpenAI account if desired by setting the `OPENAI_API_KEY` environment variable in addition to `OPENROUTER_API_KEY`. This will cause OpenAI models to make direct calls to OpenAI, which is slightly faster and cheaper.

## 🧠  New Models

### Gemini

- Google's Gemini 2.5 Pro Preview is now available as a built-in model, and is the new default model when context is between 200k and 1M tokens.

- A new `gemini-preview` model pack has been added, which uses Gemini 2.5 Pro Preview for planning and coding, and default models for other roles. You can use this pack by running the REPL with the `--gemini-preview` flag (`plandex --gemini-preview`), or with `\set-model gemini-preview` from inside the REPL. Because this model is still in preview, a fallback to Gemini 1.5 Pro is used on failure.

- Google's Gemini Flash 2.5 Preview is also now available as a built-in model. While it's not currently used by default in any built-in model packs, you can use with `\set-model` or a custom model pack.

### OpenAI

- OpenAI's o4-mini is now available as a built-in model with `high`, `medium`, and `low` reasoning effort levels. o3-mini has been replaced by the corresponding o4-mini models across all model packs, with a fallback to o3-mini on failure. This improves Plandex's file edit reliability and performance with no increase in costs. o4-mini-medium is also the new default planning model for the `cheap` model pack.

- OpenAI's o3 is now available as a built-in model with `high`, `medium`, and `low` reasoning effort levels. Note that if you're using Plandex in BYO key mode, OpenAI requires an organization verification step before you can use o3.

- o3-high is the new default planning model for the `strong` model pack, replacing o1. Due to the verification requirements for o3, the `strong` pack falls back to o4-mini-high for planning if o3 is not available.

- OpenAI's gpt-4.1, gpt-4.1-mini, and gpt-4.1-nano have been added as built-in models, replacing gpt-4o and gpt-4o-mini in all model packs that used them previously.

- gpt-4.1 is now used as a large context fallback for the default `coder` role, effectively increasing the context limit for the implementation phase from 200k to 1M tokens.

- gpt-4.1 is also the new `coder` model in the `cheap` model pack, and is also the new main planning and coding model in the `openai` model pack.

## 🛟  Model Fallbacks

- In order to better incorporate newly released models and preview models that may have initial reliability or capacity issues, a more robust fallback and retry system has been implemented. This will allow for faster introduction of new models in the future while still maintaining a high level of reliability.

- Fallbacks for 'context length exceeded' errors have also been improved, so that these errors will now trigger an automatic fallback to a model with a larger context limit if one is defined in the model pack. This will fix issues like https://github.com/plandex-ai/plandex/issues/232 where the stream errors with a 400 or 413 error when context is exceeded instead of falling back correctly.

## 💰  Gemini Caching

- Gemini models now support prompt caching, significantly reducing costs and latency during planning, implementation, and builds when using Gemini models.

## 🤫  Quieter Reasoning

- When using Claude 3.7 Sonnet thinking model in the `reasoning` AND `strong` model packs, reasoning is no longer included by default. This clears up some issues that were caused by output with specific formatting that Plandex takes action on being duplicated between the reasoning and the main output. It also feels a bit more relaxed to keep the reasoning behind-the-scenes, even though there can be a longer wait for the initial output.

## 💻  REPL Improvements

- Additional handling of possibly incorrect or mistyped commands in the REPL. Now apart from suggesting commands only based on possibly mistyped backslash commands, any likely command with or without the backslash will suggest possible commands rather than sending the prompt straight to the AI model, which can waste tokens due to minor typos or a missing backslash.

## ☁️  Plandex Cloud

- If you started a free trial of Plandex Cloud with BYO Key mode, you can now switch to a trial of Integrated Models mode if desired from your [billing dashboard](https://app.plandex.ai/settings/billing) (use `\billing` from the REPL to open the dashboard).

- When doing a trial in Integrated Models mode, you will now be warned when your trial credits balance goes below $1.00.

- In Integrated Models mode, the required number of credits to send a prompt is now much lower, so you can use more credits before getting an 'Insufficient credits' message.

## 🐞  Bug Fixes

- Fix for 'Plan replacement failed' error during file edits on Windows that was caused by mismatched line endings.

- Fix for 'tool calls not supported' error for custom models that use the XML output format (https://github.com/plandex-ai/plandex/issues/238).

- Fix for errors in some roles with Anthropic models when only a single system message was sent (https://github.com/plandex-ai/plandex/issues/208).

- Fix for potential back-pressure issue with large/concurrent project map operations.

- Plandex Cloud: fix for JSON parsing error on payment form when the card is declined. It will now show the proper error message.

================================================
FILE: releases/cli/versions/2.1.1.md
================================================
- Fix for free Gemini 2.5 Pro Experimental OpenRouter endpoint.
- Retries for "No endpoints found that support cache control" error that showed up when OpenRouter temporarily disabled caching for Gemini 2.5 Pro Preview.
- Other minor improvements to error handling and retries.


================================================
FILE: releases/cli/versions/2.1.2.md
================================================
- Fix for rare auto-load context timeout error when no files are loaded.

================================================
FILE: releases/cli/versions/2.1.3.md
================================================
- Fix for default model pack not being correctly applied to new plans
- Fix for potential crash on Linux when applying a plan

================================================
FILE: releases/cli/versions/2.1.5.md
================================================
- Added newly released Claude Sonnet 4 and Claude Opus 4 as built-in models.
- Sonnet 4 isn't yet used in the default 'daily-driver' model pack due to sporadic errors in early testing, but it can be used with the 'sonnet-4-daily' model pack (use '\set-model sonnet-4-daily' to use it). It will be promoted to the default model pack soon.
- Opus 4 can be used with the 'opus-4-planner' model pack ( '\set-model opus-4-planner'), which uses Opus 4 for planning and Sonnet 4 for coding.
- Removed error fallbacks for o4-mini and gemini-2.5-pro-preview.






================================================
FILE: releases/cli/versions/2.1.6+1.md
================================================
- Error handling fix
- Fix for some roles in the `daily-driver` model pack that weren't correctly updated to Sonnet 4 in 2.1.6
- Added fallback from Sonnet 4 to Sonnet 3.7 to deal with occasional provider errors and rate limit issues

================================================
FILE: releases/cli/versions/2.1.6.md
================================================
- The newly released Claude Sonnet 4 is now stable in testing, so it now replaces Sonnet 3.7 as the default model for context sizes under 200k across all model packs where 3.7 was previously used.
- A new `strong-opus` model pack is now available. It uses Claude Opus 4 for planning and coding, and is otherwise the same as the 'strong' pack. Use it with `\set-model strong-opus` to try it out.
- The `opus-4-planner` model pack that was introduced in 2.1.5 has been renamed to `opus-planner`, but the old name is still supported. This model pack uses Claude Opus 4 for planning, and the default models for other roles.
- Fix for occasional garbled error message when the model is unresponsive.
- Fix for occasional 'couldn't aquire lock' error after stream finishes.
- Additional retry when model is unresponsive or hits provider rate limits—helps particularly with new Opus 4 model on OpenRouter.

================================================
FILE: releases/cli/versions/2.2.0.md
================================================
This is a big release that is mainly focused on Plandex's model provider and model config system. It significantly increases model provider flexibility, makes custom model configuration much easier, reduces costs on Cloud, and adds built-in support for Ollama.

## 🔌  Model provider flexibility for BYO key mode

- Now when using Plandex in BYO key mode (either Cloud or self-hosted), you can easily use Plandex with a wide range of built-in model providers.

- Apart from OpenRouter and the OpenAI API (which were already built-in), built-in providers now include:
  - Anthropic API
  - Google AI Studio
  - Google Vertex AI
  - Azure OpenAI
  - AWS Bedrock
  - DeepSeek API
  - Perplexity API
  - Ollama (for local models—see below for details)

- See the new [model provider docs](https://docs.plandex.ai/models/model-providers) for more details.

![plandex-model-providers](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/new-providers.gif)

## 🛟  Provider fallback

- When API keys/credentials are provided for multiple providers for a model, Plandex will fail over to the last valid provider if the first one fails. This is especially useful when using a direct provider (like OpenAI or Anthropic) alongside OpenRouter. If the direct call fails, Plandex will fall back to OpenRouter, which has its *own* internal fallback system across multiple providers. You get the best of both worlds: direct access by default, with no additional cost or latency, plus multi-layered resilience in case of stability issues.

## 💰  5.5% price reduction for Plandex Cloud Integrated Models mode

- Thanks to the new model provider system described above, Plandex Cloud with Integrated Models mode can now make direct provider calls under the hood rather than defaulting to OpenRouter, which allows us to avoid OpenRouter's 5.5% surcharge on model calls and pass the savings on to you. OpenRouter is still used as a fallback for added resilience.

## ⚙️  JSON-based model config with IDE support

- Plandex now supports JSON-based model config, which make it much easier to try out different models, different settings, and to use custom models, providers, and model packs.

- The new JSON model config system integrates cleanly with your IDE or editor. When you first edit model settings, Plandex will prompt you to set a preferred editor, and the JSON config file will be opened in that editor.

- Model config files use JSON schemas, which allows for autocomplete, validation, and inline documentation/type hints in most IDEs and editors.

- Check out the new docs for [model settings](https://docs.plandex.ai/models/model-settings) and [custom models](https://docs.plandex.ai/models/custom-models) for full details.

### `set-model` and `set-model default` commands

- `set-model` has been simplified to work with the new system. If run without arguments, you'll be prompted to either select a built-in or custom model pack, or to directly edit the current plan's model config inline in JSON. You can also pass it a model pack name (`set-model daily-driver`) or jump straight to the JSON settings with `set-model --json`.

- `set-model default` works the same way, but allows you to configure the default model settings for new plans.

![plandex-model-settings-json](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/model-settings-json.gif)


### `models custom` command

- `models custom` is a new all-in-one command for managing custom providers, models, and model packs in one place. It replaces the `models add`, `models delete`, `model-packs create`, `model-packs update`, and `model-packs delete` commands.

- The first time you run it, if you haven't already configured any custom models or model packs, an example config file will be created to get you started. If you *do* already have custom models or model packs configured, the config file will be populated with those models and model packs.

![plandex-custom-models-json](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/custom-models-json.gif)

### `models` and `models default` commands

- The `models` and `models default` commands now show simplified output by default, with a new `--all` flag to show all properties.

- These commands also now show all fallback models (for large context, large output, errors, etc.) for each role, including multiple levels of fallback, which previously weren't always included in the output.

## 🦙  Built-in Ollama support

- Plandex now offers built-in support for Ollama, which makes it much easier to use local models. Check out the new [Ollama quickstart](https://docs.plandex.ai/models/ollama) for details.

![plandex-ollama](https://github.com/plandex-ai/plandex/blob/main/releases/images/cli/2.2.0/ollama.gif)

## 📖  Built-in models and models packs

- The docs now include all built-in [models](https://docs.plandex.ai/models/built-in/built-in-models) and [model packs](https://docs.plandex.ai/models/built-in/built-in-packs), making it easier to see what's available, and the settings for each model/model pack.

## 🧠  New built-in models

- `mistral/devstral-small`, with both OpenRouter and Ollama providers.

- The Qwen 3 series of models, from 8B to 235B, available with `cloud` variants for OpenRouter and `local` variants for Ollama.

- Distilled local versions of `deepseek/r1`, from 8b to 70b, available with Ollama provider.

## 🎛️  New model packs

- The `gemini-exp` model pack has been removed, and in its place there's now a new `gemini-planner` model pack, which uses Gemini 2.5 Pro for planning and context selection, and the default models for other roles, as well as a new `google` model pack, which uses either Gemini 2.5 Pro or Gemini 2.5 Flash for all roles.

- A new `o3-planner` model pack has been added, which uses OpenAI o3-medium for planning and context selection, and the default models for other roles.

## 🔄  Other built-in model updates

- Built-in Gemini 2.5 Pro and Gemini 2.5 Flash models now use the latest model identifiers (replacing old 2.5 Pro Preview and 2.5 Flash Preview identifiers)

- The `gemini-preview` model pack has been removed, and a new `gemini-planner` model pack has been added, which uses Gemini 2.5 Pro for planning and context selection, and the default models for other roles.

- OpenAI o3 models have had their pricing drastically reduced when using Plandex Cloud with Integrated Models mode—input tokens now cost $2/M, output $8/M, an 80% reduction.

- The `deepseek/r1` model has been updated to use the latest model identifier (`deepseek/deepseek-r1-0528`) on OpenRouter.

## 🐞  Bug fixes

- Fixed a file mapping bug for TypeScript files that caused directly exported symbols like `export const foo = 'bar'` to be omitted from map files. Also improved TypeScript mapping support for some other constructs like `declare global`, `namespace`, and `enum` blocks, and improved handling of arrow functions. Thanks to @mnahkies for the [PR](https://github.com/plandex-ai/plandex/pull/239) identifying this.

## 🔧  Other changes

- `plandex checkout` now has a `--yes/-y` flag to auto-confirm creating a new branch if it doesn't exist, so the command can be used for scripting with no user interaction.

- `plandex tell`, `plandex continue`, and `plandex build` all now support a `--skip-menu` flag to skip the interactive menu that appears when the response finishes and changes are pending. There's also a new `skip-changes-menu` config setting that can be set to `true` to skip this menu by default.

================================================
FILE: releases/cli/versions/2.2.1.md
================================================
## 🖇️  Connect your Claude Pro or Max subscription

If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. You can use it in either Integrated Models Mode on Plandex Cloud, or in BYO Key Mode (whether on Cloud or self-hosting).

Assuming you're using Anthropic models (which the default model pack does), you'll be asked if you want to connect your Claude subscription the first time you run Plandex. Follow the instructions to connect.

[Learn more in the docs.](https://docs.plandex.ai/models/claude-subscription)

## 🐞  Bug fixes

Fixed an [issue](https://github.com/plandex-ai/plandex/issues/291) with custom models and providers.

================================================
FILE: releases/server/CHANGELOG.md
================================================
## Server Version 2.2.1
See CLI 2.2.1 release notes.

## Server Version 2.2.1
See CLI 2.2.1 release notes.

## Server Version 2.2.0
See CLI 2.2.0 release notes.

## Server Version 2.1.8
- Fix for potential hang in file map queue

## Server Version 2.1.7
- Fix for "conversation summary timestamp not found in conversation" error (https://github.com/plandex-ai/plandex/issues/274)
- Fix for potential panic/crash during plan stream (https://github.com/plandex-ai/plandex/issues/275)
- Better protection against panics/crashes in server goroutines across the board

## Server Version 2.1.6+1
See CLI 2.1.6+1 release notes.

## Server Version 2.1.6
See CLI 2.1.6 release notes.

## Server Version 2.1.5
See CLI 2.1.5 release notes.

## Server Version 2.1.4
- Fix to remove occasional extraneous blank lines from start/end of edited files.

## Server Version 2.1.3
- Fix for 'panic in execTellPlan' error when using a model pack that doesn't explicitly set the 'coder' or 'whole-file-builder' roles

## Server Version 2.1.2
- Fix for auto-load context error: 'Error decoding response → EOF'

## Server Version 2.1.1+1
- Improve error handling to catch yet another "context length exceeded" error message variation from Anthropic.

## Server Version 2.1.1
See CLI 2.1.1 release notes.

## Server Version 2.1.0+1
- Fix for context length exceeded error that still wasn't being caught and retried by the fallback correctly.

## Server Version 2.1.0
See CLI 2.1.0 release notes.

## Server Version 2.0.6
- Improvements to process management and cleanup for command execution
- Remove extraneous model request logging

## Server Version 2.0.5
- Fix for a bug that was causing occasional model errors. Model calls should be much more reliable now.
- Better error handling and error messages for model errors (rate limits or other errors).
- No error retries for rate limit errors.
- Fixed bug that caused retries to add the prompt to the conversation multiple times.
- Error responses with no output no longer create a log entry.

## Server Version 2.0.4
- **Stability**
  - Enhanced database locking mechanisms.
  - Improved error notifications.

- **API Enhancements**
  - Added endpoints for managing custom models and updating model packs.

- **Execution**
  - Increased robustness in plan execution and subprocess lifecycle management.

- **Observability**
  - Real-time internal notifications for critical errors implemented.

- **Consistency**
  - Improved token management.
  - Enhanced summarization accuracy.

## Server Version 2.0.3
- Fix for potential crash during chat/tell operation.
- Panic handling to prevent crashes in general.
- Fix for local queue handling bug during builds that could cause queue to get stuck and cause subsequent operations to hang.

## Server Version 2.0.2
Server-side fix for context auto-load hanging when there's no valid context to load (for example, if they're all directories, which is only discovered client-side, and which can't be auto-loaded)

## Server Version 2.0.0+2
- Version tag sanitation fix for GitHub Action to build and push server image to DockerHub

## Server Version 2.0.0+1
- Fix for custom model creation (https://github.com/plandex-ai/plandex/issues/214)
- Fix for version check on self-hosted (https://github.com/plandex-ai/plandex/issues/213)
- Fix for GitHub Action to build and push server image to DockerHub

## Server Version 2.0.0
See CLI 2.0.0 release notes.

## Version 1.1.1
- Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.
- Claude 3.5 Sonnet model and model pack (via OpenRouter.ai) is now built-in.

## Version 1.1.1
- Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.
- Claude 3.5 Sonnet model and model pack (via OpenRouter.ai) is now built-in.

## Version 1.1.1
- Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.
- Claude 3.5 Sonnet model and model pack (via OpenRouter.ai) is now built-in.

## Version 1.1.0
- Give notes added to context with `plandex load -n 'some note'` automatically generated names in `context ls` list.
- Fixes for summarization and auto-continue issues that could Plandex to lose track of where it is in the plan and repeat tasks or do tasks out of order, especially when using `tell` and `continue` after the initial `tell`.
- Improvements to the verification and auto-fix step. Plandex is now more likely to catch and fix placeholder references like "// ... existing code ..." as well as incorrect removal or overwriting of code.
- After a context file is updated, Plandex is less likely to use an old version of the code from earlier in the conversation--it now uses the latest version much more reliably.
- Increase wait times when receiving rate limit errors from OpenAI API (common with new OpenAI accounts that haven't spent $50).

## Version 1.0.1
- Fix for occasional 'Error getting verify state for file' error
- Fix for occasional 'Fatal: unable to write new_index file' error
- Fix for occasional 'nothing to commit, working tree clean' error
- When hitting OpenAI rate limits, Plandex will now parse error messages that include a recommended wait time and automatically wait that long before retrying, up to 30 seconds (https://github.com/plandex-ai/plandex/issues/123)
- Some prompt updates to encourage creation of multiple smaller files rather than one mega-file when generating files for a new feature or project. Multiple smaller files are faster to generate, use less tokens, and have a lower error rate compared to a continually updated large file.

## Version 1.0.0
##   ☄️  🌅   gpt-4o is the real deal for coding

- gpt-4o, OpenAI's latest model, is the new default model for Plandex. 4o is much better than gpt-4-turbo (the previous default model) in early testing for coding tasks and agent workflows.
- If you have not used `plandex set-model` or `plandex set-model default` previously to set a custom model, you will now be use gpt-4o by default. If you *have* used one of those commands, use `plandex set-model` or `plandex set-model default` and select the new `gpt-4o-latest` model-pack to upgrade. 
 
##   🛰️  🏥   Reliability improvements: 90% reduction in syntax errors in early testing

- Automatic syntax and logic validation with an auto-correction step for file updates.
- Significantly improves reliability and reduces syntax errors, mistaken duplication or removal of code, placeholders that reference other code and other similar issues. 
- With a set of ~30 internal evals spanning 5 common languages, syntax errors were reduced by over 90% on average with gpt-4o. 
- Logical errors are also reduced (I'm still working on evals for those to get more precise numbers).
- Plandex is now much better at handling large files and plans that make many updates to the same file. Both could be problematic in previous versions.
- Plandex is much more resilient to incorrectly labelled file blocks when the model uses the file label format incorrectly to explain something rather than for a file. i.e. "Run this script" and then a bash script block. Previously Plandex would mistakenly create a file called "Run this script". It now ignores blocks like these.

##   🧠  🚞   Improvements to core planning engine: better memory and less laziness allow you to accomplish larger and more complex tasks without errors or stopping early

- Plandex is now much better at working through long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.
- Plandex is much less likely to leave TODO placeholders in comments instead of fully completing a task, or to otherwise leave a task incomplete.
- Plandex is much less likely to end a plan before all tasks are completed.

##   🏎️  📈   Performance improvements: 2x faster planning and execution

- gpt-4o is twice as fast as gpt-4-turbo for planning, summarization, builds, and more.
- If you find it's streaming too fast and you aren't able to review the output, try using the `--stop / -s` flag with `plandex tell` or `plandex continue`. It will stop the plan after a single response so you can review it before proceeding. Use `plandex continue` to proceed with the plan once you're ready.
- Speaking of which, if you're in exploratory mode and want to use less tokens, you can also use the `--no-build / -n` flag with `plandex tell` and `plandex continue`. This prevents Plandex from building files until you run `plandex build` manually.

##   💰  🪙   2x cost reduction: gpt-4o is half the per-token price of gpt-4-turbo

- For the same quantity of tokens, with improved quality and 2x speed, you'll pay half-price.

##   👩‍💻  🎭   New `plandex-dev` and `pdxd` alias in development mode

- In order to avoid conflicts/overwrites with the `plandex` CLI and `pdx` alias, a new `plandex-dev` command and `pdxd` alias have been added in development mode. 

##  🐛  🛠️   Bug fixes

- Fix for a potential panic during account creation (https://github.com/plandex-ai/plandex/issues/76)
- Fixes for some account creation flow issues (https://github.com/plandex-ai/plandex/issues/106)
- Fix for occasional "Stream buffer tokens too high" error (https://github.com/plandex-ai/plandex/issues/34).
- Fix for potential panic when updating model settings. Might possibly be the cause of or somehow related to https://github.com/plandex-ai/plandex/issues/121 but hard to be sure (maybe AWS was just being flakey).
- Attempted fix for rare git repo race condition @jesseswell_1 caught that gives error ending with: 
```
Exit status 128, output
      * Fatal: unable to write new_index file
```

##   📚  🤔   Readme updates

- The [readme](https://github.com/plandex-ai/plandex) has been revamped to be more informative and easier to navigate.

##  🏡  📦   Easy self-contained startup script for local mode and self-hosting

```bash
git clone https://github.com/plandex-ai/plandex.git
cd plandex/app
./start_local.sh
``` 

- Sincere thanks to @ZanzyTHEbar aka @daofficialwizard on Discord who wrote the script! 🙏🙏

##   🚀  ☝️   Upgrading   

- As always, cloud has already been updated with the latest version. To upgrade the CLI, run any `plandex` command (like `plandex version` or `plandex help` or whatever command you were about to run anyway 🙂)

##   💬  📆   Join me for office hours every Friday 12:30-1:30pm PST in Discord, starting May 17th

- I'll be available by voice and text chat to answer questions, talk about the new version, and hear about your use cases. Come on over and hang out! 
- Join the discord to get a reminder when office hours are starting: https://discord.gg/plandex-ai

## Version 0.9.1
- Improvements to auto-continue check. Plandex now does a better job determining whether a plan is finished or should automatically continue by incorporating the either the latest plan summary or the previous conversation message (if the summary isn't ready yet) into the auto-continue check. Previously the check was using only the latest conversation message.
- Fix for 'exit status 128' errors in a couple of edge case scenarios.
- Data that is piped into `plandex load` is now automatically given a name in `context ls` via a call to the `namer` role model (previously it had no name, making multiple pipes hard to disambiguate).

## Version 0.9.0
- Support for custom models, model packs, and default models (see CLI 0.9.0 release notes for details).
- Better accuracy for updates to existing files.
- Plandex is less likely to screw up braces, parentheses, and other code structures.
- Plandex is less likely to mistakenly remove code that it shouldn't.
- Plandex is now much better at working through very long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.
- Server-side support for `plandex diff` command to show pending plan changes in `git diff` format.
- Server-side support for archiving and unarchiving plans.
- Server-side support for `plandex summary` command.
- Server-side support for `plandex rename` command.
- Descriptive top-line for `plandex apply` commit messages instead of just "applied pending changes".
- Better message in `plandex log` when a single piece of context is loaded or updated.
- Fixes for some rare potential deadlocks and conflicts when building a file or stopping astream.

## Version 0.8.4
- Add support for new OpenAI models: `gpt-4-turbo` and `gpt-4-turbo-2024-04-09`
- Make `gpt-4-turbo` model the new default model for the planner, builder, and auto-continue roles -- in testing it seems to be better at reasoning and significantly less lazy than the previous default for these roles, `gpt-4-turbo-preview` -- any plan that has not previously had its model settings modified will now use `gpt-4-turbo` by default (those that have been modified will need to be updated manually) -- remember that you can always use `plandex set-model` to change models for your plans
- Fix for handling files that are loaded into context and later deleted from the file system (https://github.com/plandex-ai/plandex/issues/47)
- Handle file paths with ### prefixes (https://github.com/plandex-ai/plandex/issues/77)
- Fix for occasional race condition during file builds that causes error "Fatal: Unable to write new index file"

## Version 0.8.3
- SMTP_FROM environment variable for setting from address when self-hosting and using SMTP (https://github.com/plandex-ai/plandex/pull/39)
- Add support for OPENAI_ENDPOINT environment variable for custom OpenAI endpoints (https://github.com/plandex-ai/plandex/pull/46)
- Add support for OPENAI_ORG_ID environment variable for setting the OpenAI organization ID when using an API key with multiple OpenAI organizations.
- Fix for unhelpful "Error getting plan, context, convo, or summaries" error message when OpenAI returns an error for invalid API key or insufficient credits (https://github.com/plandex-ai/plandex/issues/32)

## Version 0.8.2
- Fix for creating an org that auto-adds users based on email domain (https://github.com/plandex-ai/plandex/issues/24)
- Fix for possible crash after error in file build
- Added crash prevention measures across the board
- Fix for occasional "replacements failed" error
- Reliability and improvements for file updates
- Fix for role name of auto-continue model

## Version 0.8.1
- Fixes for two potential server crashes
- Fix for server git repo remaining in locked state after a crash, which caused various issues
- Fix for server git user and email not being set in some environments (https://github.com/plandex-ai/plandex/issues/8)
- Fix for 'replacements failed' error that was popping up in some circumstances
- Fix for build issue that could cause large updates to fail, take too long, or use too many tokens in some circumstances
- Clean up extraneous logging
- Prompt update to prevent ouputting files at absolute paths (like '/etc/config.txt')
- Prompt update to prevent sometimes using file block format for explanations, causing explanations to be outputted as files
- Prompt update to prevent stopping before the plan is really finished 
- Increase maximum number of auto-continuations to 50 (from 30)

## Version 0.8.0
- User management improvements and fixes
- Backend support for `plandex invite`, `plandex users`, and `plandex revoke` commands
- Improvements to copy for email verification emails
- Fix for org creation when creating a new account
- Send an email to invited user when they are invited to an org
- Add timeout when forwarding requests from one instance to another within a cluster

## Version 0.7.1
- Fix for SMTP email issue
- Add '/version' endpoint to server

## Version 0.7.0
Initial release


================================================
FILE: releases/server/versions/0.7.0.md
================================================
Initial release

================================================
FILE: releases/server/versions/0.7.1.md
================================================
- Fix for SMTP email issue
- Add '/version' endpoint to server

================================================
FILE: releases/server/versions/0.8.0.md
================================================
- User management improvements and fixes
- Backend support for `plandex invite`, `plandex users`, and `plandex revoke` commands
- Improvements to copy for email verification emails
- Fix for org creation when creating a new account
- Send an email to invited user when they are invited to an org
- Add timeout when forwarding requests from one instance to another within a cluster

================================================
FILE: releases/server/versions/0.8.1.md
================================================
- Fixes for two potential server crashes
- Fix for server git repo remaining in locked state after a crash, which caused various issues
- Fix for server git user and email not being set in some environments (https://github.com/plandex-ai/plandex/issues/8)
- Fix for 'replacements failed' error that was popping up in some circumstances
- Fix for build issue that could cause large updates to fail, take too long, or use too many tokens in some circumstances
- Clean up extraneous logging
- Prompt update to prevent ouputting files at absolute paths (like '/etc/config.txt')
- Prompt update to prevent sometimes using file block format for explanations, causing explanations to be outputted as files
- Prompt update to prevent stopping before the plan is really finished 
- Increase maximum number of auto-continuations to 50 (from 30)


================================================
FILE: releases/server/versions/0.8.2.md
================================================
- Fix for creating an org that auto-adds users based on email domain (https://github.com/plandex-ai/plandex/issues/24)
- Fix for possible crash after error in file build
- Added crash prevention measures across the board
- Fix for occasional "replacements failed" error
- Reliability and improvements for file updates
- Fix for role name of auto-continue model

================================================
FILE: releases/server/versions/0.8.3.md
================================================
- SMTP_FROM environment variable for setting from address when self-hosting and using SMTP (https://github.com/plandex-ai/plandex/pull/39)
- Add support for OPENAI_ENDPOINT environment variable for custom OpenAI endpoints (https://github.com/plandex-ai/plandex/pull/46)
- Add support for OPENAI_ORG_ID environment variable for setting the OpenAI organization ID when using an API key with multiple OpenAI organizations.
- Fix for unhelpful "Error getting plan, context, convo, or summaries" error message when OpenAI returns an error for invalid API key or insufficient credits (https://github.com/plandex-ai/plandex/issues/32)


================================================
FILE: releases/server/versions/0.8.4.md
================================================
- Add support for new OpenAI models: `gpt-4-turbo` and `gpt-4-turbo-2024-04-09`
- Make `gpt-4-turbo` model the new default model for the planner, builder, and auto-continue roles -- in testing it seems to be better at reasoning and significantly less lazy than the previous default for these roles, `gpt-4-turbo-preview` -- any plan that has not previously had its model settings modified will now use `gpt-4-turbo` by default (those that have been modified will need to be updated manually) -- remember that you can always use `plandex set-model` to change models for your plans
- Fix for handling files that are loaded into context and later deleted from the file system (https://github.com/plandex-ai/plandex/issues/47)
- Handle file paths with ### prefixes (https://github.com/plandex-ai/plandex/issues/77)
- Fix for occasional race condition during file builds that causes error "Fatal: Unable to write new index file"

================================================
FILE: releases/server/versions/0.9.0.md
================================================
- Support for custom models, model packs, and default models (see CLI 0.9.0 release notes for details).
- Better accuracy for updates to existing files.
- Plandex is less likely to screw up braces, parentheses, and other code structures.
- Plandex is less likely to mistakenly remove code that it shouldn't.
- Plandex is now much better at working through very long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.
- Server-side support for `plandex diff` command to show pending plan changes in `git diff` format.
- Server-side support for archiving and unarchiving plans.
- Server-side support for `plandex summary` command.
- Server-side support for `plandex rename` command.
- Descriptive top-line for `plandex apply` commit messages instead of just "applied pending changes".
- Better message in `plandex log` when a single piece of context is loaded or updated.
- Fixes for some rare potential deadlocks and conflicts when building a file or stopping astream.

================================================
FILE: releases/server/versions/0.9.1.md
================================================
- Improvements to auto-continue check. Plandex now does a better job determining whether a plan is finished or should automatically continue by incorporating the either the latest plan summary or the previous conversation message (if the summary isn't ready yet) into the auto-continue check. Previously the check was using only the latest conversation message.
- Fix for 'exit status 128' errors in a couple of edge case scenarios.
- Data that is piped into `plandex load` is now automatically given a name in `context ls` via a call to the `namer` role model (previously it had no name, making multiple pipes hard to disambiguate).

================================================
FILE: releases/server/versions/1.0.0.md
================================================
##   ☄️  🌅   gpt-4o is the real deal for coding

- gpt-4o, OpenAI's latest model, is the new default model for Plandex. 4o is much better than gpt-4-turbo (the previous default model) in early testing for coding tasks and agent workflows.
- If you have not used `plandex set-model` or `plandex set-model default` previously to set a custom model, you will now be use gpt-4o by default. If you *have* used one of those commands, use `plandex set-model` or `plandex set-model default` and select the new `gpt-4o-latest` model-pack to upgrade. 
 
##   🛰️  🏥   Reliability improvements: 90% reduction in syntax errors in early testing

- Automatic syntax and logic validation with an auto-correction step for file updates.
- Significantly improves reliability and reduces syntax errors, mistaken duplication or removal of code, placeholders that reference other code and other similar issues. 
- With a set of ~30 internal evals spanning 5 common languages, syntax errors were reduced by over 90% on average with gpt-4o. 
- Logical errors are also reduced (I'm still working on evals for those to get more precise numbers).
- Plandex is now much better at handling large files and plans that make many updates to the same file. Both could be problematic in previous versions.
- Plandex is much more resilient to incorrectly labelled file blocks when the model uses the file label format incorrectly to explain something rather than for a file. i.e. "Run this script" and then a bash script block. Previously Plandex would mistakenly create a file called "Run this script". It now ignores blocks like these.

##   🧠  🚞   Improvements to core planning engine: better memory and less laziness allow you to accomplish larger and more complex tasks without errors or stopping early

- Plandex is now much better at working through long plans without skipping tasks, repeating tasks it's already done, or otherwise losing track of what it's doing.
- Plandex is much less likely to leave TODO placeholders in comments instead of fully completing a task, or to otherwise leave a task incomplete.
- Plandex is much less likely to end a plan before all tasks are completed.

##   🏎️  📈   Performance improvements: 2x faster planning and execution

- gpt-4o is twice as fast as gpt-4-turbo for planning, summarization, builds, and more.
- If you find it's streaming too fast and you aren't able to review the output, try using the `--stop / -s` flag with `plandex tell` or `plandex continue`. It will stop the plan after a single response so you can review it before proceeding. Use `plandex continue` to proceed with the plan once you're ready.
- Speaking of which, if you're in exploratory mode and want to use less tokens, you can also use the `--no-build / -n` flag with `plandex tell` and `plandex continue`. This prevents Plandex from building files until you run `plandex build` manually.

##   💰  🪙   2x cost reduction: gpt-4o is half the per-token price of gpt-4-turbo

- For the same quantity of tokens, with improved quality and 2x speed, you'll pay half-price.

##   👩‍💻  🎭   New `plandex-dev` and `pdxd` alias in development mode

- In order to avoid conflicts/overwrites with the `plandex` CLI and `pdx` alias, a new `plandex-dev` command and `pdxd` alias have been added in development mode. 

##  🐛  🛠️   Bug fixes

- Fix for a potential panic during account creation (https://github.com/plandex-ai/plandex/issues/76)
- Fixes for some account creation flow issues (https://github.com/plandex-ai/plandex/issues/106)
- Fix for occasional "Stream buffer tokens too high" error (https://github.com/plandex-ai/plandex/issues/34).
- Fix for potential panic when updating model settings. Might possibly be the cause of or somehow related to https://github.com/plandex-ai/plandex/issues/121 but hard to be sure (maybe AWS was just being flakey).
- Attempted fix for rare git repo race condition @jesseswell_1 caught that gives error ending with: 
```
Exit status 128, output
      * Fatal: unable to write new_index file
```

##   📚  🤔   Readme updates

- The [readme](https://github.com/plandex-ai/plandex) has been revamped to be more informative and easier to navigate.

##  🏡  📦   Easy self-contained startup script for local mode and self-hosting

```bash
git clone https://github.com/plandex-ai/plandex.git
cd plandex/app
./start_local.sh
``` 

- Sincere thanks to @ZanzyTHEbar aka @daofficialwizard on Discord who wrote the script! 🙏🙏

##   🚀  ☝️   Upgrading   

- As always, cloud has already been updated with the latest version. To upgrade the CLI, run any `plandex` command (like `plandex version` or `plandex help` or whatever command you were about to run anyway 🙂)

##   💬  📆   Join me for office hours every Friday 12:30-1:30pm PST in Discord, starting May 17th

- I'll be available by voice and text chat to answer questions, talk about the new version, and hear about your use cases. Come on over and hang out! 
- Join the discord to get a reminder when office hours are starting: https://discord.gg/plandex-ai

================================================
FILE: releases/server/versions/1.0.1.md
================================================
- Fix for occasional 'Error getting verify state for file' error
- Fix for occasional 'Fatal: unable to write new_index file' error
- Fix for occasional 'nothing to commit, working tree clean' error
- When hitting OpenAI rate limits, Plandex will now parse error messages that include a recommended wait time and automatically wait that long before retrying, up to 30 seconds (https://github.com/plandex-ai/plandex/issues/123)
- Some prompt updates to encourage creation of multiple smaller files rather than one mega-file when generating files for a new feature or project. Multiple smaller files are faster to generate, use less tokens, and have a lower error rate compared to a continually updated large file.

================================================
FILE: releases/server/versions/1.1.0.md
================================================
- Give notes added to context with `plandex load -n 'some note'` automatically generated names in `context ls` list.
- Fixes for summarization and auto-continue issues that could Plandex to lose track of where it is in the plan and repeat tasks or do tasks out of order, especially when using `tell` and `continue` after the initial `tell`.
- Improvements to the verification and auto-fix step. Plandex is now more likely to catch and fix placeholder references like "// ... existing code ..." as well as incorrect removal or overwriting of code.
- After a context file is updated, Plandex is less likely to use an old version of the code from earlier in the conversation--it now uses the latest version much more reliably.
- Increase wait times when receiving rate limit errors from OpenAI API (common with new OpenAI accounts that haven't spent $50).

================================================
FILE: releases/server/versions/1.1.1.md
================================================
- Improvements to stream handling that greatly reduce flickering in the terminal when streaming a plan, especially when many files are being built simultaneously. CPU usage is also reduced on both the client and server side.
- Claude 3.5 Sonnet model and model pack (via OpenRouter.ai) is now built-in.

================================================
FILE: releases/server/versions/2.0.0+1.md
================================================
- Fix for custom model creation (https://github.com/plandex-ai/plandex/issues/214)
- Fix for version check on self-hosted (https://github.com/plandex-ai/plandex/issues/213)
- Fix for GitHub Action to build and push server image to DockerHub

================================================
FILE: releases/server/versions/2.0.0+2.md
================================================
- Version tag sanitation fix for GitHub Action to build and push server image to DockerHub


================================================
FILE: releases/server/versions/2.0.0.md
================================================
See CLI 2.0.0 release notes.

================================================
FILE: releases/server/versions/2.0.2.md
================================================
Server-side fix for context auto-load hanging when there's no valid context to load (for example, if they're all directories, which is only discovered client-side, and which can't be auto-loaded)

================================================
FILE: releases/server/versions/2.0.3.md
================================================
- Fix for potential crash during chat/tell operation.
- Panic handling to prevent crashes in general.
- Fix for local queue handling bug during builds that could cause queue to get stuck and cause subsequent operations to hang.

================================================
FILE: releases/server/versions/2.0.4.md
================================================
- **Stability**
  - Enhanced database locking mechanisms.
  - Improved error notifications.

- **API Enhancements**
  - Added endpoints for managing custom models and updating model packs.

- **Execution**
  - Increased robustness in plan execution and subprocess lifecycle management.

- **Observability**
  - Real-time internal notifications for critical errors implemented.

- **Consistency**
  - Improved token management.
  - Enhanced summarization accuracy.

================================================
FILE: releases/server/versions/2.0.5.md
================================================
- Fix for a bug that was causing occasional model errors. Model calls should be much more reliable now.
- Better error handling and error messages for model errors (rate limits or other errors).
- No error retries for rate limit errors.
- Fixed bug that caused retries to add the prompt to the conversation multiple times.
- Error responses with no output no longer create a log entry.

================================================
FILE: releases/server/versions/2.0.6.md
================================================
- Improvements to process management and cleanup for command execution
- Remove extraneous model request logging

================================================
FILE: releases/server/versions/2.1.0+1.md
================================================
- Fix for context length exceeded error that still wasn't being caught and retried by the fallback correctly.

================================================
FILE: releases/server/versions/2.1.0.md
================================================
See CLI 2.1.0 release notes.

================================================
FILE: releases/server/versions/2.1.1+1.md
================================================
- Improve error handling to catch yet another "context length exceeded" error message variation from Anthropic.

================================================
FILE: releases/server/versions/2.1.1.md
================================================
See CLI 2.1.1 release notes.

================================================
FILE: releases/server/versions/2.1.2.md
================================================
- Fix for auto-load context error: 'Error decoding response → EOF'

================================================
FILE: releases/server/versions/2.1.3.md
================================================
- Fix for 'panic in execTellPlan' error when using a model pack that doesn't explicitly set the 'coder' or 'whole-file-builder' roles

================================================
FILE: releases/server/versions/2.1.4.md
================================================
- Fix to remove occasional extraneous blank lines from start/end of edited files.

================================================
FILE: releases/server/versions/2.1.5.md
================================================
See CLI 2.1.5 release notes.

================================================
FILE: releases/server/versions/2.1.6+1.md
================================================
See CLI 2.1.6+1 release notes.

================================================
FILE: releases/server/versions/2.1.6.md
================================================
See CLI 2.1.6 release notes.

================================================
FILE: releases/server/versions/2.1.7.md
================================================
- Fix for "conversation summary timestamp not found in conversation" error (https://github.com/plandex-ai/plandex/issues/274)
- Fix for potential panic/crash during plan stream (https://github.com/plandex-ai/plandex/issues/275)
- Better protection against panics/crashes in server goroutines across the board

================================================
FILE: releases/server/versions/2.1.8.md
================================================
- Fix for potential hang in file map queue

================================================
FILE: releases/server/versions/2.2.0.md
================================================
See CLI 2.2.0 release notes.


================================================
FILE: releases/server/versions/2.2.1.md
================================================
See CLI 2.2.1 release notes.

================================================
FILE: scripts/merge_from_reflog.sh
================================================
#!/bin/bash

# Check if the correct number of arguments are provided
if [ "$#" -ne 2 ]; then
    echo "Usage: $0 <commit-hash> <branch-name>"
    exit 1
fi

# Get the commit hash and branch name from the arguments
commit_hash=$1
branch_name=$2

# Create and checkout a new branch
echo "Creating and checking out new branch: $branch_name"
git checkout -b "$branch_name"

# Generate the patch from the specified commit to HEAD
echo "Generating patch from commit $commit_hash to HEAD"
git format-patch -1 "$commit_hash" --stdout > changes.patch

# Apply the patch with the three-way merge option
echo "Applying patch..."
if git am --3way < changes.patch; then
    echo "Patch applied successfully"
else
    echo "Merge conflicts detected. Please resolve them manually."
    git status
    echo "After resolving conflicts, run the following commands to continue:"
    echo "  git add ."
    echo "  git am --continue"
fi

# Find all .rej files and process them
echo "Processing rejected patches..."
find . -name "*.rej" | while read -r rej_file; do
    # Extract the original file path
    original_file="${rej_file%.rej}"

    # Check if the original file exists
    if [ ! -f "$original_file" ]; then
        # If the original file does not exist, create it
        echo "Creating new file: $original_file"
        touch "$original_file"
    fi

    # Append the content of the .rej file to the original file
    echo "Applying rejected patch to $original_file"
    cat "$rej_file" >> "$original_file"

    # Remove the .rej file after applying the patch
    rm "$rej_file"
done

# Stage all changes
echo "Staging all changes..."
git add .

# Check for conflicts again, to ensure the manual changes are staged correctly
conflicts=$(git ls-files -u | wc -l)
if [ "$conflicts" -gt 0 ]; then
    echo "Merge conflicts detected. Please resolve them manually."
    git status
    echo "After resolving conflicts, run the following commands to commit the changes:"
    echo "  git add ."
    echo "  git commit -m 'Resolved merge conflicts from reflog commit $commit_hash'"
else
    # Commit the changes
    echo "Committing changes..."
    git commit -m "Merged changes from reflog commit $commit_hash, applied rejected patches and added missing files"
fi

# Clean up
echo "Cleaning up..."
rm changes.patch

echo "Done!"


================================================
FILE: test/_test_apply.sh
================================================
#! /bin/bash

set -euo pipefail

echo "Opening application in browser..."
plandex-dev browser "http://localhost:8765/error-test.html" || {
  echo "Browser command failed. Exiting."
  exit 1
}

# Check if python3 is available
# if command -v python3 &> /dev/null; then
#     echo "Starting HTTP server with Python 3..."
#     # Start a simple HTTP server on port 8765
#     python3 -m http.server 8765 &
#     SERVER_PID=$!
    
#     # Give the server a moment to start
#     sleep 1
    
#     # Open the browser to the application
#     echo "Opening application in browser..."
#     plandex-dev browser "http://localhost:8765/error-test.html"
#     echo "plandex-dev browser exit code: $?"
    
#     # If browser command fails, kill the server and exit
#     if [ $? -ne 0 ]; then
#         echo "Browser command failed. Killing server..."
#         kill $SERVER_PID
#         exit 1
#     fi
    
#     # Wait for the server process
#     wait $SERVER_PID
    
# # Check if python is available (for Python 2)
# elif command -v python &> /dev/null; then
#     echo "Starting HTTP server with Python 2..."
#     # Start a simple HTTP server on port 8765
#     python -m SimpleHTTPServer 8765 &
#     SERVER_PID=$!
    
#     # Give the server a moment to start
#     sleep 1
    
#     # Open the browser to the application
#     echo "Opening application in browser..."
#     plandex-dev browser "http://localhost:8765"
#     echo "plandex-dev browser exit code: $?"
    
#     # If browser command fails, kill the server and exit
#     if [ $? -ne 0 ]; then
#         echo "Browser command failed. Killing server..."
#         kill $SERVER_PID
#         exit 1
#     fi
    
#     # Wait for the server process
#     wait $SERVER_PID
    
# else
#     echo "Error: Python is not installed. Please install Python to run the HTTP server."
#     exit 1
# fi

================================================
FILE: test/error-test.html
================================================
<!DOCTYPE html>
<html>

<head>
  <title>Test JS Error</title>
</head>

<body>
  <h1>This page intentionally throws a JS error</h1>
  <script>
    // This will throw an unhandled error
    nonExistentFunction();
  </script>
</body>

</html>

================================================
FILE: test/evals/promptfoo-poc/README.md
================================================
# Test Driven Development of Prompts

This directory is dedicated to the systematic development of prompts for the plandex project. The prompts are developed in a test-driven manner, where the prompt is first written in a markdown file, and then the prompt is tested by running the prompt through the various evaluations. The output of the prompt is then graded and A/B tested for various metrics (see [metrics](#metrics)). The prompt is then iteratively improved until it meets the desired metrics.

We have decided to write the majority of the evals using the [promptfoo]() framework, as it is robust and contains customizations with a clear ease of setup.

## Usage

Usage will be broken down into [run](#run-evals) and [create](#create-evals) sections:

### Setup

To run or create evals, you will need to have the following installed:

- [Go](https://golang.org/)
- [Promptfoo]()

### Run Evals

To run the evaluations, you can cd into the relevant directory and use the following command:

```bash
make eval <name_of_eval_dir>
```

Or, you can run all the evaluations by running the following command:

```bash
make evals all
```

### Create Evals

To create the evaluations, you can use our `gen-*` commands. The `gen-*` commands are designed to setup the eval environment and will create the evaluations directory structure in the `evals/promptfoo` directory. You have access to the following commands:

```bash
make gen-eval # Generates the evaluation directory structure
make gen-provider # Generates a provider file based on the directory config files
```

> ![IMPORTANT]\
> Make sure to run the `gen-eval` command before running the `gen-provider` command.
> You need to have the config files filled out with your details before running the `gen-provider` command.
> Depending on the provider you use, you will need to setup an environment variable with the provider's API key.

## Metrics

The metrics we are currently tracking are:

> ![NOTE]\
> COMING SOON


================================================
FILE: test/evals/promptfoo-poc/build/assets/build/changes.md
================================================
### Subtask 1: Parse the range of indices from the command-line arguments.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}
```

### Subtask 2: Update the logic to handle the range of indices and mark the corresponding contexts for deletion.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for _, arg := range args {
		indices, err := parseRange(arg)
		if err != nil {
			term.OutputErrorAndExit("Error parsing range: %v", err)
		}

		for _, index := range indices {
			if index > 0 && index <= len(contexts) {
				context := contexts[index-1]
				deleteIds[context.Id] = true
			}
		}
	}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}
```

### Subtask 3: Update the `contextRm` function to include the new logic for handling ranges.


```
func init() {
	RootCmd.AddCommand(contextRmCmd)
}
```

================================================
FILE: test/evals/promptfoo-poc/build/assets/build/post_build.go
================================================
pdx-1: package cmd
pdx-2: 
pdx-3: import (
pdx-4: 	"fmt"
pdx-5: 	"path/filepath"
pdx-6: 	"plandex/api"
pdx-7: 	"plandex/auth"
pdx-8: 	"plandex/lib"
pdx-9: 	"plandex/term"
pdx-10: 	"strconv"
pdx-11: 	"strings"
pdx-12: 
pdx-13: 	"plandex-shared"
pdx-14: 	"github.com/spf13/cobra"
pdx-15: )
pdx-16: 
pdx-17: func parseRange(arg string) ([]int, error) {
pdx-18: 	var indices []int 
pdx-19: 	parts := strings.Split(arg, "-")
pdx-20: 	if len(parts) == 2 {
pdx-21: 		start, err := strconv.Atoi(parts[0])
pdx-22: 		if err != nil {
pdx-23: 			return nil, err
pdx-24: 		}
pdx-25: 		end, err := strconv.Atoi(parts[1])
pdx-26: 		if err != nil {
pdx-27: 			return nil, err
pdx-28: 		}
pdx-29: 		for i := start; i <= end; i++ {
pdx-30: 			indices = append(indices, i)
pdx-31: 		}
pdx-32: 	} else {
pdx-33: 		index, err := strconv.Atoi(arg)
pdx-34: 		if err != nil {
pdx-35: 			return nil, err
pdx-36: 		}
pdx-37: 		indices = append(indices, index)
pdx-38: 	}
pdx-39: 	return indices, nil
pdx-40: }
pdx-41: 
pdx-42: func contextRm(cmd *cobra.Command, args []string) {
pdx-43: 	auth.MustResolveAuthWithOrg()
pdx-44: 	lib.MustResolveProject()
pdx-45: 
pdx-46: 	if lib.CurrentPlanId == "" {
pdx-47: 		fmt.Println("🤷‍♂️ No current plan")
pdx-48: 		return
pdx-49: 	}
pdx-50: 
pdx-51: 	term.StartSpinner("")
pdx-52: 	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
pdx-53: 
pdx-54: 	if err != nil {
pdx-55: 		term.OutputErrorAndExit("Error retrieving context: %v", err)
pdx-56: 	}
pdx-57: 
pdx-58: 	deleteIds := map[string]bool{}
pdx-59: 
pdx-60: 	for _, arg := range args {
pdx-61: 		indices, err := parseRange(arg)
pdx-62: 		if err != nil {
pdx-63: 			term.OutputErrorAndExit("Error parsing range: %v", err)
pdx-64: 		}
pdx-65: 
pdx-66: 		for _, index := range indices {
pdx-67: 			if index > 0 && index <= len(contexts) {
pdx-68: 				context := contexts[index-1]
pdx-69: 				deleteIds[context.Id] = true
pdx-70: 			}
pdx-71: 		}
pdx-72: 	}
pdx-73: 
pdx-74: 	for i, context := range contexts {
pdx-75: 		for _, id := range args {
pdx-76: 			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
pdx-77: 				deleteIds[context.Id] = true
pdx-78: 				break
pdx-79: 			} else if context.FilePath != "" {
pdx-80: 				// Check if id is a glob pattern
pdx-81: 				matched, err := filepath.Match(id, context.FilePath)
pdx-82: 				if err != nil {
pdx-83: 					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
pdx-84: 				}
pdx-85: 				if matched {
pdx-86: 					deleteIds[context.Id] = true
pdx-87: 					break
pdx-88: 				}
pdx-89: 
pdx-90: 				// Check if id is a parent directory
pdx-91: 				parentDir := context.FilePath
pdx-92: 				for parentDir != "." && parentDir != "/" && parentDir != "" {
pdx-93: 					if parentDir == id {
pdx-94: 						deleteIds[context.Id] = true
pdx-95: 						break
pdx-96: 					}
pdx-97: 					parentDir = filepath.Dir(parentDir) // Move up one directory
pdx-98: 				}
pdx-99: 			}
pdx-100: 		}
pdx-101: 	}
pdx-102: 
pdx-103: 	if len(deleteIds) > 0 {
pdx-104: 		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
pdx-105: 			Ids: deleteIds,
pdx-106: 		})
pdx-107: 		term.StopSpinner()
pdx-108: 
pdx-109: 		if err != nil {
pdx-110: 			term.OutputErrorAndExit("Error deleting context: %v", err)
pdx-111: 		}
pdx-112: 
pdx-113: 		fmt.Println("✅ " + res.Msg)
pdx-114: 	} else {
pdx-115: 		term.StopSpinner()
pdx-116: 		fmt.Println("🤷‍♂️ No context removed")
pdx-117: 	}
pdx-118: }
pdx-119: 
pdx-120: func init() {
pdx-121: 	RootCmd.AddCommand(contextRmCmd)
pdx-122: }
pdx-123: 

================================================
FILE: test/evals/promptfoo-poc/build/assets/shared/pre_build.go
================================================
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"

	"plandex-shared"
	"github.com/spf13/cobra"
)

var contextRmCmd = &cobra.Command{
	Use:     "rm",
	Aliases: []string{"remove", "unload"},
	Short:   "Remove context",
	Long:    `Remove context by index, name, or glob.`,
	Args:    cobra.MinimumNArgs(1),
	Run:     contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}

func init() {
	RootCmd.AddCommand(contextRmCmd)
}


================================================
FILE: test/evals/promptfoo-poc/build/build.config.properties
================================================
provider_id=openai:gpt-4o
temperature=0.1
max_tokens=4096
top_p=0.1
response_format=json_object
function_name=listChangesWithLineNums
tool_type=function
function_param_type=object
tool_choice_type=function
tool_choice_function_name=listChangesWithLineNums
nested_parameters_json=build.parameters.json


================================================
FILE: test/evals/promptfoo-poc/build/build.parameters.json
================================================
{
  "type": "object",
  "properties": {
    "comments": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "txt": {
            "type": "string"
          },
          "reference": {
            "type": "boolean"
          }
        },
        "required": ["txt", "reference"]
      }
    },
    "filePath": {
      "type": "string"
    },
    "changes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "summary": {
            "type": "string"
          },
          "hasChange": {
            "type": "boolean"
          },
          "old": {
            "type": "object",
            "properties": {
              "entireFile": {
                "type": "boolean"
              },
              "startLineString": {
                "type": "string"
              },
              "endLineString": {
                "type": "string"
              }
            },
            "required": ["startLineString", "endLineString"]
          },
          "startLineIncludedReasoning": {
            "type": "string"
          },
          "startLineIncluded": {
            "type": "boolean"
          },
          "endLineIncludedReasoning": {
            "type": "string"
          },
          "endLineIncluded": {
            "type": "boolean"
          },
          "new": {
            "type": "string"
          }
        },
        "required": [
          "summary",
          "hasChange",
          "old",
          "startLineIncludedReasoning",
          "startLineIncluded",
          "endLineIncludedReasoning",
          "endLineIncluded",
          "new"
        ]
      }
    }
  },
  "required": ["comments", "filePath", "changes"]
}


================================================
FILE: test/evals/promptfoo-poc/build/build.prompt.txt
================================================
You are an AI that analyzes a code file and an AI-generated plan to update the code file and produces a list of changes.

[YOUR INSTRUCTIONS]

Call the 'listChangesWithLineNums' function with a valid JSON object that includes the 'comments', 'problems', and 'changes' keys.

You ABSOLUTELY MUST NOT generate overlapping changes. Group smaller changes together into larger changes where necessary to avoid overlap. Only generate multiple changes when you are ABSOLUTELY CERTAIN that they do not overlap--otherwise group them together into a single change. If changes are close to each other (within several lines), group them together into a single change. You MUST group changes together and make fewer, larger changes rather than many small changes, unless the changes are completely independent of each other and not close to each other in the file. You MUST NEVER generate changes that are adjacent or close to adjacent. Adjacent or closely adjacent changes MUST ALWAYS be grouped into a single larger change.

Furthermore, unless doing so would require a very large change because some changes are far apart in the file, it's ideal to call the 'listChangesWithLineNums' with just a SINGLE change.

Changes must be ordered in the array according to the order they appear in the file. The 'startLineString' of each 'old' property must come after the 'endLineString' of the previous 'old' property. Changes MUST NOT overlap. If a change is dependent on another change or intersects with it, group those changes together into a single change.

You MUST NOT repeat changes to the same block of lines multiple teams. You MUST NOT duplicate changes. It is extremely important that a given change is only applied *once*.

The 'comments' key is an array of objects with two properties: 'txt' and 'reference'. 'txt' is the exact text of a code comment. 'reference' is a boolean that indicates whether the comment is a placeholder of or reference to the original code, like "// rest of the function..." or "# existing init code...", or "// rest of the main function" or "// rest of your function..." or "// Existing methods..." or "// Remaining methods" or "// Existing code..." or "// ... existing setup code ..." or "// ... existing code ..." or "// ..." or other comments which reference code from the original file. References DO NOT need to exactly match any of the previous examples. Use your judgement to determine whether each comment is a reference. If 'reference' is true, the comment is a placeholder or reference to the original code. If 'reference' is false, the comment is not a placeholder or reference to the original code.

In 'comments', you must list EVERY comment included in the proposed updates. Only list *code comments* that are valid comments for the programming language being used. Do not list logging statements or any other non-comment text that is not a valid code comment. If there are no code comments in the proposed updates, 'comments' must be an empty array.

If there are multiple identical comments in the proposed updates, you MUST list them *all* in the 'comments' array--list each identical comment as a separate object in the array.

In the 'problems' key, you MUST explain how you will strategically generate changes in order to avoid any problems in the updated file. You should explain which changes you will make and how you will *avoid* making any overlapping or invalid changes. Consider whether any changes are close together or whether any change is potentially contained by another. If so, group those changes together into a single change.

You must consider whether you will apply partial changes or replace the entire file. If the original file is long, you MUST NOT replace the entire file with a single change. Instead, you should apply changes to specific sections of the file. If the original file is short and the changes are complex, you may consider replacing the entire file with a single change.

You must consider how you will avoid *incorrectly removing or overwriting code* from the original file. Explain whether any code from the original file needs to be merged with the proposed updates in order to avoid removing or overwriting code that should not be removed. It is ABSOLUTELY CRITICAL that no pre-existing code or functionality is removed or overwritten unless the plan explicitly intends for it to be removed or overwritten. New code and functionality introduced in the proposed updates MUST be *merged* with existing code and functionality in the original file. Explain how you will achieve this. 

You must consider how you will avoid including any references in the updated file if any are present in the proposed updates. 

You must consider how you will *avoid incorrect duplication* in making your changes. For example if a 'main' function is present in the original file and the proposed updates include update code for the 'main' function, you must ensure the changes are applied within the existing 'main' function rather than incorrectly adding a duplicate 'main' function.

If the proposed updates include large sections that are identical to the original file, consider whether the changes can be made more minimal in order to only replace sections of code that are *changing*. If you are making the changes more minimal and specific, explain how you will do this without generating any overlapping changes or introducing any new problems.

'changes': An array of NON-OVERLAPPING changes. Each change is an object with properties: 'summary', 'hasChange', 'old', 'startLineIncludedReasoning', 'startLineIncluded', 'endLineIncludedReasoning', 'endLineIncluded', and 'new'.

Note: all line numbers that are used below are prefixed with 'pdx-', like this 'pdx-5: for i := 0; i < 10; i++ {'. This is to help you identify the line numbers in the file. You *must* include the 'pdx-' prefix in the line numbers in the 'old' property.

The 'summary' property is a brief summary of the change. At the end of the summary, consider if this change will overlap with any ensuing changes. If it will, include those changes in *this* change instead. Continue the summary and includes those ensuing changes that would otherwise overlap. Changes that remove code are especially likely to overlap with ensuing changes. 

'summary' examples: 
	- 'Update loop that aggregates the results to iterate 10 times instead of 5 and log the value of someVar.'
	- 'Update the Org model to include StripeCustomerId and StripeSubscriptionId fields.'
	- 'Add function ExecQuery to execute a query.'
	
'summary' that is larger to avoid overlap:
	- 'Insert function ExecQuery after GetResults function in loop body. Update loop that aggregates the results to iterate 10 times instead of 5 and log the value of someVar. Add function ExecQuery to execute a query.'

The 'hasChange' property is a boolean that indicates whether there is anything to change. If there is nothing to change, set 'hasChange' to false. If there is something to change, set 'hasChange' to true.

The 'old' property is an object with 3 properties: 'entireFile', 'startLineString' and 'endLineString'.

	'entireFile' is a boolean that indicates whether the **entire file** is being replaced. If 'entireFile' is true, 'startLineString' and 'endLineString' must be empty strings. If 'entireFile' is false, 'startLineString' and 'endLineString' must be valid strings that exactly match lines from the original file. If 'entireFile' is false, 'startLineString' and 'endLineString' MUST NEVER be empty strings.

	'startLineString' is the **entire, exact line** where the section to be replaced begins in the original file, including the line number. Unless it's the first change, 'startLineString' ABSOLUTELY MUST begin with a line number that is HIGHER than both the 'endLineString' of the previous change and the 'startLineString' of the previous change. **The line number and line MUST EXACTLY MATCH a line from the original file.**
	
	If the previous change's 'endLineString' starts with 'pdx-75: ', then the current change's 'startLineString' MUST start with 'pdx-76: ' or higher. It MUST NOT be 'pdx-75: ' or lower. If the previous change's 'startLineString' starts with 'pdx-88: ' and the previous change's 'endLineString' is an empty string, then the current change's 'startLineString' MUST start with 'pdx-89: ' or higher. If the previous change's 'startLineString' starts with 'pdx-100: ' and the previous change's 'endLineString' starts with 'pdx-105: ', then the current change's 'startLineString' MUST start with 'pdx-106: ' or higher.
	
	'endLineString' is the **entire, exact line** where the section to be replaced ends in the original file. Pay careful attention to spaces and indentation. 'startLineString' and 'endLineString' must be *entire lines* and *not partial lines*. Even if a line is very long, you must include the entire line, including the line number and all text on the line. **The line number and line MUST EXACTLY MATCH a line from the original file.**
	
	**For a single line replacement, 'endLineString' MUST be an empty string.**

	'endLineString' MUST ALWAYS come *after* 'startLineString' in the original file. It must start with a line number that is HIGHER than the 'startLineString' line number. If 'startLineString' starts with 'pdx-22: ', then 'endLineString' MUST either be an empty string (for a single line replacement) or start with 'pdx-23: ' or higher (for a multi-line replacement).	

	If 'hasChange' is false, both 'startLineString' and 'endLineString' must be empty strings. If 'hasChange' is true, 'startLineString' and 'endLineString' must be valid strings that exactly match lines from the original file. If 'hasChange' is true, 'startLineString' and 'endLineString' MUST NEVER be empty strings.

	If you are replacing the entire file, 'startLineString' MUST be the first line of the original file and 'endLineString' MUST be the last line of the original file.

The 'startLineIncludedReasoning' property is a string that very briefly explains whether 'startLineString' should be included in the 'new' property. For example, if the 'startLineString' is the closing bracket of a function and you are adding another function after it, you *MUST* include the 'startLineString' in the 'new' property, or the previous function will lose its closing bracket when the change is applied. Similarly, if the 'startLineString' is a function definition and you are updating the body of the function, you *MUST* also include 'startLineString' so that they function definition is not removed. The only time 'startLineString' should not be included in 'new' is if it is a line that should be removed or replaced. Generalize the above to all types of code blocks, changes, and syntax to ensure the 'new' property will not remove or overwrite code that should not be removed or overwritten. That also includes newlines, line breaks, and indentation.

'startLineIncluded' is a boolean that indicates whether 'startLineString' should be included in the 'new' property. If 'startLineIncluded' is true, 'startLineString' MUST be included in the 'new' property. If 'startLineIncluded' is false, 'startLineString' MUST not be included in the 'new' property.

The 'endLineIncludedReasoning' property is a string that very briefly explains whether 'endLineString' should be included in the 'new' property. For example, if the 'endLineString' is the opening bracket of a function and you are adding another function before it, you *MUST* include the 'endLineString' in the 'new' property, or the subsequent function will lose its opening bracket when the change is applied. Similarly, if the 'endLineString' is the closing bracket of a function and you are updating the body of the function, you *MUST* also include 'endLineString' so that the closing bracket not removed. The only time 'endLineString' should not be included in 'new' is if it is a line that should be removed or replaced. Generalize the above to all types of code blocks, changes, and syntax to ensure the 'new' property will not remove or overwrite code that should not be removed or overwritten. That also includes newlines, line breaks, and indentation.

'endLineIncluded' is a boolean that indicates whether 'endLineString' should be included in the 'new' property. If 'endLineIncluded' is true, 'endLineString' MUST be included in the 'new' property. If 'endLineIncluded' is false, 'endLineString' MUST not be included in the 'new' property.

The 'new' property is a string that represents the new code that will replace the old code. The new code must be valid and consistent with the intention of the plan. If the proposed update is to remove code, the 'new' property should be an empty string. Be precise about newlines, line breaks, and indentation. 'new' must include only full lines of code and *no partial lines*. Do NOT include line numbers in the 'new' property.

If the proposed update includes references to the original code in comments like "// rest of the function..." or "# existing init code...", or "// rest of the main function..." or "// rest of your function..." or **any other reference to the original code,** you *MUST* ensure that the comment making the reference is *NOT* included in the 'new' property. Instead, include the **exact code** from the original file that the comment is referencing. Do not be overly strict in identifying references. If there is a comment that seems like it could plausibly be a reference and there is code in the original file that could plausibly be the code being referenced, then treat that as a reference and handle it accordingly by including the code from the original file in the 'new' property instead of the comment. YOU MUST NOT MISS ANY REFERENCES.

If the 'startLineIncluded' property is true, the 'startLineString' MUST be the first line of 'new'. If the 'startLineIncluded' property is false, the 'startLineString' MUST NOT be included in 'new'. If the 'endLineIncluded' property is true, the 'endLineString' MUST be the last line of 'new'. If the 'endLineIncluded' property is false, the 'endLineString' MUST NOT be included in 'new'.

If the 'hasChange' property is false, the 'new' property must be an empty string. If the 'hasChange' property is true, the 'new' property must be a valid string.

If *any* change has the 'entireFile' key in the 'old' property set to true, the corresponding 'new' key MUST be the entire updated file, and there MUST only be a single change in the 'changes' array.

Example change object:

```json
  {
    summary: "Fix syntax error in loop body.",
   	old: {
      startLineString: "pdx-5: for i := 0; i < 10; i++ { ",
      endLineString: "pdx-7: }"
    },
    new: "for i := 0; i < 10; i++ {\n  execQuery()\n  }\n  }\n}"
  }
```


Apply changes intelligently **in order** to avoid syntax errors, breaking code, or removing code from the original file that should not be removed. Consider the reason behind the update and make sure the result is consistent with the intention of the plan.

Changes MUST be ordered based on their position in the original file. ALWAYS go from top to bottom IN ORDER when generating replacements. DO NOT EVER GENERATE AN OVERLAPPING CHANGE. If a change would fall within OR overlap a prior change in the list, SKIP that change and move on to the next one.

You ABSOLUTELY MUST NOT overwrite or delete code from the original file unless the plan *clearly intends* for the code to be overwritten or removed. Do NOT replace a full section of code with only new code unless that is the clear intention of the plan. Instead, merge the original code and the proposed updates together intelligently according to the intention of the plan. 

Pay *EXTREMELY close attention* to opening and closing brackets, parentheses, and braces. Never leave them unbalanced when the changes are applied. Also pay *EXTREMELY close attention* to newlines and indentation. Make sure that the indentation of the new code is consistent with the indentation of the original code, and syntactically correct.

The 'listChangesWithLineNums' function MUST be called *valid JSON*. Double quotes within json properties of the 'listChangesWithLineNums' function call parameters JSON object *must be properly escaped* with a backslash. Pay careful attention to newlines, tabs, and other special characters. The JSON object must be properly formatted and must include all required keys. **You generate perfect JSON -every- time**, no matter how many quotes or special characters are in the input. You must always call 'listChangesWithLineNums' with a valid JSON object. Don't call any other function.

[END YOUR INSTRUCTIONS]


**The current file is {{filePath}} Original state of the file:**

```
{{preBuildState}}
```

Proposed updates:

{{changes}}


Now call the 'listChangesWithLineNums' function with a valid JSON array of changes according to your instructions. You must always call 'listChangesWithLineNums' with one or more valid changes. Don't call any other function.

================================================
FILE: test/evals/promptfoo-poc/build/build.provider.yml
================================================
id: openai:gpt-4o
config:
  temperature: 0.1
  max_tokens: 4096
  response_format: { type: json_object }
  top_p: 0.1
  tools:
    [
      {
        "type": "function",
        "function":
          {
            "name": "listChangesWithLineNums",
            "parameters":
              {
                "properties":
                  {
                    "changes":
                      {
                        "items":
                          {
                            "properties":
                              {
                                "endLineIncluded": { "type": "boolean" },
                                "endLineIncludedReasoning":
                                  { "type": "string" },
                                "hasChange": { "type": "boolean" },
                                "new": { "type": "string" },
                                "old":
                                  {
                                    "properties":
                                      {
                                        "endLineString": { "type": "string" },
                                        "entireFile": { "type": "boolean" },
                                        "startLineString": { "type": "string" },
                                      },
                                    "required":
                                      ["startLineString", "endLineString"],
                                    "type": "object",
                                  },
                                "startLineIncluded": { "type": "boolean" },
                                "startLineIncludedReasoning":
                                  { "type": "string" },
                                "summary": { "type": "string" },
                              },
                            "required":
                              [
                                "summary",
                                "hasChange",
                                "old",
                                "startLineIncludedReasoning",
                                "startLineIncluded",
                                "endLineIncludedReasoning",
                                "endLineIncluded",
                                "new",
                              ],
                            "type": "object",
                          },
                        "type": "array",
                      },
                    "comments":
                      {
                        "items":
                          {
                            "properties":
                              {
                                "reference": { "type": "boolean" },
                                "txt": { "type": "string" },
                              },
                            "required": ["txt", "reference"],
                            "type": "object",
                          },
                        "type": "array",
                      },
                    "filePath": { "type": "string" },
                  },
                "required": ["comments", "filePath", "changes"],
                "type": "object",
              },
          },
      },
    ]
  tool_choice:
    type: "function"
    function:
      name: "listChangesWithLineNums"


================================================
FILE: test/evals/promptfoo-poc/build/promptfooconfig.yaml
================================================
description: "build"

prompts:
  - file://build.prompt.txt
providers:
  - file://build.provider.yml
tests: tests/*.test.yml


================================================
FILE: test/evals/promptfoo-poc/build/tests/build.test.yml
================================================
- description: "Check Build with Line numbers"
  vars:
    preBuildState: file://assets/shared/pre_build.go
    changes: file://assets/build/changes.md
    filePath: parse.go
    postBuildState: file://assets/build/post_build.go
  assert:
    - type: is-json
    - type: is-valid-openai-tools-call
    - type: javascript
      value: |
        var args = JSON.parse(output[0].function.arguments)
        return ( 
          args.changes.length > 0 &&
          args.changes.some(
            change => change.hasChange && 
                      change.new.includes("var contextRmCmd = &cobra.Command{")
          )
        )


================================================
FILE: test/evals/promptfoo-poc/evals.md
================================================
# Evals

Evals for plandex.

## Overview

`Classification:`

- MCC
- Specificity
- Sensitivity
- Accuracy

`Regression:`

- RMSE
- R2
- MSE

## Types of Evals

---

### Build Prompts Evaluations

1. **Syntax Check**
   - Ensure the prompt is syntactically correct and follows the required format.
2. **Completeness Check**
   - Verify that all necessary components (e.g., headers, body, footers) are included.
3. **Clarity and Precision**
   - Evaluate if the instructions are clear and unambiguous.
4. **Context Appropriateness**
   - Assess if the prompt is appropriate for the intended context and audience.
5. **Error Handling**
   - Check if there are adequate instructions for handling potential errors.
6. **Dependency Evaluation**
   - Ensure all dependencies (libraries, tools) are correctly specified.
7. **Output Validation**
   - Define criteria to validate the expected output.

### Verify Prompts Evaluations

1. **Accuracy Check**
   - Ensure the prompt's instructions lead to the correct and intended results.
2. **Validation Criteria**
   - Define and check the validation criteria for the outputs.
3. **Consistency Check**
   - Verify if the prompt maintains consistency in terminology and steps.
4. **Logic and Flow**
   - Evaluate the logical flow of the instructions to ensure they are coherent.
5. **Edge Cases Handling**
   - Assess if the prompt considers and handles edge cases effectively.
6. **User Feedback Integration**
   - Ensure there are provisions for incorporating user feedback.
7. **Performance Metrics**
   - Define and evaluate the performance metrics for the verification process.

### Fix Prompts Evaluations

1. **Error Identification**
   - Ensure the prompt accurately identifies the errors to be fixed.
2. **Correctness of Fix**
   - Verify that the proposed fix is correct and resolves the issue.
3. **Impact Analysis**
   - Assess the impact of the fix on the overall system or application.
4. **Regression Testing**
   - Ensure that the fix does not introduce new issues or regressions.
5. **Documentation Update**
   - Check if the documentation is updated to reflect the fix.
6. **Code Quality**
   - Evaluate the quality of the code after the fix (e.g., readability, maintainability).
7. **Performance Impact**
   - Assess if the fix affects the performance and ensure it remains optimal.

### Function Call Schemas Evaluations

1. **Schema Validity**
   - Ensure the schema is valid and conforms to the defined standards.
2. **Parameter Consistency**
   - Verify that the parameters are consistently defined and used.
3. **Return Type Verification**
   - Ensure the return types are correctly specified and handled.
4. **Error Handling Mechanism**
   - Assess the error handling mechanisms in the schema.
5. **Compatibility Check**
   - Check if the schema is compatible with different environments or systems.
6. **Documentation Completeness**
   - Ensure the schema is well-documented with clear explanations of each parameter and return type.
7. **Security Considerations**
   - Evaluate the schema for potential security vulnerabilities or risks.


================================================
FILE: test/evals/promptfoo-poc/fix/assets/removal/changes.md
================================================
### Subtask 1: Parse the range of indices from the command-line arguments.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}
```

### Subtask 2: Update the logic to handle the range of indices and mark the corresponding contexts for deletion.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for _, arg := range args {
		indices, err := parseRange(arg)
		if err != nil {
			term.OutputErrorAndExit("Error parsing range: %v", err)
		}

		for _, index := range indices {
			if index > 0 && index <= len(contexts) {
				context := contexts[index-1]
				deleteIds[context.Id] = true
			}
		}
	}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}
```

### Subtask 3: Update the `contextRm` function to include the new logic for handling ranges.


```
func init() {
	RootCmd.AddCommand(contextRmCmd)
}
```

================================================
FILE: test/evals/promptfoo-poc/fix/assets/removal/post_build.go
================================================
pdx-1: package cmd
pdx-2: 
pdx-3: import (
pdx-4: 	"fmt"
pdx-5: 	"path/filepath"
pdx-6: 	"plandex/api"
pdx-7: 	"plandex/auth"
pdx-8: 	"plandex/lib"
pdx-9: 	"plandex/term"
pdx-10: 	"strconv"
pdx-11: 	"strings"
pdx-12: 
pdx-13: 	"plandex-shared"
pdx-14: 	"github.com/spf13/cobra"
pdx-15: )
pdx-16: 
pdx-17: func parseRange(arg string) ([]int, error) {
pdx-18: 	var indices []int 
pdx-19: 	parts := strings.Split(arg, "-")
pdx-20: 	if len(parts) == 2 {
pdx-21: 		start, err := strconv.Atoi(parts[0])
pdx-22: 		if err != nil {
pdx-23: 			return nil, err
pdx-24: 		}
pdx-25: 		end, err := strconv.Atoi(parts[1])
pdx-26: 		if err != nil {
pdx-27: 			return nil, err
pdx-28: 		}
pdx-29: 		for i := start; i <= end; i++ {
pdx-30: 			indices = append(indices, i)
pdx-31: 		}
pdx-32: 	} else {
pdx-33: 		index, err := strconv.Atoi(arg)
pdx-34: 		if err != nil {
pdx-35: 			return nil, err
pdx-36: 		}
pdx-37: 		indices = append(indices, index)
pdx-38: 	}
pdx-39: 	return indices, nil
pdx-40: }
pdx-41: 
pdx-42: func contextRm(cmd *cobra.Command, args []string) {
pdx-43: 	auth.MustResolveAuthWithOrg()
pdx-44: 	lib.MustResolveProject()
pdx-45: 
pdx-46: 	if lib.CurrentPlanId == "" {
pdx-47: 		fmt.Println("🤷‍♂️ No current plan")
pdx-48: 		return
pdx-49: 	}
pdx-50: 
pdx-51: 	term.StartSpinner("")
pdx-52: 	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
pdx-53: 
pdx-54: 	if err != nil {
pdx-55: 		term.OutputErrorAndExit("Error retrieving context: %v", err)
pdx-56: 	}
pdx-57: 
pdx-58: 	deleteIds := map[string]bool{}
pdx-59: 
pdx-60: 	for _, arg := range args {
pdx-61: 		indices, err := parseRange(arg)
pdx-62: 		if err != nil {
pdx-63: 			term.OutputErrorAndExit("Error parsing range: %v", err)
pdx-64: 		}
pdx-65: 
pdx-66: 		for _, index := range indices {
pdx-67: 			if index > 0 && index <= len(contexts) {
pdx-68: 				context := contexts[index-1]
pdx-69: 				deleteIds[context.Id] = true
pdx-70: 			}
pdx-71: 		}
pdx-72: 	}
pdx-73: 
pdx-74: 	for i, context := range contexts {
pdx-75: 		for _, id := range args {
pdx-76: 			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
pdx-77: 				deleteIds[context.Id] = true
pdx-78: 				break
pdx-79: 			} else if context.FilePath != "" {
pdx-80: 				// Check if id is a glob pattern
pdx-81: 				matched, err := filepath.Match(id, context.FilePath)
pdx-82: 				if err != nil {
pdx-83: 					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
pdx-84: 				}
pdx-85: 				if matched {
pdx-86: 					deleteIds[context.Id] = true
pdx-87: 					break
pdx-88: 				}
pdx-89: 
pdx-90: 				// Check if id is a parent directory
pdx-91: 				parentDir := context.FilePath
pdx-92: 				for parentDir != "." && parentDir != "/" && parentDir != "" {
pdx-93: 					if parentDir == id {
pdx-94: 						deleteIds[context.Id] = true
pdx-95: 						break
pdx-96: 					}
pdx-97: 					parentDir = filepath.Dir(parentDir) // Move up one directory
pdx-98: 				}
pdx-99: 			}
pdx-100: 		}
pdx-101: 	}
pdx-102: 
pdx-103: 	if len(deleteIds) > 0 {
pdx-104: 		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
pdx-105: 			Ids: deleteIds,
pdx-106: 		})
pdx-107: 		term.StopSpinner()
pdx-108: 
pdx-109: 		if err != nil {
pdx-110: 			term.OutputErrorAndExit("Error deleting context: %v", err)
pdx-111: 		}
pdx-112: 
pdx-113: 		fmt.Println("✅ " + res.Msg)
pdx-114: 	} else {
pdx-115: 		term.StopSpinner()
pdx-116: 		fmt.Println("🤷‍♂️ No context removed")
pdx-117: 	}
pdx-118: }
pdx-119: 
pdx-120: func init() {
pdx-121: 	RootCmd.AddCommand(contextRmCmd)
pdx-122: }
pdx-123: 

================================================
FILE: test/evals/promptfoo-poc/fix/assets/removal/problems.txt
================================================
The command definition for 'contextRmCmd' was incorrectly removed. The proposed updates did not specify this removal, and it breaks the functionality of the command. To correct this, the command definition should be re-added to the updated file.

================================================
FILE: test/evals/promptfoo-poc/fix/assets/shared/pre_build.go
================================================
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"

	"github.com/spf13/cobra"
)

var contextRmCmd = &cobra.Command{
	Use:     "rm",
	Aliases: []string{"remove", "unload"},
	Short:   "Remove context",
	Long:    `Remove context by index, name, or glob.`,
	Args:    cobra.MinimumNArgs(1),
	Run:     contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}

func init() {
	RootCmd.AddCommand(contextRmCmd)
}


================================================
FILE: test/evals/promptfoo-poc/fix/fix.config.properties
================================================
provider_id=openai:gpt-4o
temperature=0.1
max_tokens=4096
top_p=0.1
response_format=json_object
function_name=listChangesWithLineNums
tool_type=function
function_param_type=object
tool_choice_type=function
tool_choice_function_name=listChangesWithLineNums
nested_parameters_json=fix.parameters.json


================================================
FILE: test/evals/promptfoo-poc/fix/fix.parameters.json
================================================
{
  "type": "object",
  "properties": {
    "comments": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "txt": {
            "type": "string"
          },
          "reference": {
            "type": "boolean"
          }
        },
        "required": ["txt", "reference"]
      }
    },
    "problems": {
      "type": "string"
    },
    "changes": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "summary": {
            "type": "string"
          },
          "hasChange": {
            "type": "boolean"
          },
          "old": {
            "type": "object",
            "properties": {
              "entireFile": {
                "type": "boolean"
              },
              "startLineString": {
                "type": "string"
              },
              "endLineString": {
                "type": "string"
              }
            },
            "required": ["startLineString", "endLineString"]
          },
          "startLineIncludedReasoning": {
            "type": "string"
          },
          "startLineIncluded": {
            "type": "boolean"
          },
          "endLineIncludedReasoning": {
            "type": "string"
          },
          "endLineIncluded": {
            "type": "boolean"
          },
          "new": {
            "type": "string"
          }
        },
        "required": [
          "summary",
          "hasChange",
          "old",
          "startLineIncludedReasoning",
          "startLineIncluded",
          "endLineIncludedReasoning",
          "endLineIncluded",
          "new"
        ]
      }
    }
  },
  "required": ["comments", "problems", "changes"]
}


================================================
FILE: test/evals/promptfoo-poc/fix/fix.prompt.txt
================================================
You are an AI that analyzes an original file (if present), an incorrectly updated file, the changes that were proposed, and a description of the problems with the file, and then produces a list of changes to apply to the *incorrectly updated file* that will fix *ALL* the problems.

Problems you MUST fix include:
- Syntax errors, including unbalanced brackets, parentheses, braces, quotes, indentation, and other code structure errors
- Missing or incorrectly scoped declarations
- Any other errors that make the code invalid and would prevent it from being run as-is for the programming language being used
- Incorrectly applied changes
- Incorrectly removed code
- Incorrectly overwritten code
- Incorrectly duplicated code
- Incorrectly applied comments that reference the original code

If the updated file includes references to the original code in comments like "// rest of the function..." or "# existing init code...", or "// rest of the main function..." or "// rest of your function..." or "// Existing methods..." **any other reference to the original code, the file is incorrect. References like these must be handled by including the exact code from the original file that the comment is referencing.

[YOUR INSTRUCTIONS]
Call the 'listChangesWithLineNums' function with a valid JSON object that includes the 'comments','problems' and 'changes' keys.

The 'comments' key is an array of objects with two properties: 'txt' and 'reference'. 'txt' is the exact text of a code comment. 'reference' is a boolean that indicates whether the comment is a placeholder of or reference to the original code, like "// rest of the function..." or "# existing init code...", or "// rest of the main function" or "// rest of your function..." or "// Existing methods..." or "// Remaining methods" or "// Existing code..." or "// ... existing setup code ..."" or other comments which reference code from the original file. References DO NOT need to exactly match any of the previous examples. Use your judgement to determine whether each comment is a reference. If 'reference' is true, the comment is a placeholder or reference to the original code. If 'reference' is false, the comment is not a placeholder or reference to the original code.

In 'comments', you must list EVERY comment included in the proposed updates. Only list *code comments* that are valid comments for the programming language being used. Do not list logging statements or any other non-comment text that is not a valid code comment. If there are no code comments in the proposed updates, 'comments' must be an empty array.

If there are multiple identical comments in the proposed updates, you MUST list them *all* in the 'comments' array--list each identical comment as a separate object in the array.

'problems': A string that describes all problems present within the updated file. Explain the cause of each problem and how it should be fixed. Do not just restate that there is a syntax error on a specific line. Explain what the syntax error is and how to fix it. Be exhaustive and include *every* problem that is present in the file.

Since you are fixing an incorrectly updated file, you *MUST* include the 'problems' key and you *MUST* describe *all* problems present in the file. If you cannot identify any problems immediately, output a few hypotheses about what might be wrong and then explain which of them are actually present in the file. The file definitely does have problems, so you *must* identify them.

'changes': An array of NON-OVERLAPPING changes. Each change is an object with properties: 'summary', 'hasChange', 'old', 'startLineIncludedReasoning', 'startLineIncluded', 'endLineIncludedReasoning', 'endLineIncluded', and 'new'.

Note: all line numbers that are used below are prefixed with 'pdx-', like this 'pdx-5: for i := 0; i < 10; i++ {'. This is to help you identify the line numbers in the file. You *must* include the 'pdx-' prefix in the line numbers in the 'old' property.

The 'summary' property is a brief summary of the change. At the end of the summary, consider if this change will overlap with any ensuing changes. If it will, include those changes in *this* change instead. Continue the summary and includes those ensuing changes that would otherwise overlap. Changes that remove code are especially likely to overlap with ensuing changes. 

'summary' examples: 
	- 'Update loop that aggregates the results to iterate 10 times instead of 5 and log the value of someVar.'
	- 'Update the Org model to include StripeCustomerId and StripeSubscriptionId fields.'
	- 'Add function ExecQuery to execute a query.'
	
'summary' that is larger to avoid overlap:
	- 'Insert function ExecQuery after GetResults function in loop body. Update loop that aggregates the results to iterate 10 times instead of 5 and log the value of someVar. Add function ExecQuery to execute a query.'

The 'hasChange' property is a boolean that indicates whether there is anything to change. If there is nothing to change, set 'hasChange' to false. If there is something to change, set 'hasChange' to true.

The 'old' property is an object with 3 properties: 'entireFile', 'startLineString' and 'endLineString'.

	'entireFile' is a boolean that indicates whether the **entire file** is being replaced. If 'entireFile' is true, 'startLineString' and 'endLineString' must be empty strings. If 'entireFile' is false, 'startLineString' and 'endLineString' must be valid strings that exactly match lines from the original file. If 'entireFile' is false, 'startLineString' and 'endLineString' MUST NEVER be empty strings.

	'startLineString' is the **entire, exact line** where the section to be replaced begins in the original file, including the line number. Unless it's the first change, 'startLineString' ABSOLUTELY MUST begin with a line number that is HIGHER than both the 'endLineString' of the previous change and the 'startLineString' of the previous change. **The line number and line MUST EXACTLY MATCH a line from the original file.**
	
	If the previous change's 'endLineString' starts with 'pdx-75: ', then the current change's 'startLineString' MUST start with 'pdx-76: ' or higher. It MUST NOT be 'pdx-75: ' or lower. If the previous change's 'startLineString' starts with 'pdx-88: ' and the previous change's 'endLineString' is an empty string, then the current change's 'startLineString' MUST start with 'pdx-89: ' or higher. If the previous change's 'startLineString' starts with 'pdx-100: ' and the previous change's 'endLineString' starts with 'pdx-105: ', then the current change's 'startLineString' MUST start with 'pdx-106: ' or higher.
	
	'endLineString' is the **entire, exact line** where the section to be replaced ends in the original file. Pay careful attention to spaces and indentation. 'startLineString' and 'endLineString' must be *entire lines* and *not partial lines*. Even if a line is very long, you must include the entire line, including the line number and all text on the line. **The line number and line MUST EXACTLY MATCH a line from the original file.**
	
	**For a single line replacement, 'endLineString' MUST be an empty string.**

	'endLineString' MUST ALWAYS come *after* 'startLineString' in the original file. It must start with a line number that is HIGHER than the 'startLineString' line number. If 'startLineString' starts with 'pdx-22: ', then 'endLineString' MUST either be an empty string (for a single line replacement) or start with 'pdx-23: ' or higher (for a multi-line replacement).	

	If 'hasChange' is false, both 'startLineString' and 'endLineString' must be empty strings. If 'hasChange' is true, 'startLineString' and 'endLineString' must be valid strings that exactly match lines from the original file. If 'hasChange' is true, 'startLineString' and 'endLineString' MUST NEVER be empty strings.

	If you are replacing the entire file, 'startLineString' MUST be the first line of the original file and 'endLineString' MUST be the last line of the original file.

The 'startLineIncludedReasoning' property is a string that very briefly explains whether 'startLineString' should be included in the 'new' property. For example, if the 'startLineString' is the closing bracket of a function and you are adding another function after it, you *MUST* include the 'startLineString' in the 'new' property, or the previous function will lose its closing bracket when the change is applied. Similarly, if the 'startLineString' is a function definition and you are updating the body of the function, you *MUST* also include 'startLineString' so that they function definition is not removed. The only time 'startLineString' should not be included in 'new' is if it is a line that should be removed or replaced. Generalize the above to all types of code blocks, changes, and syntax to ensure the 'new' property will not remove or overwrite code that should not be removed or overwritten. That also includes newlines, line breaks, and indentation.

'startLineIncluded' is a boolean that indicates whether 'startLineString' should be included in the 'new' property. If 'startLineIncluded' is true, 'startLineString' MUST be included in the 'new' property. If 'startLineIncluded' is false, 'startLineString' MUST not be included in the 'new' property.

The 'endLineIncludedReasoning' property is a string that very briefly explains whether 'endLineString' should be included in the 'new' property. For example, if the 'endLineString' is the opening bracket of a function and you are adding another function before it, you *MUST* include the 'endLineString' in the 'new' property, or the subsequent function will lose its opening bracket when the change is applied. Similarly, if the 'endLineString' is the closing bracket of a function and you are updating the body of the function, you *MUST* also include 'endLineString' so that the closing bracket not removed. The only time 'endLineString' should not be included in 'new' is if it is a line that should be removed or replaced. Generalize the above to all types of code blocks, changes, and syntax to ensure the 'new' property will not remove or overwrite code that should not be removed or overwritten. That also includes newlines, line breaks, and indentation.

'endLineIncluded' is a boolean that indicates whether 'endLineString' should be included in the 'new' property. If 'endLineIncluded' is true, 'endLineString' MUST be included in the 'new' property. If 'endLineIncluded' is false, 'endLineString' MUST not be included in the 'new' property.

The 'new' property is a string that represents the new code that will replace the old code. The new code must be valid and consistent with the intention of the plan. If the proposed update is to remove code, the 'new' property should be an empty string. Be precise about newlines, line breaks, and indentation. 'new' must include only full lines of code and *no partial lines*. Do NOT include line numbers in the 'new' property.

If the proposed update includes references to the original code in comments like "// rest of the function..." or "# existing init code...", or "// rest of the main function..." or "// rest of your function..." or **any other reference to the original code,** you *MUST* ensure that the comment making the reference is *NOT* included in the 'new' property. Instead, include the **exact code** from the original file that the comment is referencing. Do not be overly strict in identifying references. If there is a comment that seems like it could plausibly be a reference and there is code in the original file that could plausibly be the code being referenced, then treat that as a reference and handle it accordingly by including the code from the original file in the 'new' property instead of the comment. YOU MUST NOT MISS ANY REFERENCES.

If the 'startLineIncluded' property is true, the 'startLineString' MUST be the first line of 'new'. If the 'startLineIncluded' property is false, the 'startLineString' MUST NOT be included in 'new'. If the 'endLineIncluded' property is true, the 'endLineString' MUST be the last line of 'new'. If the 'endLineIncluded' property is false, the 'endLineString' MUST NOT be included in 'new'.

If the 'hasChange' property is false, the 'new' property must be an empty string. If the 'hasChange' property is true, the 'new' property must be a valid string.

If *any* change has the 'entireFile' key in the 'old' property set to true, the corresponding 'new' key MUST be the entire updated file, and there MUST only be a single change in the 'changes' array.

You MUST ensure the line numbers for the 'old' property correctly remove *ALL* code that has problems and that the 'new' property correctly fixes *ALL* the problems present in the updated file. You MUST NOT miss any problems, fail to fix any problems, or introduce any new problems.


Because you are implementing a fix, be more willing to make larger changes in order to fix all the problems. Smaller changes are more error-prone, and the fact that you are fixing a file means a line-number based change already failed. This likely means there was some tricky structural challenge in applying the changes with line numbers, so be prepared to make a larger change in order to avoid continuing to fail to fix the file.

Example change object:
  
```json
{
  "summary": "Fix syntax error in loop body.",
 	"old": {
    "startLineString": "pdx-5: for i := 0; i < 10; i++ { ",
    "endLineString": "pdx-7: }"
  },
  "new": "for i := 0; i < 10; i++ {\n  execQuery()\n  }\n  }\n}"
}
```


You ABSOLUTELY MUST NOT generate overlapping changes. Group smaller changes together into larger changes where necessary to avoid overlap. Only generate multiple changes when you are ABSOLUTELY CERTAIN that they do not overlap--otherwise group them together into a single change. If changes are close to each other (within several lines), group them together into a single change. You MUST group changes together and make fewer, larger changes rather than many small changes, unless the changes are completely independent of each other and not close to each other in the file. You MUST NEVER generate changes that are adjacent or close to adjacent. Adjacent or closely adjacent changes MUST ALWAYS be grouped into a single larger change.

Furthermore, unless doing so would require a very large change because some changes are far apart in the file, it's ideal to call the 'listChangesWithLineNums' with just a SINGLE change.

Changes must be ordered in the array according to the order they appear in the file. The 'startLineString' of each 'old' property must come after the 'endLineString' of the previous 'old' property. Changes MUST NOT overlap. If a change is dependent on another change or intersects with it, group those changes together into a single change.

You MUST NOT repeat changes to the same block of lines multiple teams. You MUST NOT duplicate changes. It is extremely important that a given change is only applied *once*.

Apply changes intelligently **in order** to avoid syntax errors, breaking code, or removing code from the original file that should not be removed. Consider the reason behind the update and make sure the result is consistent with the intention of the plan.

Changes MUST be ordered based on their position in the original file. ALWAYS go from top to bottom IN ORDER when generating replacements. DO NOT EVER GENERATE AN OVERLAPPING CHANGE. If a change would fall within OR overlap a prior change in the list, SKIP that change and move on to the next one.

You ABSOLUTELY MUST NOT overwrite or delete code from the original file unless the plan *clearly intends* for the code to be overwritten or removed. Do NOT replace a full section of code with only new code unless that is the clear intention of the plan. Instead, merge the original code and the proposed updates together intelligently according to the intention of the plan. 

Pay *EXTREMELY close attention* to opening and closing brackets, parentheses, and braces. Never leave them unbalanced when the changes are applied. Also pay *EXTREMELY close attention* to newlines and indentation. Make sure that the indentation of the new code is consistent with the indentation of the original code, and syntactically correct.

The 'listChangesWithLineNums' function MUST be called *valid JSON*. Double quotes within json properties of the 'listChangesWithLineNums' function call parameters JSON object *must be properly escaped* with a backslash. Pay careful attention to newlines, tabs, and other special characters. The JSON object must be properly formatted and must include all required keys. **You generate perfect JSON -every- time**, no matter how many quotes or special characters are in the input. You must always call 'listChangesWithLineNums' with a valid JSON object. Don't call any other function.

[END YOUR INSTRUCTIONS]

**Original file:**

```
{{preBuildState}}
```

**Proposed updates:**

{{changes}}

--

**The incorrectly updated file is:**

```
{{incorrectlyUpdatedFile}}
```

**The problems with the file are:**

{{problems}}

--

Now call the 'listChangesWithLineNums' function with a valid JSON array of changes according to your instructions. You must always call 'listChangesWithLineNums' with one or more valid changes. Don't call any other function.


================================================
FILE: test/evals/promptfoo-poc/fix/fix.provider.yml
================================================
id: openai:gpt-4o
config:
  temperature: 0.1
  max_tokens: 4096
  response_format: { type: json_object }
  top_p: 0.1
  tools:
    [
      {
        "type": "function",
        "function":
          { "name": "listChangesWithLineNums", "parameters": {"properties":{"changes":{"items":{"properties":{"endLineIncluded":{"type":"boolean"},"endLineIncludedReasoning":{"type":"string"},"hasChange":{"type":"boolean"},"new":{"type":"string"},"old":{"properties":{"endLineString":{"type":"string"},"entireFile":{"type":"boolean"},"startLineString":{"type":"string"}},"required":["startLineString","endLineString"],"type":"object"},"startLineIncluded":{"type":"boolean"},"startLineIncludedReasoning":{"type":"string"},"summary":{"type":"string"}},"required":["summary","hasChange","old","startLineIncludedReasoning","startLineIncluded","endLineIncludedReasoning","endLineIncluded","new"],"type":"object"},"type":"array"},"comments":{"items":{"properties":{"reference":{"type":"boolean"},"txt":{"type":"string"}},"required":["txt","reference"],"type":"object"},"type":"array"},"problems":{"type":"string"}},"required":["comments","problems","changes"],"type":"object"} },
      },
    ]
  tool_choice:
    type: "function"
    function:
      name: "listChangesWithLineNums"


================================================
FILE: test/evals/promptfoo-poc/fix/promptfooconfig.yaml
================================================
# This configuration compares LLM output of 2 prompts x 2 GPT models across 3 test cases.
# Learn more: https://promptfoo.dev/docs/configuration/guide
description: "fix"

prompts:
  - file://fix.prompt.txt

providers:
  - file://fix.provider.yml

tests: tests/*.test.yml


================================================
FILE: test/evals/promptfoo-poc/fix/tests/fix.test.yml
================================================
- description: "Check Fix with Line numbers"
  vars:
    preBuildState: file://assets/shared/pre_build.go
    changes: file://assets/removal/changes.md
    problems: file://assets/removal/problems.txt
    postBuildState: file://assets/removal/post_build.go
  assert:
    - type: is-json
    - type: is-valid-openai-tools-call
    - type: javascript
      value: |
        var args = JSON.parse(output[0].function.arguments)
        return (
          args.problems && 
          args.changes.length > 0 &&
          args.changes.some(
            change => change.hasChange && 
                      change.new.includes("var contextRmCmd = &cobra.Command{")
          )
        )


================================================
FILE: test/evals/promptfoo-poc/templates/provider.template.yml
================================================
# TODO: Add support for more dynamic creation, support for multiple tools, different API providers parameters, etc.

id: {{ .provider_id }}
config:
  temperature: {{ .temperature }}
  max_tokens: {{ .max_tokens }}
  response_format: { type: {{ .response_format }} }
  top_p: {{ .top_p }}
  tools:
    [
      {
        "type": "{{ .tool_type }}",
        "function":
          { "name": "{{ .function_name }}", "parameters": {{ .parameters }} },
      },
    ]
  tool_choice:
    type: "{{ .tool_choice_type }}"
    function:
      name: "{{ .tool_choice_function_name }}"


================================================
FILE: test/evals/promptfoo-poc/verify/assets/removal/changes.md
================================================
### Subtask 1: Parse the range of indices from the command-line arguments.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}
```

### Subtask 2: Update the logic to handle the range of indices and mark the corresponding contexts for deletion.

```
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"plandex-shared"
	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for _, arg := range args {
		indices, err := parseRange(arg)
		if err != nil {
			term.OutputErrorAndExit("Error parsing range: %v", err)
		}

		for _, index := range indices {
			if index > 0 && index <= len(contexts) {
				context := contexts[index-1]
				deleteIds[context.Id] = true
			}
		}
	}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}
```

### Subtask 3: Update the `contextRm` function to include the new logic for handling ranges.


```
func init() {
	RootCmd.AddCommand(contextRmCmd)
}
```

================================================
FILE: test/evals/promptfoo-poc/verify/assets/removal/diff.txt
================================================
diff --git a/pre_build.go b/tests/removal/post_build.go
index c90eeb7..e9da642 100644
--- a/pre_build.go
+++ b/tests/removal/post_build.go
@@ -7,18 +7,36 @@ import (
 	"plandex/auth"
 	"plandex/lib"
 	"plandex/term"
+	"strconv"
+	"strings"
 
 	"plandex-shared"
 	"github.com/spf13/cobra"
 )
 
-var contextRmCmd = &cobra.Command{
-	Use:     "rm",
-	Aliases: []string{"remove", "unload"},
-	Short:   "Remove context",
-	Long:    `Remove context by index, name, or glob.`,
-	Args:    cobra.MinimumNArgs(1),
-	Run:     contextRm,
+func parseRange(arg string) ([]int, error) {
+	var indices []int
+	parts := strings.Split(arg, "-")
+	if len(parts) == 2 {
+		start, err := strconv.Atoi(parts[0])
+		if err != nil {
+			return nil, err
+		}
+		end, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return nil, err
+		}
+		for i := start; i <= end; i++ {
+			indices = append(indices, i)
+		}
+	} else {
+		index, err := strconv.Atoi(arg)
+		if err != nil {
+			return nil, err
+		}
+		indices = append(indices, index)
+	}
+	return indices, nil
 }
 
 func contextRm(cmd *cobra.Command, args []string) {
@@ -39,6 +57,20 @@ func contextRm(cmd *cobra.Command, args []string) {
 
 	deleteIds := map[string]bool{}
 
+	for _, arg := range args {
+		indices, err := parseRange(arg)
+		if err != nil {
+			term.OutputErrorAndExit("Error parsing range: %v", err)
+		}
+
+		for _, index := range indices {
+			if index > 0 && index <= len(contexts) {
+				context := contexts[index-1]
+				deleteIds[context.Id] = true
+			}
+		}
+	}
+
 	for i, context := range contexts {
 		for _, id := range args {
 			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
@@ -64,7 +96,6 @@ func contextRm(cmd *cobra.Command, args []string) {
 					}
 					parentDir = filepath.Dir(parentDir) // Move up one directory
 				}
-
 			}
 		}
 	}


================================================
FILE: test/evals/promptfoo-poc/verify/assets/removal/post_build.go
================================================
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for _, arg := range args {
		indices, err := parseRange(arg)
		if err != nil {
			term.OutputErrorAndExit("Error parsing range: %v", err)
		}

		for _, index := range indices {
			if index > 0 && index <= len(contexts) {
				context := contexts[index-1]
				deleteIds[context.Id] = true
			}
		}
	}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}
			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}

func init() {
	RootCmd.AddCommand(contextRmCmd)
}


================================================
FILE: test/evals/promptfoo-poc/verify/assets/shared/pre_build.go
================================================
pdx-1: package cmd
pdx-2: 
pdx-3: import (
pdx-4: 	"fmt"
pdx-5: 	"path/filepath"
pdx-6: 	"plandex/api"
pdx-7: 	"plandex/auth"
pdx-8: 	"plandex/lib"
pdx-9: 	"plandex/term"
pdx-10: 
pdx-11: 	"plandex-shared"
pdx-12: 	"github.com/spf13/cobra"
pdx-13: )
pdx-14: 
pdx-15: var contextRmCmd = &cobra.Command{
pdx-16: 	Use:     "rm",
pdx-17: 	Aliases: []string{"remove", "unload"},
pdx-18: 	Short:   "Remove context",
pdx-19: 	Long:    `Remove context by index, name, or glob.`,
pdx-20: 	Args:    cobra.MinimumNArgs(1),
pdx-21: 	Run:     contextRm,
pdx-22: }
pdx-23: 
pdx-24: func contextRm(cmd *cobra.Command, args []string) {
pdx-25: 	auth.MustResolveAuthWithOrg()
pdx-26: 	lib.MustResolveProject()
pdx-27: 
pdx-28: 	if lib.CurrentPlanId == "" {
pdx-29: 		fmt.Println("🤷‍♂️ No current plan")
pdx-30: 		return
pdx-31: 	}
pdx-32: 
pdx-33: 	term.StartSpinner("")
pdx-34: 	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
pdx-35: 
pdx-36: 	if err != nil {
pdx-37: 		term.OutputErrorAndExit("Error retrieving context: %v", err)
pdx-38: 	}
pdx-39: 
pdx-40: 	deleteIds := map[string]bool{}
pdx-41: 
pdx-42: 	for i, context := range contexts {
pdx-43: 		for _, id := range args {
pdx-44: 			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
pdx-45: 				deleteIds[context.Id] = true
pdx-46: 				break
pdx-47: 			} else if context.FilePath != "" {
pdx-48: 				// Check if id is a glob pattern
pdx-49: 				matched, err := filepath.Match(id, context.FilePath)
pdx-50: 				if err != nil {
pdx-51: 					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
pdx-52: 				}
pdx-53: 				if matched {
pdx-54: 					deleteIds[context.Id] = true
pdx-55: 					break
pdx-56: 				}
pdx-57: 
pdx-58: 				// Check if id is a parent directory
pdx-59: 				parentDir := context.FilePath
pdx-60: 				for parentDir != "." && parentDir != "/" && parentDir != "" {
pdx-61: 					if parentDir == id {
pdx-62: 						deleteIds[context.Id] = true
pdx-63: 						break
pdx-64: 					}
pdx-65: 					parentDir = filepath.Dir(parentDir) // Move up one directory
pdx-66: 				}
pdx-67: 
pdx-68: 			}
pdx-69: 		}
pdx-70: 	}
pdx-71: 
pdx-72: 	if len(deleteIds) > 0 {
pdx-73: 		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
pdx-74: 			Ids: deleteIds,
pdx-75: 		})
pdx-76: 		term.StopSpinner()
pdx-77: 
pdx-78: 		if err != nil {
pdx-79: 			term.OutputErrorAndExit("Error deleting context: %v", err)
pdx-80: 		}
pdx-81: 
pdx-82: 		fmt.Println("✅ " + res.Msg)
pdx-83: 	} else {
pdx-84: 		term.StopSpinner()
pdx-85: 		fmt.Println("🤷‍♂️ No context removed")
pdx-86: 	}
pdx-87: }
pdx-88: 
pdx-89: func init() {
pdx-90: 	RootCmd.AddCommand(contextRmCmd)
pdx-91: }
pdx-92: 

================================================
FILE: test/evals/promptfoo-poc/verify/assets/valid/changes.md
================================================
 ### Subtask 1: Parse the range of indices from the command-line arguments.  
                                                               
                                                        ```                      
    package cmd                                                               
                                                                              
    import (                                                                  
    	"fmt"                                                                     
    	"path/filepath"                                                           
    	"plandex/api"                                                             
    	"plandex/auth"                                                            
    	"plandex/lib"                                                             
    	"plandex/term"                                                            
    	"strconv"                                                                 
    	"strings"                                                                 
                                                                              
    	"plandex-shared"                                       
    	"github.com/spf13/cobra"                                                  
    )                                                                         
                                                                              
    func parseRange(arg string) ([]int, error) {                              
    	var indices []int                                                         
    	parts := strings.Split(arg, "-")                                          
    	if len(parts) == 2 {                                                      
    		start, err := strconv.Atoi(parts[0])                                      
    		if err != nil {                                                           
    			return nil, err                                                           
    		}                                                                         
    		end, err := strconv.Atoi(parts[1])                                        
    		if err != nil {                                                           
    			return nil, err                                                           
    		}                                                                         
    		for i := start; i <= end; i++ {                                           
    			indices = append(indices, i)                                              
    		}                                                                         
    	} else {                                                                  
    		index, err := strconv.Atoi(arg)                                           
    		if err != nil {                                                           
    			return nil, err                                                           
    		}                                                                         
    		indices = append(indices, index)                                          
    	}                                                                         
    	return indices, nil                                                       
    }
	```

================================================
FILE: test/evals/promptfoo-poc/verify/assets/valid/diff.txt
================================================
diff --git a/tests/go/shared/pre_build.go b/tests/go/valid/post_build.go
index c90eeb7..90405e7 100644
--- a/tests/go/shared/pre_build.go
+++ b/tests/go/valid/post_build.go
@@ -7,11 +7,38 @@ import (
 	"plandex/auth"
 	"plandex/lib"
 	"plandex/term"
+	"strconv"
+	"strings"
 
 	"plandex-shared"
 	"github.com/spf13/cobra"
 )
 
+func parseRange(arg string) ([]int, error) {
+	var indices []int
+	parts := strings.Split(arg, "-")
+	if len(parts) == 2 {
+		start, err := strconv.Atoi(parts[0])
+		if err != nil {
+			return nil, err
+		}
+		end, err := strconv.Atoi(parts[1])
+		if err != nil {
+			return nil, err
+		}
+		for i := start; i <= end; i++ {
+			indices = append(indices, i)
+		}
+	} else {
+		index, err := strconv.Atoi(arg)
+		if err != nil {
+			return nil, err
+		}
+		indices = append(indices, index)
+	}
+	return indices, nil
+}
+
 var contextRmCmd = &cobra.Command{
 	Use:     "rm",
 	Aliases: []string{"remove", "unload"},


================================================
FILE: test/evals/promptfoo-poc/verify/assets/valid/post_build.go
================================================
package cmd

import (
	"fmt"
	"path/filepath"
	"plandex/api"
	"plandex/auth"
	"plandex/lib"
	"plandex/term"
	"strconv"
	"strings"

	"github.com/spf13/cobra"
)

func parseRange(arg string) ([]int, error) {
	var indices []int
	parts := strings.Split(arg, "-")
	if len(parts) == 2 {
		start, err := strconv.Atoi(parts[0])
		if err != nil {
			return nil, err
		}
		end, err := strconv.Atoi(parts[1])
		if err != nil {
			return nil, err
		}
		for i := start; i <= end; i++ {
			indices = append(indices, i)
		}
	} else {
		index, err := strconv.Atoi(arg)
		if err != nil {
			return nil, err
		}
		indices = append(indices, index)
	}
	return indices, nil
}

var contextRmCmd = &cobra.Command{
	Use:     "rm",
	Aliases: []string{"remove", "unload"},
	Short:   "Remove context",
	Long:    `Remove context by index, name, or glob.`,
	Args:    cobra.MinimumNArgs(1),
	Run:     contextRm,
}

func contextRm(cmd *cobra.Command, args []string) {
	auth.MustResolveAuthWithOrg()
	lib.MustResolveProject()

	if lib.CurrentPlanId == "" {
		fmt.Println("🤷‍♂️ No current plan")
		return
	}

	term.StartSpinner("")
	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)

	if err != nil {
		term.OutputErrorAndExit("Error retrieving context: %v", err)
	}

	deleteIds := map[string]bool{}

	for i, context := range contexts {
		for _, id := range args {
			if fmt.Sprintf("%d", i+1) == id || context.Name == id || context.FilePath == id || context.Url == id {
				deleteIds[context.Id] = true
				break
			} else if context.FilePath != "" {
				// Check if id is a glob pattern
				matched, err := filepath.Match(id, context.FilePath)
				if err != nil {
					term.OutputErrorAndExit("Error matching glob pattern: %v", err)
				}
				if matched {
					deleteIds[context.Id] = true
					break
				}

				// Check if id is a parent directory
				parentDir := context.FilePath
				for parentDir != "." && parentDir != "/" && parentDir != "" {
					if parentDir == id {
						deleteIds[context.Id] = true
						break
					}
					parentDir = filepath.Dir(parentDir) // Move up one directory
				}

			}
		}
	}

	if len(deleteIds) > 0 {
		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
			Ids: deleteIds,
		})
		term.StopSpinner()

		if err != nil {
			term.OutputErrorAndExit("Error deleting context: %v", err)
		}

		fmt.Println("✅ " + res.Msg)
	} else {
		term.StopSpinner()
		fmt.Println("🤷‍♂️ No context removed")
	}
}

func init() {
	RootCmd.AddCommand(contextRmCmd)
}


================================================
FILE: test/evals/promptfoo-poc/verify/promptfooconfig.yaml
================================================
# This configuration compares LLM output of 2 prompts x 2 GPT models across 3 test cases.
# Learn more: https://promptfoo.dev/docs/configuration/guide
description: "verify"

prompts:
  - file://verify.prompt.txt
providers:
  - file://verify.provider.yml
tests: tests/*.test.yml


================================================
FILE: test/evals/promptfoo-poc/verify/tests/removal.test.yml
================================================
- description: "Removal of code errors"
  vars:
      preBuildState: file://assets/shared/pre_build.go
      changes: file://assets/removal/changes.md
      postBuildState: file://assets/removal/post_build.go
      diffs: file://assets/removal/diff.txt
  assert:
    - type: is-json
    - type: is-valid-openai-tools-call
    - type: javascript
      value: |
        var args = JSON.parse(output[0].function.arguments)
        return args.hasRemovedCodeErrors

================================================
FILE: test/evals/promptfoo-poc/verify/tests/validate.test.yml
================================================
- description: "Validation of the code changes"
  vars:
    preBuildState: file://assets/shared/pre_build.go
    changes: file://assets/valid/changes.md
    postBuildState: file://assets/valid/post_build.go
    diffs: file://assets/valid/diff.txt
  assert:
    - type: is-json
    - type: is-valid-openai-tools-call
    - type: javascript
      value: |
        var args = JSON.parse(output[0].function.arguments)
        return !(
          args.hasSyntaxErrors ||
          args.hasRemovedCodeErrors ||
          args.hasDuplicationErrors ||
          args.hasReferenceErrors            
        )


================================================
FILE: test/evals/promptfoo-poc/verify/verify.config.properties
================================================
provider_id=openai:gpt-4o
temperature=0.1
max_tokens=4096
top_p=0.1
response_format=json_object
function_name=verifyOutput
tool_type=function
function_param_type=object
tool_choice_type=function
tool_choice_function_name=verifyOutput
nested_parameters_json=verify.parameters.json


================================================
FILE: test/evals/promptfoo-poc/verify/verify.parameters.json
================================================
{
  "type": "object",
  "properties": {
    "syntaxErrorsReasoning": {
      "type": "string"
    },
    "hasSyntaxErrors": {
      "type": "boolean"
    },
    "removed": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "code": {
            "type": "string"
          },
          "reasoning": {
            "type": "string"
          },
          "correct": {
            "type": "boolean"
          }
        },
        "required": ["code", "reasoning", "correct"]
      }
    },
    "removedCodeErrorsReasoning": {
      "type": "string"
    },
    "hasRemovedCodeErrors": {
      "type": "boolean"
    },
    "duplicationErrorsReasoning": {
      "type": "string"
    },
    "hasDuplicationErrors": {
      "type": "boolean"
    },
    "comments": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "txt": {
            "type": "string"
          },
          "reference": {
            "type": "boolean"
          }
        },
        "required": ["txt", "reference"]
      }
    },
    "referenceErrorsReasoning": {
      "type": "string"
    },
    "hasReferenceErrors": {
      "type": "boolean"
    }
  },
  "required": [
    "syntaxErrorsReasoning",
    "hasSyntaxErrors",
    "removed",
    "removedCodeErrorsReasoning",
    "hasRemovedCodeErrors",
    "duplicationErrorsReasoning",
    "hasDuplicationErrors",
    "comments",
    "referenceErrorsReasoning",
    "hasReferenceErrors"
  ]
}


================================================
FILE: test/evals/promptfoo-poc/verify/verify.prompt.txt
================================================
Based on an original file (if one exists), an AI-generated plan, an updated file and a set of diffs (if one exists), determine whether the updated file's syntax is correct and whether the proposed updates were applied correctly to the updated file.

You must consider whether any of the following problems are present in the updated file:
- Syntax errors, including unbalanced brackets, parentheses, braces, quotes, indentation, and other code structure errors
- Missing or incorrectly scoped declarations
- Any other errors that make the code invalid and would prevent it from being run as-is for the programming language being used
- Code from the original file was incorrectly removed or overwritten.
- Code was incorrectly duplicated. For example, if a file should have a single main function, but instead of updating the existing main function, the updated file includes multiple main functions, then the file is incorrect. The same applies to any other functions or elements that should not be duplicated.
- Incorrectly included comments that reference the original code.. If the updated file includes comments like "// rest of the function..." or "# existing init code...", or "// rest of the main function..." or "// rest of your function..." or "// Existing methods...", "// Existing code..." **any other reference to the original code**, the file is incorrect. References like these must be handled by including the exact code from the original file that the comment is referencing.

If there is no original file, it means that a new file was created from scratch based on the AI-generated plan. In this case, the syntax in the new file must be valid and consistent with the intention of the plan. You must ensure there are no syntax errors or other clear mistakes in the new file.

Call the 'verifyOutput' function with a valid JSON object that include the following keys:

'syntaxErrorsReasoning': A string that succinctly explains whether there are any syntax or scoping errors in the updated file. Explain all syntax errors, scoping errors, or other code structure errors that are present in the updated file. 

'hasSyntaxErrors': A boolean that indicates whether there are any syntax errors in the updated file, based on the reasoning provided in 'syntaxErrorsReasoning'.

'removed': an array of objects with three properties: 'code', 'reasoning', and 'correct'. 
   - 'code' is a string. It shows the section of code that was removed or overwritten in the updated file. This can be abbreviated by detailing how the section starts and end and describing the purpose of the code. If the section is longer than a few lines, rather than reproducding a long section of code verbatim, provide a summary of the code that was removed or overwritten, as well as the exact code which starts and ends the section. The summary and start/end code should be details enough to disambiguate the section of code that was removed or overwritten from any other similar sections of code in the file.
   - 'reasoning' is a string that explains whether, based on the proposed changes, this section was deliberately removed consistent with the intention of the plan, or whether the plan did NOT specify that this section should be removed, and the code was therefore removed incorrectly. Also consider whether this removal breaks the syntax or functionality of the code in the updated file based on the programming language being used--if it does, explain this and state that the removal was incorrect. If the removal either wasn't intended by the proposed updates *or* breaks the syntax or functionality of the code, the removal is incorrect. If the removal was consistent with the intention of the plan *and* did not break the syntax or functionality of the code, the removal is correct.
   - 'correct' is a boolean that indicates whether the removal or overwriting was correct based on the 'reasoning' provided. If the removal was correct, set 'correct' to true. If the removal was incorrect, set 'correct' to false.

Based on supplied diffs, you must list EVERY code section that was removed or overwritten in the updated file in 'removed'. If there are no code sections that were removed or overwritten, 'removed' must be an empty array. If multiple code sections were removed or overwritten, list each one as a separate object in the 'removed' array. If multiple identical code sections were removed or overwritten, you MUST list them *all* in the 'removed' array--list each identical code section as a separate object in the array. Do NOT include removals that only modify whitespace. Do NOT include sections that were moved or refactored, only sections that were fully removed or overwritten.

'removedCodeErrorsReasoning': A string that succinctly explains whether any code was incorrectly removed or overwritten in the updated file based on the 'removed' array. If code was incorrectly removed or overwritten, succinctly explain why it was incorrect, and how the file can be corrected. If code was correctly removed or overwritten, consistent with the intention of the plan, state this.

'hasRemovedCodeErrors': A boolean that indicates whether any code was *incorrectly* removed or overwritten in the updated file, based on the reasoning provided in 'removedCodeErrorsReasoning'.

'duplicationErrorsReasoning': A string that succinctly explains whether any code was *incorrectly* duplicated in the updated file. First explain whether any code, functions, or other elements are duplicated in the updated file, then explain whether the duplication is deliberate and consistent with the plan, and whether the duplication is correct and valid in the programming language being used.

'hasDuplicationErrors': A boolean that indicates whether any code was *incorrectly* duplicated in the updated file, based on the reasoning provided in 'duplicationErrorsReasoning'. If code was *incorrectly* duplicated, set 'hasDuplicationErrors' to true. If code was *correctly* duplicated, consistent with the intention of the plan, set 'hasDuplicationErrors' to false.

'comments':  an array of objects with two properties: 'txt' and 'reference'. 'txt' is the exact text of a code comment. 'reference' is a boolean that indicates whether the comment is a placeholder of or reference to the original code, like "// rest of the function..." or "# existing init code...", or "// rest of the main function" or "// rest of your function..." or "// Existing methods..." or "// Remaining methods" or "// Existing code..." or "// ... existing setup code ..."" or other comments which reference code from the original file. References DO NOT need to exactly match any of the previous examples. Use your judgement to determine whether each comment is a reference. If 'reference' is true, the comment is a placeholder or reference to the original code. If 'reference' is false, the comment is not a placeholder or reference to the original code.

In 'comments', you must list EVERY comment included in the *updated file*. Only list *code comments* that are valid comments for the programming language being used. Do not list logging statements or any other non-comment text that is not a valid code comment. If there are no code comments in the *updated file*, 'comments' must be an empty array.

If there are multiple identical comments in the *updated file*, you MUST list them *all* in the 'comments' array--list each identical comment as a separate object in the array.

'referenceErrorsReasoning': A string that succinctly explains whether any comments in the updated file are placeholders/references that should have been replaced with code from the original file. These are comments like "// rest of the function..." or "# existing init code...", or "// rest of the main function..." or "// rest of your function..." or "// Existing methods...", "// Existing code..." or other  comments which reference code from the original file. Only include comments that *are not* present in the original file and *are* present in the proposed updates. If there are no such comments, explain that there are no reference errors.

'hasReferenceErrors': A boolean that indicates whether any comments in the updated file are placeholders/references that should be replaced with code from the original file, based on the reasoning provided in 'referenceErrorsReasoning'.

In each of the reasoning keys above, be exhaustive and include *every* problem that is present in the file. But if there are no problems in a reasoning key, do NOT invent problems--explain according to your instructions for each key that there are no problems in that category.

--

## **Original file:**

{{preBuildState}}

--

## **Proposed updates:**

{{changes}}

--

## **Updated file:**

{{postBuildState}}

--

## **Diffs:**

{{diffs}}

--

Now call the 'verifyOutput' function with a valid JSON object. Don't call any other function.

You absolutely MUST generate PERFECTLY VALID JSON. Pay extremely close attention to the JSON syntax and structure. Double quotes within JSON properties *MUST* be properly escaped with a backslash.

================================================
FILE: test/evals/promptfoo-poc/verify/verify.provider.yml
================================================
id: openai:gpt-4o
config:
  temperature: 0.1
  max_tokens: 4096
  response_format: { type: json_object }
  top_p: 0.1
  tools:
    [
      {
        "type": "function",
        "function":
          { "name": "verifyOutput", "parameters": {"properties":{"comments":{"items":{"properties":{"reference":{"type":"boolean"},"txt":{"type":"string"}},"required":["txt","reference"],"type":"object"},"type":"array"},"duplicationErrorsReasoning":{"type":"string"},"hasDuplicationErrors":{"type":"boolean"},"hasReferenceErrors":{"type":"boolean"},"hasRemovedCodeErrors":{"type":"boolean"},"hasSyntaxErrors":{"type":"boolean"},"referenceErrorsReasoning":{"type":"string"},"removed":{"items":{"properties":{"code":{"type":"string"},"correct":{"type":"boolean"},"reasoning":{"type":"string"}},"required":["code","reasoning","correct"],"type":"object"},"type":"array"},"removedCodeErrorsReasoning":{"type":"string"},"syntaxErrorsReasoning":{"type":"string"}},"required":["syntaxErrorsReasoning","hasSyntaxErrors","removed","removedCodeErrorsReasoning","hasRemovedCodeErrors","duplicationErrorsReasoning","hasDuplicationErrors","comments","referenceErrorsReasoning","hasReferenceErrors"],"type":"object"} },
      },
    ]
  tool_choice:
    type: "function"
    function:
      name: "verifyOutput"


================================================
FILE: test/plan_deletion_test.sh
================================================
# Plandex hasn't been able to get this working yet

#!/bin/bash
set -e

# Enable debug output
set -x

# Helper function to check if a plan exists
check_plan_exists() {
    local plan_name=$1
    pdxd plans | grep -q "$plan_name"
}

# Helper function to count total plans
count_plans() {
    # Add sleep to ensure plan list is updated
    sleep 1
    # Strip ANSI codes, skip help text and header, then count only the test plans
    pdxd plans | sed 's/\x1B\[[0-9;]*[mK]//g' | grep -A 1000 "^+----+" | tail -n +3 | head -n 5 | grep -E '\| (plan-config-[123]|other-plan-[12])(\.[0-9]+)? \|' | wc -l
}

# Clean up any existing test plans before starting
echo "Cleaning up any existing test plans..."
echo "y" | pdxd dp "plan-config-*" || true
echo "y" | pdxd dp "other-plan-*" || true
sleep 2

# Create test plans with verification
echo "Creating test plans..."
for plan in "plan-config-1" "plan-config-2" "plan-config-3" "other-plan-1" "other-plan-2"; do
    pdxd new -n "$plan"
    if ! check_plan_exists "$plan"; then
        echo "❌ Failed to create plan '$plan'"
        exit 1
    fi
    # Add sleep to ensure plan creation is complete
    sleep 1
done

# Verify initial plans were created
echo "Verifying plans were created..."
initial_count=$(count_plans)
echo "Found $initial_count plans"

if [ "$initial_count" -ne 5 ]; then
    echo "❌ Expected 5 plans, but found $initial_count"
    pdxd plans
    exit 1
fi

for plan in "plan-config-1" "plan-config-2" "plan-config-3" "other-plan-1" "other-plan-2"; do
    if ! check_plan_exists "$plan"; then
        echo "❌ Plan '$plan' was not created successfully"
        exit 1
    fi
done

# Test wildcard deletion
echo "Testing wildcard deletion..."
echo "y" | pdxd dp "plan-config-*"
sleep 1

# Verify wildcard deletion worked
remaining_count=$(count_plans)
echo "Found $remaining_count plans after wildcard deletion"

if [ "$remaining_count" -ne 2 ]; then
    echo "❌ Expected 2 plans after wildcard deletion, but found $remaining_count"
    pdxd plans
    exit 1
fi

for plan in "plan-config-1" "plan-config-2" "plan-config-3"; do
    if check_plan_exists "$plan"; then
        echo "❌ Plan '$plan' should have been deleted"
        exit 1
    fi
done

# Create more plans for range deletion test
echo "Creating plans for range deletion test..."
for plan in "range-test-1" "range-test-2" "range-test-3"; do
    pdxd new -n "$plan"
    if ! check_plan_exists "$plan"; then
        echo "❌ Failed to create plan '$plan'"
        exit 1
    fi
    sleep 1
done

# Test range deletion (should delete first 3 plans)
echo "Testing range deletion..."
echo "y" | pdxd dp "1-3"
sleep 1

# Verify range deletion worked
final_count=$(count_plans)
echo "Found $final_count plans after range deletion"

if [ "$final_count" -ne 2 ]; then
    echo "❌ Expected 2 plans after range deletion, but found $final_count"
    pdxd plans
    exit 1
fi

# Clean up any remaining test plans
echo "Cleaning up remaining test plans..."
echo "y" | pdxd dp "plan-config-*" || true
echo "y" | pdxd dp "other-plan-*" || true
echo "y" | pdxd dp "range-test-*" || true
sleep 2

# Verify all plans were cleaned up
cleanup_count=$(count_plans)
if [ "$cleanup_count" -ne 0 ]; then
    echo "❌ Expected 0 plans after cleanup, but found $cleanup_count"
    pdxd plans
    exit 1
fi

echo "✅ All tests passed!"


================================================
FILE: test/project/react-redux-foobar/action.ts
================================================
export const INCREMENT_COUNT = 'INCREMENT_COUNT';

interface IncrementCountAction {
  type: typeof INCREMENT_COUNT;
  payload: number; // Payload now specifically expects a number
}

export const incrementCount = (amount: number): IncrementCountAction => ({
  type: INCREMENT_COUNT,
  payload: amount,
});


================================================
FILE: test/project/react-redux-foobar/component.ts
================================================
import React, { useState } from 'react';

interface Props {
  name: string;
}

const MyComponent: React.FC<Props> = ({ name }) => {
  const [count, setCount] = useState(0);

  return (
    <div>
      <h1>Hello, {name}!</h1>
      <p>You clicked {count} times</p>
      <button onClick={() => setCount(count + 1)}>
        Click me
      </button>
    </div>
  );
};

export default MyComponent;


================================================
FILE: test/project/react-redux-foobar/lib/constants.ts
================================================
export const SOME_CONSTANT = 'SOME_CONSTANT_VALUE';


================================================
FILE: test/project/react-redux-foobar/lib/utils.ts
================================================
export const formatDate = (date: Date): string => {
  return date.toLocaleDateString('en-US', {
    weekday: 'long', year: 'numeric', month: 'long', day: 'numeric'
  });
}


================================================
FILE: test/project/react-redux-foobar/package.json
================================================
{
  "name": "react-redux-foobar",
  "version": "1.0.0",
  "description": "A realistic React/Redux/TypeScript project",
  "main": "index.js",
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test",
    "eject": "react-scripts eject"
  },
  "dependencies": {
    "@reduxjs/toolkit": "^1.8.0",
    "react": "^18.0.0",
    "react-dom": "^18.0.0",
    "react-redux": "^8.0.0",
    "react-scripts": "5.0.0",
    "typescript": "^4.5.5"
  },
  "devDependencies": {
    "@testing-library/jest-dom": "^5.16.2",
    "@testing-library/react": "^13.2.0",
    "@testing-library/user-event": "^14.2.1",
    "@types/jest": "^27.4.0",
    "@types/node": "^17.0.21",
    "@types/react": "^18.0.0",
    "@types/react-dom": "^18.0.0"
  },
  "eslintConfig": {
    "extends": [
      "react-app",
      "react-app/jest"
    ]
  },
  "browserslist": {
    "production": [
      ">0.2%",
      "not dead",
      "not op_mini all"
    ],
    "development": [
      "last 1 chrome version",
      "last 1 firefox version",
      "last 1 safari version"
    ]
  }
}


================================================
FILE: test/project/react-redux-foobar/reducer.ts
================================================
import { createReducer } from '@reduxjs/toolkit';
import { INCREMENT_COUNT } from './action';

interface State {
  count: number;
}

const initialState: State = {
  count: 0,
};

const countReducer = createReducer(initialState, (builder) => {
  builder.addCase(INCREMENT_COUNT, (state, action) => {
    state.count += action.payload;
  });
});

export default countReducer;


================================================
FILE: test/project/react-redux-foobar/tests/action.test.ts
================================================
import { myAction, MY_ACTION_TYPE } from '../action';

describe('myAction', () => {
  it('creates an action with the correct type and payload', () => {
    const payload = {}; // Define payload
    const expectedAction = {
      type: MY_ACTION_TYPE,
      payload,
    };
    expect(myAction(payload)).toEqual(expectedAction);
  });
});


================================================
FILE: test/project/react-redux-foobar/tests/component.test.ts
================================================
import { render, fireEvent } from '@testing-library/react';  it('increments count on button click', () => {
    const { getByText } = render(<MyComponent name="John Doe" />);
    fireEvent.click(getByText('Click me'));
    expect(getByText('You clicked 1 times')).toBeInTheDocument();
  });
});
import MyComponent from '../component';

describe('MyComponent', () => {
  it('renders with the correct name', () => {
    const { getByText } = render(<MyComponent name="John Doe" />);
    expect(getByText('Hello, John Doe!')).toBeInTheDocument();
  });
});



================================================
FILE: test/project/react-redux-foobar/tsconfig.json
================================================
{
  "compilerOptions": {
    "target": "es5",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "forceConsistentCasingInFileNames": true,
    "module": "esnext",
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "jsx": "react-jsx"
  },
  "include": ["src"]
}


================================================
FILE: test/smoke_test.sh
================================================
#!/bin/bash
# Plandex Smoke Test Script
# Tests core functionality in a linear flow mimicking real usage
# Assumes: Already signed in to Plandex Cloud (dev or staging account)

set -e  # Exit on error

# Source common utilities
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/test_utils.sh"

# Test-specific variables
PROMPT_CREATE_FUNCTION="add a simple hello world function in main.go"
PROMPT_ADD_TEST="add a test for the hello function"
PROMPT_CHAT_QUESTION="what does the hello function do?"
PROMPT_ADD_FEATURE="add a goodbye function that returns: goodbye world"

# Setup for this test
setup() {
    setup_test_dir "smoke-test"
    
    # Create a simple Go project structure
    mkdir -p cmd
    echo "package main" > main.go
    echo "func main() {}" >> main.go
    
    # Create a test file to load as context
    cat > README.md << EOF
# Test Project
This is a test project for Plandex smoke testing.
EOF
}

# Set trap for cleanup on exit
trap cleanup_test_dir EXIT

# Main test flow
main() {
    log "=== Plandex Smoke Test Started at $(date) ==="
    
    setup
    
    # 1. PLAN MANAGEMENT
    log "\n=== Testing Plan Management ==="
    
    # Create new plan with name
    run_plandex_cmd "new -n smoke-test-plan" "Create named plan"
    
    # Check current plan
    run_plandex_cmd "current"
    
    # List plans
    run_plandex_cmd "plans"
    
    # 2. CONTEXT MANAGEMENT
    log "\n=== Testing Context Management ==="
    
    # Load single file
    run_plandex_cmd "load main.go" "Load single file"
    
    # Load with note
    run_plandex_cmd "load -n 'keep code simple and well-commented'" "Load note"
    
    # Load directory tree
    run_plandex_cmd "load . --tree" "Load directory tree"
    
    # List context
    run_plandex_cmd "ls"
    
    # Show specific context
    run_plandex_cmd "show main.go"
    
    # 3. BASIC TASK EXECUTION
    log "\n=== Testing Task Execution ==="

    # Skip changes menu so we don't have to interact with the menu
    run_plandex_cmd "set-config skip-changes-menu true" "Set skip-changes-menu to true"
    
    # Tell command with simple task
    run_plandex_cmd "tell '$PROMPT_CREATE_FUNCTION'" "Execute tell command"
    
    # Check diff
    run_plandex_cmd "diff --git"
    
    # Apply changes
    run_plandex_cmd "apply --auto-exec --debug 2 --skip-commit" "Apply changes"
    
    # Verify file was updated
    check_file "main.go"
    
    # 4. CHAT FUNCTIONALITY
    log "\n=== Testing Chat ==="
    
    # Chat without making changes
    run_plandex_cmd "chat '$PROMPT_CHAT_QUESTION'"
    
    # 5. CONTINUE AND BUILD
    log "\n=== Testing Continue and Build ==="
    
    # Tell another task
    run_plandex_cmd "tell '$PROMPT_ADD_TEST' --no-build" "Tell without building"
    
    # Build pending changes
    run_plandex_cmd "build" "Build pending changes"
    
    # Review and apply
    run_plandex_cmd "diff --git"
    run_plandex_cmd "apply --auto-exec --debug 2 --skip-commit" "Apply test changes"
    
    # 6. BRANCHES
    log "\n=== Testing Branches ==="
    
    # Create and switch to new branch
    run_plandex_cmd "checkout feature-branch -y" "Create new branch"
    
    # Make changes on branch
    run_plandex_cmd "tell '$PROMPT_ADD_FEATURE'" "Add feature on branch"
    run_plandex_cmd "apply --auto-exec --debug 2 --skip-commit" "Apply on branch"
    
    # List branches
    run_plandex_cmd "branches"
    
    # Switch back to main
    run_plandex_cmd "checkout main" "Switch to main branch"
    
    # 7. VERSION CONTROL
    log "\n=== Testing Version Control ==="
    
    # View log
    run_plandex_cmd "log"
    
    # View conversation
    run_plandex_cmd "convo"
    
    # Get current state for rewind test
    REWIND_STEPS=2
    info "Will rewind $REWIND_STEPS steps"
    
    # Rewind
    run_plandex_cmd "rewind $REWIND_STEPS --revert" "Rewind $REWIND_STEPS steps"
    
    # 8. CONFIGURATION
    log "\n=== Testing Configuration ==="
    
    # View current config
    run_plandex_cmd "config"
    
    # Change a setting
    run_plandex_cmd "set-config auto-continue false" "Set auto-continue to false"

    # Change it back
    run_plandex_cmd "set-config auto-continue true" "Set auto-continue to true"
    
    # View models
    run_plandex_cmd "models"
    
    # List model packs
    run_plandex_cmd "model-packs"
    
    # 9. CONTEXT UPDATES
    log "\n=== Testing Context Updates ==="
    
    # Modify a file outside of Plandex
    echo "// Modified outside Plandex" >> main.go
    
    # Update context
    run_plandex_cmd "update" "Update outdated context"
    
    # Remove context
    run_plandex_cmd "rm main.go" "Remove file from context"
    
    # Clear all context
    run_plandex_cmd "clear" "Clear all context"
    
    # 10. REJECT FUNCTIONALITY
    log "\n=== Testing Reject ==="
    
    # Load context again and make changes
    run_plandex_cmd "load . -r" "Reload context"
    run_plandex_cmd "tell 'add a function that has an intentional syntax error'" "Create changes to reject"
    
    # Reject all pending changes
    run_plandex_cmd "reject --all" "Reject all pending changes"
    
    # 11. ARCHIVE FUNCTIONALITY
    log "\n=== Testing Archive ==="
    
    # Archive the plan
    run_plandex_cmd "archive smoke-test-plan" "Archive plan"
    
    # List archived plans
    run_plandex_cmd "plans --archived"
    
    # Unarchive
    run_plandex_cmd "unarchive smoke-test-plan" "Unarchive plan"
    
    # 12. MULTIPLE PLANS
    log "\n=== Testing Multiple Plans ==="
    
    # Create another plan with model pack
    run_plandex_cmd "new -n second-plan --cheap" "Create plan with cheap model pack"
    
    # Switch between plans
    run_plandex_cmd "cd smoke-test-plan" "Switch to first plan"
    run_plandex_cmd "current"
    
    log "\n=== Plandex Smoke Test Completed Successfully at $(date) ==="
}

# Run the tests
main

================================================
FILE: test/test_custom_models.sh
================================================
#!/bin/bash
# custom-models-test.sh - Plandex custom models functionality test

set -e  # Exit on error

# Source common utilities
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/test_utils.sh"

# Setup for this test
setup() {
    setup_test_dir "custom-models-test"
    
    # Create a simple test file
    echo "package main" > main.go
}

# Set trap for cleanup on exit
trap cleanup_test_dir EXIT

# Create custom models JSON matching the GitHub issue
create_custom_models_json() {
    cat > custom-models.json << 'EOF'
{
  "$schema": "https://plandex.ai/schemas/models-input.schema.json",
  "models": [
    {
      "modelId": "custom-claude-4",
      "publisher": "test",
      "description": "Claude 4 Sonnet test",
      "defaultMaxConvoTokens": 15000,
      "maxTokens": 200000,
      "maxOutputTokens": 64000,
      "reservedOutputTokens": 16000,
      "preferredOutputFormat": "xml",
      "hasImageSupport": true,
      "providers": [
        {
          "provider": "openrouter",
          "modelName": "anthropic/claude-sonnet-4"
        }
      ]
    }
  ],
  "modelPacks": [
    {
      "name": "test-pack",
      "description": "Test model pack",
      "$schema": "https://plandex.ai/schemas/model-pack-inline.schema.json",
      "planner": {
        "modelId": "custom-claude-4",
        "largeContextFallback": "custom-claude-4"
      },
      "architect": "custom-claude-4",
      "coder": "custom-claude-4",
      "summarizer": "custom-claude-4",
      "builder": "custom-claude-4",
      "wholeFileBuilder": "custom-claude-4",
      "names": "custom-claude-4",
      "commitMessages": "custom-claude-4",
      "autoContinue": "custom-claude-4"
    }
  ]
}
EOF
}

main() {
    log "=== Plandex Custom Models Test Started at $(date) ==="
    
    setup

    echo "OPENROUTER_API_KEY: $OPENROUTER_API_KEY"

    run_plandex_cmd "new -n custom-model-test" "Create test plan"
    run_plandex_cmd "models" "Show current models"
    
    log "\n=== Testing Custom Models with Custom Provider ==="
    
    create_custom_models_json
    run_plandex_cmd "models custom --file custom-models.json --save" "Import custom models"
    run_plandex_cmd "models available --custom" "List custom models"
    run_plandex_cmd "set-model test-pack" "Set custom model pack"
    
    # test without required API key
    PREV_KEY=$OPENROUTER_API_KEY
    unset OPENROUTER_API_KEY
    expect_plandex_failure "tell 'write a hello world program in Go'" "Tell with custom models (should fail due to missing API key)"
    
    # restore API key
    export OPENROUTER_API_KEY=$PREV_KEY
    run_plandex_cmd "tell 'write a hello world program in Go'" "Tell with custom models"

    log "\n=== Custom Models Test Completed at $(date) ==="
}

# Run the tests
main

================================================
FILE: test/test_prompts/aws-infra.txt
================================================
I want to deploy api infrastructure with the following components:          
                                                                              
These should all be done with the AWS CDK and tied together in              
infra/lib/main.ts. The infra project will need simple, minimalistic package.json and tsconfig.json files in `infra`.                                                          
                                                                            
Please pay close attention to detail and ensure every setting is correct,   
secure, and production ready. At the same time, do not include any          
nonessential attributes or complexity. Keep it as simple as it can be while 
still being correct.                                                        
                                                                            
• A basic VPC                                                               
• Two public subnets that allow outgoing requests                           
• Two private subnets for the database                                      
• An RDS Aurora postgresql database with smallest possible size--just a single
instance with no replicas for now. it should run in the private subnets.    
• An ECR repository where container images can be stored that are loaded by 
the fargate cluster                                                         
• A fargate ECS cluster that runs an image from the ECR repository. just one
replica in the cluster for now                                              
• The fargate cluster should have access to the RDS database. the cluster   
should run in public subnets that can make outgoing requests to the         
internet.                                                                   
• Replicas within the fargate cluster should be able to make requests to    
each other internally- The fargate cluster and RDS should use a secrets     
manager secret for the database credentials.                                
• I need an EFS shared file system that all the fargate cluster containers  
are connected to                                                            
• The fargate containers also need to send emails via SES... please include 
any necessary resources                                                     
                                                                            
please use your best judgement and select reasonable values for all of      
these. the db password should be generated by secrets manager. use defaults 
and best practices.


================================================
FILE: test/test_prompts/pong.txt
================================================
Let's create a basic pong game using C and OpenGL. For now let's make it 1-player pong with the computer as the opponent. Create a basic AI for the computer that will move the paddle up and down based on the ball's position.

Create all the necessary functionality for the project so that it will be ready to compile and run.

Include a script that will install any necessary dependencies that are missing on Mac OSC. Prefer homebrew where possible for package management.

Also include a Makefile that will compile the project.

Include a README.md file that will describe the project and how to run it from the command line.


================================================
FILE: test/test_prompts/robust-logging.txt
================================================
insert simple log statements throughout the operations of the 'app/server/model/plan/tell.go' file so it's easy to track the flow of logic. add detailed and rigorous logging to all branches of control flow. log using log.Printf / log.Println                                                                 
                                                                              
only log key data and don't log anything that will show too large of an     
output. the goal is to be able to follow the flow of the logic, not see *all
* the data.

especially add comprehensive logging to anything related to the 'missingFileResponse' functionality. as well as everything within spitting distance of this code: 
                                                                              
  active.Stream(shared.StreamMessage{ Type:                                   
  shared.StreamMessagePromptMissingFile, MissingFilePath: currentFile, })     
                                                                              
                                // stop stream for now                                                    
                                active.CancelModelStreamFn()                                              
                                                                              
                                // wait for user response to come in                                      
                                userChoice := <-active.MissingFileResponseCh  

================================================
FILE: test/test_prompts/stripe-plan.txt
================================================
I want to integrate this app with Stripe on the backend. For now let’s just concern ourselves with the backend portion (no frontend or client-side logic yet).

I want to start with a single Stripe plan. Assuming IS_CLOUD == “1”, each org should be on this plan after the user converts from a free trial. The price should be $15 per user per month.

We should add functionality to add and remove users.

There should be no proration and no immediate charge when a user is added (or removed). The org will simply be charged once per month based on how many users they have at that point.

We should also add webhook callbacks for charge successful, charge failed, and subscription canceled events. Implement these webhooks and the associated routes.

The Stripe secret key will be available in an environment variable.

Don't add the stripe library dependency. I'll take care of that.

================================================
FILE: test/test_prompts/tic-tac-toe.txt
================================================
Build a complete tic-tac-toe game in rust


================================================
FILE: test/test_utils.sh
================================================
#!/bin/bash
# test-utils.sh - Common utilities for Plandex test scripts

export PLANDEX_ENV='development'

# Colors for output
export RED='\033[0;31m'
export GREEN='\033[0;32m'
export YELLOW='\033[1;33m'
export NC='\033[0m' # No Color

# Default command
export PLANDEX_CMD="${PLANDEX_CMD:-plandex-dev}"

# Logging functions
log() {
    echo -e "$1"
}

success() {
    log "${GREEN}✓ $1${NC}"
}

error() {
    log "${RED}✗ $1${NC}"
    exit 1
}

info() {
    log "${YELLOW}→ $1${NC}"
}

# Run command and check for success
run_cmd() {
    local cmd="$1"
    local description="$2"
    
    info "Running: $cmd"
    
    # Run command and capture output and exit code properly
    set +e  # Temporarily disable exit on error
    output=$(eval "$cmd" 2>&1)
    local exit_code=$?
    set -e  # Re-enable exit on error
    
    # Log the output
    echo "$output"
    
    if [ "$exit_code" -eq 0 ]; then
        success "$description"
    else
        error "$description failed (exit code: $exit_code)"
    fi
}

# Run plandex command
run_plandex_cmd() {
    local cmd="$1"
    local description="$2"
    run_cmd "$PLANDEX_CMD $cmd" "$description"
}

# Run plandex command and check if output contains substring
check_plandex_contains() {
    local cmd="$1"
    local expected="$2"
    local description="$3"
    
    info "Running: $PLANDEX_CMD $cmd"
    
    local output=$($PLANDEX_CMD $cmd 2>&1)
    echo "$output"
    
    if echo "$output" | grep -q "$expected"; then
        success "$description"
    else
        error "$description - expected to find '$expected'"
    fi
}

# Check if command fails (expecting failure)
expect_failure() {
    local cmd="$1"
    local description="$2"
    
    info "Running (expecting failure): $cmd"
    
    # Run the command and capture both output and exit code
    set +e  # Temporarily disable exit on error
    output=$(eval "$cmd" 2>&1)
    local exit_code=$?
    set -e  # Re-enable exit on error
    
    echo "$output"
    
    if [ "$exit_code" -ne 0 ]; then
        success "$description (failed as expected with exit code $exit_code)"
    else
        error "$description should have failed but succeeded (exit code: $exit_code)"
    fi
}

# Expect plandex command to fail
expect_plandex_failure() {
    local cmd="$1"
    local description="$2"
    expect_failure "$PLANDEX_CMD $cmd" "$description"
}

# Check if file exists
check_file() {
    if [ -f "$1" ]; then
        success "File exists: $1"
    else
        error "File missing: $1"
    fi
}

# Setup test environment
setup_test_dir() {
    source ../.env.client-keys

    local test_name="$1"
    TEST_DIR="/tmp/plandex-${test_name}-$$"
    TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    
    info "Setting up test environment in $TEST_DIR"
    mkdir -p "$TEST_DIR"
    cd "$TEST_DIR"
    
    success "Test environment created"
}

# Cleanup function
cleanup_test_dir() {
    info "Cleaning up test environment"
    cd /
    rm -rf "$TEST_DIR"
    success "Cleanup complete"
}