How jensrot/meeting-minutes-send-summary-to-confluence works
Project type & purpose (what you’re diagramming)
This is a local automation/CLI tool (single-node, not a distributed system) that:
• Reads meeting data directly from Meetily’s local SQLite database (no Meetily server involved).
• Optionally exports meeting summaries to Atlassian Confluence via Confluence REST APIs.
• Supports debugging/export to JSON.
So the “system” is best modeled as a CLI-driven pipeline with:
• Local filesystem + SQLite DB as the primary data source
• Optional external SaaS (Confluence) as the sink
• Env-based configuration and auth
File structure → architectural components
Top-level Python modules clearly map to responsibilities:
• main.py — CLI entrypoint / orchestration (commands: init, list, scrape, export)
• config.py — configuration layer (reads .env, holds constants, validates required config)
• db_scraper.py — data access layer to Meetily’s SQLite DB (queries, transforms into Python objects/dicts)
• confluence_exporter.py — integration layer for Confluence (HTTP client, auth via API token, create/update pages)
• .env.example — configuration template
• requirements.txt — runtime deps (likely requests, python-dotenv, etc.)
• scripts/* — maintenance/test utilities (template tests, token tests, zipping DB/recordings, replace recordings/DB)
This is basically a clean “ports & adapters” style even if not formalized:
• Core workflow in main.py
• Ports: “read meetings” (SQLite) and “export to Confluence” (HTTP API)
• Adapters: db_scraper.py and confluence_exporter.py
Meetily Automation CLI (this project) (the system)
3. Meetily Local Data (SQLite DB on disk; optionally also “recordings” if relevant to scripts)
Confluence Cloud (Atlassian Confluence REST API)
• User → CLI: runs commands (list, scrape, export, init)
• CLI → SQLite DB: read queries
• CLI → Local JSON file: writes JSON output (for scrape)
• CLI → Confluence API: HTTPS requests (create/update page content)
• CLI ← Confluence API: responses (page id, errors)
Annotate:
• “No Meetily server required”
• “Auth: Basic (email + API token) or token header (depending on implementation)”
• “Config from .env”
Level 2 — Container/Component (map to files)
• main.py (CLI / command router)
• config.py (env loader + validation)
• db_scraper.py (SQLite reader / query layer)
• confluence_exporter.py (Confluence client/service)
Relationships:
• main.py → config.py (loads config)
• main.py → db_scraper.py (fetch meetings list/details)
• main.py → confluence_exporter.py (export meeting summary)
• db_scraper.py → SQLite DB file (SQL queries)
• confluence_exporter.py → Confluence REST endpoints (HTTPS)
• filesystem (zip/replace DB/recordings)
• Confluence token test
list
1) User runs python main.py list
2) main.py loads env via config.py
3) main.py calls db_scraper.py to query meetings
4) CLI prints list to stdout
scrape
1) User runs python main.py scrape
2) Config load
3) DB scrape
export
1) User runs python main.py export --meeting-id ...
2) Config load (must include Confluence URL/username/token/space)
3) DB fetch meeting details/summary
4) confluence_exporter.py formats payload and calls Confluence API
5) CLI prints success/failure
Architectural patterns / key design principles
• Single-node local execution (no daemon/service)
• Source-of-truth = SQLite file on disk
• Separation of concerns by module: CLI orchestration vs data access vs external integration vs configuration
• Side-effect boundaries:
• Reads: SQLite
• Writes: Confluence (network) and local JSON (filesystem)
• Config via environment (twelve-factor style, but local)
Relevant technologies (labels matter)
• Python CLI (main.py)
• SQLite (Meetily DB file)
• Confluence REST API (HTTPS)
• .env / environment variables (credentials + space key)
Clear labels
• “CLI Orchestrator (main.py)”
• “SQLite Reader (db_scraper.py)”
• “Confluence Client (confluence_exporter.py)”
• “Config Loader (config.py)”
• Name artifacts precisely:
• “Meetily SQLite DB (meeting_minutes.sqlite)”
• “Local JSON output (debug)”
• “Confluence Space (SPACE_KEY)”
• “SQL (sqlite3)” to DB
• “HTTPS (REST)” to Confluence
“Separate into as many components as possible” (without overthinking)
Given the repo size, the maximum useful granularity is:
• Each top-level .py file as a component
• Each external boundary as its own node (SQLite file, filesystem outputs, Confluence API)
• Scripts grouped as a separate “tooling” area
• Split Confluence into: “Auth (API token)”, “Page create/update endpoint”, “Space”
• Split DB into: “Meetings table(s)”, “Transcripts/Summaries table(s)” (confirm names from db_scraper.py)
That combination will be the most accurate representation of this project’s “architecture” given it’s a CLI integration tool.