R2.1.0#62
Uh oh!
There was an error while loading. Please reload this page.
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,22 @@ | ||
| # Codecov Configuration for RepForge (Devasy/RepForge) | ||
| codecov: | ||
| require_ci_to_pass: yes | ||
| coverage: | ||
| precision: 2 | ||
| round: down | ||
| range: "70...100" | ||
| status: | ||
| project: | ||
| default: | ||
| target: auto | ||
| threshold: 1% | ||
| patch: | ||
| default: | ||
| target: auto | ||
| ignore: | ||
| - "**/*.g.dart" | ||
| - "**/*.freezed.dart" | ||
| - "workout-logger/test/**/*" |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -2,20 +2,31 @@ name: Test | ||
| on: | ||
| push: | ||
| branches: | ||
| - main | ||
| - 'r[0-9]+.[0-9]+.*' | ||
| pull_request: | ||
| branches: | ||
| - main | ||
| - 'r[0-9]+.[0-9]+.*' | ||
| release: | ||
| types: [published] | ||
| concurrency: | ||
| group: ${{ github.workflow }}-${{ github.ref }} | ||
| cancel-in-progress: ${{ github.event_name == 'pull_request' }} | ||
| jobs: | ||
| test: | ||
| name: Analyze & Test | ||
| runs-on: ubuntu-latest | ||
| permissions: | ||
| contents: read | ||
| steps: | ||
| - name: Checkout repository | ||
| uses: actions/checkout@v7 | ||
| - name: Set up Flutter | ||
| id: flutter-action | ||
| @@ -28,13 +39,14 @@ jobs: | ||
| pub-cache-key: "flutter-pub-:os:-:channel:-:version:-:arch:-${{ hashFiles('workout-logger/pubspec.lock') }}" | ||
| - name: Install dependencies | ||
| if: steps.flutter-action.outputs.CACHE-HIT != 'true' | ||
| working-directory: ./workout-logger | ||
| run: flutter pub get | ||
Comment on lines
+42
to
44
Contributor There was a problem hiding this comment. 🩺 Stability & Availability | 🟠 Major | ⚡ Quick win 🧩 Analysis chain🏁 Script executed: #!/bin/bashset -euo pipefail
echo"== workflow excerpt =="
sed -n '1,140p' .github/workflows/test.yml 2>/dev/null ||trueechoecho"== related files =="
git ls-files | rg '(^|/)(pubspec\.yaml|\.dart_tool/package_config\.json|workflows/test\.yml)$'||trueechoecho"== pubspec/package_config references =="
rg -n "pubspec|package_config|flutter pub get|CACHE-HIT|flutter-analyz|flutter test" .github workout-logger pubspec.yaml 2>/dev/null ||trueechoecho"== git status =="
git status --shortRepository: Devasy/RepForge Length of output: 3559 🌐 Web query:
💡 Result: The Citations:
🌐 Web query:
💡 Result: In the context of the subosito/flutter-action GitHub Action, CACHE-HIT and PUB-CACHE-HIT are output variables that provide information about the status of the Flutter SDK and Dart pub dependencies caches, respectively [1][2]. These outputs are defined in the action's configuration (action.yaml) to allow users to conditionally execute steps based on whether a cache was restored successfully [1][2]. Specifically: CACHE-HIT: Indicates whether the Flutter SDK cache was a hit (returns 'true' if there is an exact match for the cache key) [1]. PUB-CACHE-HIT: Indicates whether the Dart pub dependencies cache was a hit (returns 'true' if there is an exact match for the cache key) [1]. These values are sourced directly from the cache-hit output of the underlying actions/cache step used within the action [3][4]. They are commonly used in workflow YAML files to skip redundant installation or setup steps, such as bootstrapping dependencies, when a valid cache already exists [2][5]. Example usage in a workflow: - name: Set up Flutter uses: subosito/flutter-action@v2 id: flutter-action with: cache: true pub-cache: true - name: Conditionally run setup if: steps.flutter-action.outputs.PUB-CACHE-HIT!= 'true' run: dart pub get Citations:
🌐 Web query:
💡 Result: Relevant official Dart/Flutter documentation:
The original query returned no exact Run dependency resolution when the Flutter SDK cache hits.
🤖 Prompt for AI Agents | ||
| - name: Analyze | ||
| working-directory: ./workout-logger | ||
| run: | | ||
| set -o pipefail | ||
| # Only fail on errors, ignore warnings and info messages | ||
| flutter analyze --no-fatal-infos --no-fatal-warnings | tee analyze_output.txt | ||
| @@ -53,3 +65,5 @@ jobs: | ||
| with: | ||
| files: workout-logger/coverage/lcov.info | ||
| token: ${{ secrets.CODECOV_TOKEN }} | ||
| slug: Devasy/RepForge | ||
Comment on lines
+68
to
+69
Contributor There was a problem hiding this comment. 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win Remove the added empty line. The configured YAML linter rejects the empty line after 🧰 Tools🪛 YAMLlint (1.37.1)[error] 69-69: too many blank lines (1 > 0) (empty-lines) 🤖 Prompt for AI AgentsSource: Linters/SAST tools | ||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,224 @@ | ||
| # Hive → SQLite Migration + Coach SQL Query Tool — Design Spec | ||
| **Date:** 2026-08-08 | ||
| **Status:** Approved | ||
| **Feature area:** Storage layer (`lib/services/`) + AI Coach tools (`lib/services/ai/`) | ||
| --- | ||
| ## 1. Problem | ||
| The AI Coach (`CoachToolService`) currently exposes ~15 narrow, purpose-built tools (`get_exercise_performance`, `get_workouts_in_range`, etc.), each hand-wrapping a specific `WorkoutProvider`/`PRManager` query. This is fine for known question shapes but can't answer arbitrary analytical questions the model wasn't given a preset tool for (e.g. ad-hoc joins, unusual aggregations, novel filters). | ||
| The fix — a generic SQL query tool — is a poor fit for the current storage layer: RepForge persists to **Hive**, a key-value store with no query language. Any SQL tool would need a translation layer. | ||
| Two paths were considered: | ||
| - **Ephemeral snapshot**: build a throwaway in-memory SQLite mirror on every coach tool call, rebuilt from Hive-backed in-memory lists each time. | ||
| - **Real migration**: replace Hive with SQLite as the actual persistence backend, so the coach's SQL tool queries live data directly with no translation step. | ||
| This spec chooses the second path. `IStorageService` (`lib/services/interfaces/storage_service_interface.dart`) is already a clean DIP boundary — every method takes/returns plain Dart models, no Hive types leak through — so a `SqliteStorageService implements IStorageService` swap is architecturally sound without touching any manager, `WorkoutProvider`, or screen. `MockStorageService` already fulfills the same interface, so the existing test suite is unaffected by the backend swap. | ||
| This is two dependent efforts: (A) migrate the storage backend, (B) add the coach's SQL tool on top of it. (A) is materially riskier — it touches real user data — and is the majority of this spec. | ||
| --- | ||
| ## 2. Goal | ||
| 1. Replace Hive with SQLite (`sqflite`) as RepForge's persistence backend, via a new `SqliteStorageService implements IStorageService`, with a safe, reversible, one-time migration for existing installs. | ||
| 2. Add `run_sql_query` to `CoachToolService`: the model submits a read-only SQL `SELECT`, executed against a dedicated read-only connection to the live database, results returned as JSON rows. | ||
| Non-goals: no UI changes, no new user-facing features, no change to any existing `IStorageService` method signature or manager/provider code. | ||
| --- | ||
| ## 3. Package Choice: `sqflite` | ||
| Considered `sqlite3` (FFI, synchronous) vs `sqflite` (platform channel, async). Chose **`sqflite`**: | ||
| - `IStorageService` is entirely `Future`-based already. `sqflite` runs DB work on a native background thread and returns via `Future` naturally — no extra isolate-management code. `sqlite3` is synchronous on the calling isolate; matching the same non-blocking behavior would require hand-rolling a background isolate, which is unjustified complexity at this app's data scale. | ||
| - `sqflite` supports `rawQuery(sql, args)` / `rawInsert` / `rawUpdate`, so the coach's arbitrary-SQL tool works identically to how it would under `sqlite3`. No capability is lost. | ||
| - No native binary bundling (`sqlite3_flutter_libs`) needed; uses the OS-provided SQLite. | ||
| **Known tradeoff:** `sqflite` uses the Android-bundled SQLite version rather than a pinned one, so very old devices could lack newer SQL features (e.g. window functions, SQLite 3.25+/Android 9+). Accepted as low risk for this app's scale and audience. | ||
| **Test dependency:** add `sqflite_common_ffi` (dev dependency) — required to run `sqflite`-backed code under `flutter test`, since plain `sqflite` needs a real platform binding unavailable off-device. | ||
| --- | ||
| ## 4. Schema | ||
| All tables live in one SQLite database file, created in `onCreate`. | ||
| ```sql | ||
| CREATE TABLE exercises ( | ||
| id TEXT PRIMARY KEY, | ||
| name TEXT NOT NULL, | ||
| category TEXT NOT NULL, -- 'compound' | 'isolation' | ||
| is_custom INTEGER NOT NULL DEFAULT 0, | ||
| available_handles TEXT -- JSON array or NULL | ||
| ); | ||
| CREATE TABLE muscle_groups ( | ||
| id TEXT PRIMARY KEY, | ||
| name TEXT NOT NULL, | ||
| growth_rate REAL NOT NULL DEFAULT 0, | ||
| last_updated TEXT NOT NULL | ||
| ); | ||
| CREATE TABLE exercise_muscle_activations ( | ||
| exercise_id TEXT NOT NULL REFERENCES exercises(id), | ||
| muscle_group_id TEXT NOT NULL, | ||
| activation_percentage INTEGER NOT NULL | ||
Comment on lines
+68
to
+71
Contributor There was a problem hiding this comment. 🗄️ Data Integrity & Integration | 🟠 Major | ⚡ Quick win 🧩 Analysis chain🏁 Script executed: sed -n '50,85p;165,185p' docs/superpowers/specs/2026-08-08-sqlite-migration-and-coach-sql-tool-design.md
rg -n "foreign_keys|openReadOnlyDatabase|singleInstance|PRAGMA|sqflite|settings|personal_records|exercise_muscle_activations" docs lib test .github 2>/dev/null | head -200Repository: Devasy/RepForge Length of output: 7619 🏁 Script executed: cat -n docs/superpowers/specs/2026-08-08-sqlite-migration-and-coach-sql-tool-design.md | sed -n '118,220p'
rg -n "onConfigure|foreign_keys|PRAGMA foreign_keys|openDatabase\\(|openReadOnlyDatabase". --glob '*.dart' --glob '*.md' --glob 'pubspec.yaml'2>/dev/nullRepository: Devasy/RepForge Length of output: 8086 🏁 Script executed: python3 - <<'PY'import sqlite3schema = """CREATE TABLE parent(id TEXT PRIMARY KEY);CREATE TABLE child(parent_id TEXT NOT NULL REFERENCES parent(id));"""def check(connection_name, configure=False): db = sqlite3.connect(":memory:") db.executescript(schema) before = db.execute("PRAGMA foreign_keys").fetchone()[0] if configure: db.execute("PRAGMA foreign_keys = ON") after = db.execute("PRAGMA foreign_keys").fetchone()[0] try: db.execute("INSERT INTO child(parent_id) VALUES ('missing')") db.commit() result = "accepted" except sqlite3.IntegrityError as exc: result = f"rejected: {exc}" print(connection_name, {"before": before, "after": after, "invalid_child_insert": result}) return dbfirst = check("connection_1")second = check("connection_2")configured = check("configured_connection", configure=True)print("connection_1 final foreign_keys:", first.execute("PRAGMA foreign_keys").fetchone()[0])print("connection_2 final foreign_keys:", second.execute("PRAGMA foreign_keys").fetchone()[0])PYRepository: Devasy/RepForge Length of output: 488 Enforce and declare all foreign keys. Configure Add 🤖 Prompt for AI AgentsSource: MCP tools | ||
| ); | ||
| CREATE TABLE routines ( | ||
| id TEXT PRIMARY KEY, | ||
| name TEXT NOT NULL, | ||
| created_at TEXT NOT NULL | ||
| ); | ||
| CREATE TABLE routine_exercises ( | ||
| routine_id TEXT NOT NULL REFERENCES routines(id), | ||
| exercise_id TEXT NOT NULL, | ||
| position INTEGER NOT NULL | ||
| ); | ||
| CREATE TABLE sessions ( | ||
| id TEXT PRIMARY KEY, | ||
| date TEXT NOT NULL, | ||
| routine_id TEXT, | ||
| duration_min INTEGER NOT NULL, | ||
| notes TEXT, | ||
| hc_synced_at TEXT | ||
| ); | ||
| CREATE TABLE exercise_logs ( | ||
| id TEXT PRIMARY KEY, -- synthetic: '${session_id}_${index}' | ||
| session_id TEXT NOT NULL REFERENCES sessions(id), | ||
| exercise_id TEXT NOT NULL, | ||
| notes TEXT, | ||
| handle TEXT | ||
| ); | ||
| CREATE TABLE sets ( | ||
| id TEXT PRIMARY KEY, -- synthetic: '${exercise_log_id}_${index}' | ||
| exercise_log_id TEXT NOT NULL REFERENCES exercise_logs(id), | ||
| weight REAL NOT NULL, | ||
| reps INTEGER NOT NULL, | ||
| is_dropset INTEGER NOT NULL DEFAULT 0, | ||
| drops_json TEXT, -- JSON array of {id, weight, reps} or NULL | ||
| time_taken INTEGER, | ||
| timestamp TEXT NOT NULL, | ||
| assist_weight REAL, | ||
| extra_weight REAL, | ||
| handle TEXT | ||
| ); | ||
| CREATE TABLE targets ( | ||
| id TEXT PRIMARY KEY, | ||
| exercise_id TEXT NOT NULL, | ||
| target_type TEXT NOT NULL, | ||
| target_value REAL NOT NULL, | ||
| current_value REAL NOT NULL DEFAULT 0, | ||
| estimated_completion_date TEXT, | ||
| created_at TEXT NOT NULL, | ||
| is_completed INTEGER NOT NULL DEFAULT 0 | ||
| ); | ||
| CREATE TABLE personal_records ( | ||
| exercise_id TEXT PRIMARY KEY, | ||
| best_weight REAL NOT NULL, | ||
| best_reps INTEGER NOT NULL, | ||
| best_volume REAL NOT NULL, | ||
| achieved_at TEXT NOT NULL | ||
Comment on lines
+128
to
+133
Contributor There was a problem hiding this comment. 🗄️ Data Integrity & Integration | 🟠 Major | 🏗️ Heavy lift Preserve handle-scoped personal records.
🤖 Prompt for AI Agents | ||
| ); | ||
| CREATE TABLE training_programs ( | ||
| id TEXT PRIMARY KEY, | ||
| name TEXT NOT NULL, | ||
| description TEXT, | ||
| total_weeks INTEGER NOT NULL, | ||
| author TEXT, | ||
| is_imported INTEGER NOT NULL DEFAULT 0, | ||
| created_at TEXT NOT NULL, | ||
| phases_json TEXT NOT NULL, -- List<TrainingPhase>.toJson() | ||
| weeks_json TEXT NOT NULL -- List<ProgramWeek>.toJson() | ||
| ); | ||
| CREATE TABLE conversations ( | ||
| id TEXT PRIMARY KEY, | ||
| title TEXT NOT NULL, | ||
| kind TEXT NOT NULL DEFAULT 'coach', | ||
| created_at TEXT NOT NULL, | ||
| updated_at TEXT NOT NULL, | ||
| messages_json TEXT NOT NULL -- List<ChatMessage>.toJson() | ||
| ); | ||
| CREATE TABLE settings ( | ||
| key TEXT PRIMARY KEY, | ||
| value TEXT | ||
| ); | ||
Comment on lines
+157
to
+160
Contributor There was a problem hiding this comment. 🔒 Security & Privacy | 🟠 Major | 🏗️ Heavy lift Exclude secrets from The schema exposes Also applies to: 203-207 🤖 Prompt for AI Agents | ||
| CREATE INDEX idx_sets_exercise_log ON sets(exercise_log_id); | ||
| CREATE INDEX idx_exercise_logs_session ON exercise_logs(session_id); | ||
| CREATE INDEX idx_exercise_logs_exercise ON exercise_logs(exercise_id); | ||
| CREATE INDEX idx_sessions_date ON sessions(date); | ||
| ``` | ||
| **Deliberately not fully normalized:** `training_programs` (phases/weeks/days/exercises) and `conversations` (messages) are stored as JSON-blob columns rather than exploded into child tables. Both are always read/written as a whole object via existing `toJson()`/`fromJson()` methods, never queried piecemeal by any manager or by the coach's SQL tool. Normalizing them would add several more tables for no query benefit — YAGNI. | ||
| --- | ||
| ## 5. `SqliteStorageService` | ||
| New file: `lib/services/sqlite_storage_service.dart`, `class SqliteStorageService implements IStorageService`. | ||
| - `init()`: opens the database (`openDatabase`), runs `onCreate` (schema above) on first creation. | ||
| - Every `IStorageService` method gets a real implementation: entity writes that touch multiple tables (e.g. `saveWorkoutSession` → `sessions` + `exercise_logs` + `sets`) run inside a single `db.transaction()` — delete-then-reinsert child rows for the given parent id, so updates and inserts share one code path. | ||
| - `exportAllData()` / `importData()` keep their existing JSON contract (used by the migration below and by the user-facing export/import feature) — implemented by reading/writing through the same model `toJson()`/`fromJson()` methods already used elsewhere. | ||
| No changes to `IStorageService`'s method signatures. | ||
| --- | ||
| ## 6. Migration & Cutover | ||
| **Goal:** existing installs upgrade from Hive to SQLite exactly once, safely, with no possibility of a half-migrated state. | ||
| 1. On app start, `AppInitializer` (in `main.dart`) checks `settings['storage_migrated_v1']` **in the existing Hive settings box** (the migration hasn't happened yet at this point, so Hive is still authoritative for this check). | ||
| 2. If unset: instantiate both the existing `StorageService` (Hive) and a fresh `SqliteStorageService`. For every entity type, read via the existing, already-correct Hive read methods (`getAllWorkoutSessions()`, `getAllRoutines()`, `getAllTargets()`, `getAllMuscleGroups()`, `getCustomExercises()`, `getAllTrainingPrograms()`, `getAllPersonalRecords()`, `getAllConversations()`, plus raw settings keys) and write each into `SqliteStorageService` through its normal write methods. This trusts only the new write path — reads reuse logic that already works. | ||
| 3. Only if every entity type migrates without throwing: write `storage_migrated_v1 = true` into the Hive settings box. | ||
| 4. From that point on (this launch and all future launches), `AppInitializer` hands `WorkoutProvider` a `SqliteStorageService` instead of `StorageService`. | ||
| 5. If migration throws partway through anything, the flag is never set. The app falls back to `StorageService` (Hive) for that launch, and retries the full migration on the next app start. There is no partial-migration state a user can get stuck in. | ||
| 6. **Hive boxes are never deleted.** They remain on disk indefinitely as a passive backup — the data volume for a personal fitness log is small, so the disk cost is negligible next to the safety value. | ||
Comment on lines
+188
to
+193
Contributor There was a problem hiding this comment. 🗄️ Data Integrity & Integration | 🟠 Major | 🏗️ Heavy lift Make migration retries atomic or reset partial state. The migration writes entities sequentially and sets Run the complete migration in one transaction or delete and recreate the SQLite database before retrying. Add failure tests after each entity type. 🤖 Prompt for AI Agents | ||
| This keeps the app in exactly one of two well-defined states at all times: fully on Hive, or fully on SQLite. | ||
| --- | ||
| ## 7. Coach SQL Tool: `run_sql_query` | ||
| Added to `CoachToolService.buildTools()` / `handleCall()`, alongside (not replacing) the existing curated tools. | ||
| - **Connection:** a dedicated **read-only** `sqflite` connection (`openReadOnlyDatabase`) to the same database file used by `SqliteStorageService`. This is the real safety boundary — the OS/SQLite layer itself refuses writes on this connection, regardless of what SQL text is submitted. | ||
| - **Text validation (defense-in-depth, not the primary guard):** trim the query, strip a single trailing `;`, reject if a second `;` remains (multi-statement), reject case-insensitively if it doesn't start with `SELECT` or `WITH`, reject if it contains `insert|update|delete|drop|alter|create|attach|detach|pragma|vacuum|replace|trigger` as a keyword. | ||
| - **Row cap:** wrap the model's query as `SELECT * FROM (<query>) LIMIT ?` with a default of 200, model-adjustable up to 500 — never trusts a `LIMIT` the model wrote itself. | ||
Comment on lines
+201
to
+205
Contributor There was a problem hiding this comment. 🔒 Security & Privacy | 🟠 Major | 🏗️ Heavy lift 🧩 Analysis chain🏁 Script executed: # Inspect the repository's sqflite dependency and the referenced design context.printf'%s\n''--- dependency declarations ---'
rg -n --glob 'pubspec*.yaml' --glob 'pubspec*.lock''sqflite|sqflite_common'.printf'%s\n''--- referenced design sections ---'
sed -n '180,220p' docs/superpowers/specs/2026-08-08-sqlite-migration-and-coach-sql-tool-design.md
printf'%s\n''--- sqflite API references in the repository ---'
rg -n 'openReadOnlyDatabase|singleInstance|openDatabase'. --glob '!docs/superpowers/specs/2026-08-08-sqlite-migration-and-coach-sql-tool-design.md'Repository: Devasy/RepForge Length of output: 4502 🌐 Web query:
💡 Result: In the sqflite library, the openReadOnlyDatabase function is a convenience method that calls openDatabase with the readOnly parameter set to true [1][2]. Regarding the behavior of singleInstance: 1. Default Behavior: By default, singleInstance is true [1][3][4]. When true, sqflite returns a single database instance for a given path [3][4]. 2. Subsequent Calls: If you call openDatabase or openReadOnlyDatabase with the same path while singleInstance is set to true, the library will return the existing database instance rather than opening a new one [3][4]. 3. Parameter Handling: When singleInstance is true and you re-open an existing database, the library discards all other parameters (such as callbacks) provided in that subsequent call [3][4]. 4. Best Practice: It is strongly recommended to open a database only once [5]. Because openDatabase is asynchronous, you should manage your database instance carefully to avoid race conditions, typically by using a helper pattern to ensure it is initialized only once [5]. If you set singleInstance to false, each call will attempt to open a new connection to the database, which can lead to errors such as "database is locked" (SQLiteDatabaseLockedException), particularly on platforms like Android [5]. Citations:
🏁 Script executed: # Locate any vendored or cached sqflite source without executing repository code.printf'%s\n''--- candidate sqflite source files ---'
find . -type f \( -iname '*sqflite*' -o -path '*/sqflite/*'\) -print | head -200
printf'%s\n''--- lockfile entries ---'
rg -n -A12 -B2 '^ sqflite:|^sqflite:'. --glob '*.lock' --glob 'pubspec*.yaml'Repository: Devasy/RepForge Length of output: 217 🌐 Web query:
💡 Result: The openReadOnlyDatabase function is part of the sqflite library for Dart and Flutter [1]. The singleInstance parameter is a boolean that defaults to true [1]. When set to true, the library returns the existing database instance if one has already been opened for the specified path, rather than creating a new connection [1]. In the context of openReadOnlyDatabase, the function is implemented as follows [1]: Future openReadOnlyDatabase( String path, { bool? singleInstance = true, }) => openDatabase(path, readOnly: true, singleInstance: singleInstance); Citations: Use an isolated read-only
🤖 Prompt for AI AgentsSource: MCP tools | ||
| - **Error handling:** any exception (syntax error, cap violation, etc.) returns `{'error': message}`, matching every other tool's contract — a bad query is a recoverable turn, not a crash. | ||
| - **Function description** embeds the full schema (table + column names, one line each) so the model always has it in context without a separate schema-discovery round trip. | ||
| --- | ||
| ## 8. Testing | ||
| - **`SqliteStorageService`**: new test file, run against an in-memory database via `sqflite_common_ffi` (`databaseFactory = databaseFactoryFfi`, `inMemoryDatabasePath`). Covers every `IStorageService` method, mirroring the existing `MockStorageService`-based test patterns for shape. | ||
| - **Migration**: seed a `StorageService` (Hive, using the existing test Hive setup) with representative data across every entity type, run the migration routine against a fresh in-memory `SqliteStorageService`, assert the data matches, assert the flag is set, assert re-running the migration is a no-op (skips already-migrated). | ||
| - **Existing test suite** (managers, `WorkoutProvider`, screens): unaffected — all depend on `IStorageService`/`MockStorageService`, never the concrete backend. | ||
| - **`run_sql_query`**: valid `SELECT` → correct JSON rows; non-`SELECT` → rejected with error; multi-statement → rejected; row cap enforced; schema-referencing query (e.g. a join across `sessions`/`exercise_logs`/`sets`) returns expected shape. | ||
| --- | ||
| ## 9. Rollout Notes | ||
| - `pubspec.yaml` additions: `sqflite` (runtime), `sqflite_common_ffi` (dev, for tests). | ||
| - `hive`/`hive_flutter` dependencies and `StorageService` (Hive) are **kept**, not removed — they remain the migration source and the pre-migration fallback path indefinitely (or until a future spec decides it's safe to drop them, informed by real-world migration success rates). | ||
| - No changes to `CLAUDE.md`'s documented Hive box list are needed for this spec beyond noting the SQLite migration exists; a follow-up doc update once this ships is reasonable but out of scope here. | ||
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
🩺 Stability & Availability | 🟠 Major | 🏗️ Heavy lift
🧩 Analysis chain
🏁 Script executed:
Repository: Devasy/RepForge
Length of output: 840
🏁 Script executed:
Repository: Devasy/RepForge
Length of output: 10250
🌐 Web query:
Flutter build apk --split-debug-info output location documentation💡 Result:
When running a Flutter build with the --split-debug-info flag, the output location for debug symbols is determined by the directory path you explicitly provide as an argument to the flag [1][2]. The flag syntax is: flutter build --split-debug-info=/ [1][2] Key details regarding the output location: - User-Defined Path: You specify the directory path where Flutter should save the symbol files [1][2]. For example, using --split-debug-info=out/android will create a directory named out/android (relative to your project root) and place the generated symbol files there [3][2]. - Not Automatic: Flutter does not place these symbols in a default build folder unless you explicitly direct it to do so (e.g., --split-debug-info=build/app/outputs/symbols) [3]. - Purpose: This command generates symbol map files (e.g., app.android-arm.symbols), which are essential for de-obfuscating stack traces from crash reports [1][4][5]. - Persistence: It is recommended to store these symbols outside of ephemeral build directories (like the standard build/ folder), as they may be cleared by a flutter clean command [4]. Developers often commit these files to version control or an external symbol storage service to ensure they are available for future debugging sessions [4].
Citations:
Persist the obfuscation symbol files after the APK builds.
Line 140 writes split-debug-info files to
build/app/outputs/symbols, but the following steps only upload and release APK files. Upload or store those symbol files in protected long-term storage before the workflow ends.🤖 Prompt for AI Agents