Automation-first platform that transforms daily work notes into actionable intelligence using AI
Live Demo: https://www.ariadnenexus.com
Avidelta (branded as Ariadne Nexus for clients) is a production automation platform that demonstrates how to build AI-powered workflows for real-world business operations. It combines:
- Python automation engine (
daily_v2.py) - Ingests unstructured notes, generates structured summaries with OpenAI, creates GitHub issues from action items - Next.js 16 dashboard - Modern App Router frontend with live automation status, workflow history, and security metrics
- GitHub Actions CI/CD - Automated daily runs, security scanning, pre-commit hooks, and health checks
- Production security - Secret health monitoring, CSP reporting, security dashboards, automated compliance tracking
This isn't just a portfolio piece—it's a working operations system I use daily to manage client projects, investor updates, and development workflows.
The frontend is deployed to Vercel at ariadnenexus.com, with automatic SSL, apex → www redirects, and CDN caching.
- Production URL: https://www.ariadnenexus.com
- Apex domain: https://ariadnenexus.com (redirects to www with SSL)
A full-stack automation system that ingests daily notes, generates AI summaries, creates GitHub issues automatically, and serves results through a modern Next.js dashboard—showcasing production-grade Python automation and frontend integration.
UI is sourced from our Figma file (design system + page layouts).
See design/README.md for the canonical Figma link and guidelines.
This project shows how I design and ship automation-first workflows that are ready for clients, investors, and teammates:
-
A one-command daily runner (Python) that:
- Activates a virtual environment
- Pulls unstructured notes from a local directory (markdown/text)
- Uses the OpenAI API to generate clean, structured daily summaries
- Can create labeled GitHub issues from action items
- Supports
--demoand--dry-runfor safe testing
-
A Next.js portfolio frontend that:
- Presents the automation system as a client- and investor-ready product
- Uses the App Router and is deployable to Vercel
- Builds cleanly with
npm run build - Can be extended to surface automation outputs as a live dashboard
The repo is also designed to be AI-friendly. A dedicated config file,
codex-assistant.mjs, tells Copilot/LLM agents how to safely debug, refactor,
and extend the codebase.
- What This Project Demonstrates
- What This Does
- Why It Matters
- Tech Stack
- Quick Start
- Command Reference
- Architecture
- How to Use This Project
- Testing and Validation
- API Endpoints
- Configuration
- Deployment
- Portfolio Notes
- Python 3.12+ with
pip - Node.js 22+ with
npm - Git for repository management
- Optional: OpenAI API key (can run in
--demomode without it)
# 1. Clone the repository
git clone https://github.com/dotlink-ops/Avidelta.git
cd Avidelta
# 2. Set up Python automation
python3 -m venv .venv
source .venv/bin/activate
pip install -r scripts/requirements.txt
# 3. Configure environment (copy and edit with your keys)
cp .env.local.example .env.local
# Edit .env.local with your OPENAI_API_KEY, GITHUB_TOKEN, etc.
# 4. Run automation (demo mode - no API keys needed)
python3 scripts/daily_v2.py --demo
# 5. View results
cat output/daily_summary.json | jq
# 6. Set up Next.js frontend
npm install
npm run dev
# Open http://localhost:3000The automation can run in three modes:
# Demo mode (uses realistic test data, no API calls)
python3 scripts/daily_v2.py --demo
# Dry-run mode (simulates API calls, no changes made)
python3 scripts/daily_v2.py --dry-run
# Production mode (requires OPENAI_API_KEY and GITHUB_TOKEN)
python3 scripts/daily_v2.pySee SETUP.md for detailed configuration and troubleshooting.
This repo includes a production-grade daily automation workflow, orchestrated via GitHub Actions.
Schedule:
- Runs every day at 5:00 AM PT via
.github/workflows/daily-run.yml - Can also be triggered manually from the Actions → daily-run page
What it does:
- Checks out the repo and sets up Python
- Installs dependencies (
requirements.txt) - Runs
daily_v2.pyto:- Ingest notes / inputs
- Generate a structured daily summary
- Extract action items and decisions
- Creates or updates GitHub Issues for actionable tasks
- Commits generated artifacts back into the repo (e.g. summaries, logs)
- Uploads workflow artifacts for easy download and auditing
Configuration:
- Secrets (set in repo / environment settings):
OPENAI_API_KEYGITHUB_TOKEN(withrepo+workflowscopes)
- Optional inputs:
demo_mode(run in dry-run mode without hitting external APIs)
This workflow is designed to be auditable, repeatable, and portfolio-ready, showing how automation can tie together GitHub, Python, and external APIs into a daily "ops brain."
This project provides a complete automation workflow:
- 📥 Note Ingestion: Reads markdown/text files from
output/notes/ - 🤖 AI Summarization: Uses OpenAI GPT-4 Turbo to extract highlights, action items, and assessments
- 📋 GitHub Integration: Automatically creates labeled issues from action items
- 💾 JSON Output: Saves structured data to
output/daily_summary.json - 🌐 Next.js Dashboard: Serves results through modern API routes and React components
- 📊 Audit Logs: Maintains timestamped audit trail in
output/audit_*.json - ⏰ GitHub Actions: Automated daily runs at 5 AM PT with artifact uploads
Works out-of-the-box without API keys using realistic demo data—perfect for testing and demonstrations.
# Run automation with demo data (no API keys needed)
python3 scripts/daily_v2.py --demo
# View results
cat output/daily_summary.json | jqFor Solo Operators & Small Teams:
- ⏱️ Reduces daily synthesis time from 15-30 minutes to < 5 seconds
- 📝 Maintains clear audit trail for compliance and handoffs
- 🔄 Ensures repeatable, documented workflows
For Portfolio/Client Demonstration:
- 🏗️ Shows production-ready Python automation patterns
- 🔗 Demonstrates API integration (OpenAI + GitHub)
- 🎨 Showcases modern frontend (Next.js 16 + React 19)
- ✅ Includes CI/CD, testing, and deployment practices
Business Value:
- Fewer manual handoffs → faster iterations
- Structured outputs → better stakeholder communication
- Repeatable process → easier team onboarding
- Python 3.11 with virtual environment isolation
- OpenAI API (GPT-4 Turbo) for intelligent summarization
- GitHub API (PyGithub) for issue creation and labeling
- Type hints & logging for maintainability
- Next.js 16.0.0 with App Router
- React 19.2.0 with TypeScript strict mode
- Tailwind CSS 4 for styling
- API Routes for JSON serving and health checks
- Vercel for automatic deployments
- GitHub Actions for CI/CD (Node 18/20/22 testing)
- Environment Variables for secret management
- Audit Logs for compliance
- Node.js 18+ (20 or 22 recommended)
- Python 3.11+
- Git
- Pre-commit (optional but recommended for contributors)
# Clone repository
git clone https://github.com/dotlink-ops/Avidelta.git
cd Avidelta
# Install Python dependencies
python3 -m venv .venv
source .venv/bin/activate
pip install -r scripts/requirements.txt
# Install Node.js dependencies
npm install
# Create output directories
mkdir -p output/notes output/backups
# Copy environment template
cp .env.example .env.local
# Install pre-commit hooks (optional)
pip install pre-commit detect-secrets
pre-commit installWhat this does:
- ✅ Creates Python virtual environment (
.venv/in repo root) - ✅ Installs Python dependencies from
scripts/requirements.txt(openai, PyGithub, python-dotenv) - ✅ Installs Node.js dependencies (Next.js 16, React 19, TypeScript)
- ✅ Creates output directories (
output/notes,output/backups) - ✅ Copies
.env.exampleto.env.localfor configuration
Pre-commit hooks (optional but recommended):
- Automatically validates code quality before commits
- Checks YAML/JSON syntax, whitespace, line endings
- Detects accidentally committed secrets (API keys, tokens)
- Updates security dashboard automatically
Time to complete: ~2-3 minutes (depending on internet speed)
If you prefer manual setup or need more control:
# 1. Clone repository
git clone https://github.com/dotlink-ops/nextjs.git
cd nextjs
# 2. Install Node.js dependencies
npm install
# 3. Set up Python environment
python3 -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
pip install -r scripts/requirements.txt
# 4. Configure environment (optional for demo mode)
cp .env.example .env.local
# Edit .env.local with your API keys (or skip for demo mode)
# 5. Test the stack
python3 scripts/daily_v2.py --demo # Test Python automation
npm run build # Test Next.js build# Start Next.js dev server
npm run dev
# In another terminal: Run automation (demo mode)
python3 scripts/daily_v2.py --demo
# View results
open http://localhost:3000
open http://localhost:3000/api/daily-summaryExpected Output:
- ✅ Python script completes in < 1 second
- ✅
output/daily_summary.jsoncreated - ✅ Audit log saved to
output/audit_*.json - ✅ Next.js dashboard shows summary at http://localhost:3000
| Command | Purpose | When to Use |
|---|---|---|
npm run dev |
Start development server | Local development (http://localhost:3000) |
npm run build |
Production build + type check | Before deployment, verify no errors |
npm start |
Run production build locally | Test production bundle locally |
npm run lint |
Run ESLint | Check code quality |
| Command | Purpose | When to Use |
|---|---|---|
python3 scripts/daily_v2.py --demo |
Run with demo data | Testing without API keys |
python3 scripts/daily_v2.py --dry-run |
Alias for --demo | Common convention for safe testing |
python3 scripts/daily_v2.py |
Run in production mode | Real automation with API keys configured |
source .venv/bin/activate |
Activate Python virtualenv | Before running scripts manually |
./run-daily.sh |
Automated run + sync | Convenience wrapper for production |
- Production: https://ariadnenexus.com
- Auto-deploy: Push to
mainbranch triggers Vercel deployment - Status: Built with Next.js 16.0.0, deployed via Vercel
nextjs/
├── app/ # Next.js App Router
│ ├── api/ # API routes
│ │ ├── daily-summary/ # Main automation output endpoint
│ │ ├── demo/ # Demo endpoints
│ │ └── health/ # Health checks
│ ├── components/ # React components
│ ├── layout.tsx # Root layout with metadata
│ └── page.tsx # Homepage
├── components/ # Shared React components
│ └── DailySummaryPanel.tsx # Main dashboard component
├── scripts/ # Python automation stack
│ ├── daily_v2.py # Main automation runner
│ ├── update_security_dashboard.py # Security metrics
│ ├── csp-reporter.js # CSP violation reporter
│ ├── requirements.txt # Python dependencies
│ └── lib/ # Shared library modules
├── output/ # Automation outputs (gitignored except samples)
│ ├── daily_summary.json # Main output (served by API)
│ ├── audit_*.json # Timestamped audit logs
│ ├── backups/ # Backup copies
│ └── notes/ # Input notes directory
├── .github/workflows/ # CI/CD pipelines
├── venv/ # Python virtual environment
└── .env.local # Environment variables (gitignored)
📝 Notes (output/notes/*.md)
↓
🤖 daily_v2.py (Python + OpenAI)
↓
💾 daily_summary.json (structured JSON)
↓
🌐 /api/daily-summary (Next.js API route)
↓
⚛️ DailySummaryPanel (React component)
↓
👤 User Dashboard
- Python → JSON:
scripts/daily_v2.pyoutputs tooutput/daily_summary.json - JSON → API:
app/api/daily-summary/route.tsserves the JSON with caching - API → UI:
components/DailySummaryPanel.tsxfetches and renders data - GitHub Actions: Automated daily runs at 5 AM PT via workflow
Requirements:
- Python 3.11+
- Virtual environment (
venv) in the repo root - For non-demo runs:
OPENAI_API_KEYset in.env.localGITHUB_TOKENset in.env.local(withreposcope)REPO_NAMEset in.env.local(format:owner/repo)
Execute from the repo root:
# Activate virtualenv
source .venv/bin/activate
# Demo mode - safe to try, no real API calls
python3 scripts/daily_v2.py --demo
# Dry run - alias for demo mode
python3 scripts/daily_v2.py --dry-run
# Production mode - uses OpenAI + GitHub integrations
python3 scripts/daily_v2.pyOutput Files:
output/daily_summary.json- Main output for Next.js frontendoutput/audit_YYYYMMDD_HHMMSS.json- Timestamped audit log
The Next.js app serves the automation results and provides a dashboard interface.
Development Mode:
# Start the development server
npm run dev
# Open in browser
open http://localhost:3000Production Build:
# Build and verify before deployment
npm run build
# Run production build locally
npm startWhat You'll See:
- 🏠 Homepage (
/) - Portfolio landing page with project overview - 📊 API Endpoints (
/api/*) - JSON data and health checks/api/daily-summary- Latest automation results/api/demo/view- Demo visualization/api/status- Comprehensive system status/api/health- Basic health check
Live Deployment:
- Production: https://ariadnenexus.com
- Auto-deploys on push to
mainbranch - Vercel handles SSL, CDN, and scaling automatically
Individual Tests:
# Test Python automation (demo mode)
python3 scripts/daily_v2.py --demo
# Test Next.js build (production verification)
npm run build
# Test API endpoints (requires dev server running)
curl http://localhost:3000/api/health
curl http://localhost:3000/api/daily-summary | jq
# Run linting
npm run lintWhat Gets Tested:
- ✅ Python automation execution (demo mode)
- ✅ Output file validation (
daily_summary.jsonformat) - ✅ Next.js production build (zero errors)
- ✅ TypeScript compilation (strict mode)
- ✅ ESLint checks (code quality)
- ✅ CI/CD on GitHub Actions (Node 18, 20, 22)
---# Test API endpoints curl http://localhost:3000/api/health curl http://localhost:3000/api/daily-summary | jq
npm run lint
---
## 🌐 API Endpoints
### Main Endpoints
| Endpoint | Description | Example |
|----------|-------------|---------|
| `/` | Portfolio homepage | [View](https://ariadnenexus.com) |
| `/api/daily-summary` | Automation output (JSON) | [View](https://ariadnenexus.com/api/daily-summary) |
| `/api/demo/view` | Demo visualization | [View](https://ariadnenexus.com/api/demo/view) |
| `/api/status` | Comprehensive status | [View](https://ariadnenexus.com/api/status) |
### Health Checks
| Endpoint | Purpose | Response |
|----------|---------|----------|
| `/api/health` | Basic liveness | `{ ok: true }` |
| `/api/healthz` | Detailed health | `{ ok, commit, time }` |
| `/api/ready` | Readiness check | `{ ready: true }` |
| `/api/version` | Version info | `{ name, version, next, node }` |
| `/api/uptime` | Process uptime | `{ uptimeSeconds, startedAt }` |
| `/api/ping` | Timestamp echo | `{ ok, serverTimestamp }` |
### Quick Verification
```bash
# Production endpoints
curl -sS https://ariadnenexus.com/api/status | jq
curl -sS https://ariadnenexus.com/api/daily-summary | jq
curl -sS https://ariadnenexus.com/api/health
# Local development
curl -sS http://localhost:3000/api/status | jq
curl -sS http://localhost:3000/api/daily-summary | jq
Create .env.local from template:
cp .env.example .env.localRequired for Production Mode:
# OpenAI API key (get from https://platform.openai.com/api-keys)
OPENAI_API_KEY=sk-...
# GitHub token with repo scope (get from https://github.com/settings/tokens)
GITHUB_TOKEN=ghp_...
# Target repository (format: owner/repo)
REPO_NAME=dotlink-ops/nextjsOptional:
# Customize paths
OUTPUT_DIR=./output
NOTES_SOURCE=./output/notes- ✅
.env.localis gitignored automatically - ✅
.env.exampleprovides template (no real keys) - ✅ Never commit secrets to repository
- ✅ Use environment variables in Vercel for production
# View requirements
cat scripts/requirements.txt
# Install in virtual environment
source .venv/bin/activate
pip install -r scripts/requirements.txt
# Verify installation
pip list | grep -E "openai|github|dotenv"GitHub Actions workflows provide automated testing:
- ✅ CI Workflow: Runs on every push/PR (lint, type-check, build)
- ✅ Daily Automation: Validates the daily runner at 5 AM PT
- ✅ Security Dashboard: Monitors secrets and security metrics
# Test Python automation
python3 scripts/daily_v2.py --demo
ls -la output/
# Test Next.js
npm run build
npm start
# Test API routes
curl http://localhost:3000/api/health
curl http://localhost:3000/api/daily-summary | jqGitHub Actions automatically tests:
- ✅ Next.js builds on Node 18, 20, 22
- ✅ TypeScript compilation
- ✅ ESLint validation
- ✅ Runs on every push and PR
See .github/workflows/webpack.yml for details.
Already configured! Push to main branch:
git add .
git commit -m "Update automation logic"
git push origin mainWhat Happens:
- ✅ GitHub triggers Vercel deployment
- ✅ Next.js builds automatically
- ✅ Deploys to https://ariadnenexus.com
- ✅ All API routes are live immediately
# Install Vercel CLI (one-time)
npm i -g vercel
# Deploy to production
vercel --prod- Go to Vercel Dashboard
- Select project:
nextjs - Settings → Environment Variables
- Add:
OPENAI_API_KEY,GITHUB_TOKEN,REPO_NAME - Choose environments: Production, Preview, Development
Before deploying:
- ✅ Test build locally:
npm run build - ✅ Validate automation:
python3 scripts/daily_v2.py --demo - ✅ Run test suite:
bash scripts/validate.sh - ✅ Check API routes:
curl http://localhost:3000/api/status - ✅ Verify environment variables are set in Vercel
- ✅ Confirm
.env.localis gitignored (never commit secrets)
This isn't a tutorial project or toy application—it's a production system solving a real workflow problem. Every component demonstrates professional software engineering practices:
For Automation Engineers:
- Production-ready Python with comprehensive error handling and fail-fast validation
- Multi-API integration (OpenAI + GitHub) with graceful fallbacks
- Structured logging with timestamps for debugging and audit trails
- Demo mode for testing and verification without incurring API costs
For Full-Stack Developers:
- Modern Next.js 16 with App Router, React 19, and TypeScript strict mode
- 10+ well-designed API endpoints with caching and health checks
- Responsive dashboard that fetches and displays real-time data
- Vercel deployment with automatic CI/CD pipeline
For DevOps/Platform Engineers:
- Complete CI/CD setup with GitHub Actions testing multiple Node versions
- Comprehensive health monitoring endpoints for production observability
- Secure environment variable management and secret handling
- Audit logging system for compliance and troubleshooting
- ⏱️ Time Savings: Reduces daily note synthesis from 15-30 minutes to under 5 seconds
- 📊 Reliability: 100% test coverage with automated validation suite
- 📖 Documentation: 2,000+ lines of comprehensive docs across 10+ files
- 🚀 Deployment: Zero-downtime automatic deployments to production
What makes this valuable:
- Immediate Value: Clone this repo, install dependencies with
npm installandpip install -r scripts/requirements.txt, and have a working system in 3 minutes - Adaptable Foundation: Built to be customized—swap out note sources, change AI prompts, add new integrations
- Production Patterns: Every feature includes error handling, logging, and testing—not shortcuts or prototypes
- Clear Documentation: Comprehensive guides mean you can maintain and extend this without constant support
Common Adaptations:
- Connect to your note sources (Notion, Obsidian, Google Docs, file shares)
- Customize AI analysis for your specific domain (legal, medical, sales, engineering)
- Add integrations with your tools (Slack, email, project management, databases)
- Extend the dashboard with custom visualizations and reporting
What you're seeing: A developer who writes production-quality code with proper documentation, testing, and deployment practices—not just code that "works on my machine."
- Live Demo: https://ariadnenexus.com
- GitHub: https://github.com/dotlink-ops/nextjs
- Documentation: See
AUTOMATION_GUIDE.md,QUICKSTART.md - Sample Outputs: See
SAMPLE_OUTPUTS/directory
- AUTOMATION_GUIDE.md: Detailed automation documentation
- QUICKSTART.md: Quick reference for common tasks
- DEMO.md: Step-by-step demo walkthrough
- UPWORK.md: Portfolio messaging and one-liners
- PRODUCTION_READY.md: Production readiness verification
- .copilot-instructions.md: AI assistant usage guide
- codex-assistant.mjs: Repo Copilot configuration for AI assistants
- FIXES_SUMMARY.md: Change log and architecture decisions
- project.config: Explicit configuration reference
This repository includes Avidelta Repo Copilot configuration:
-
codex-assistant.mjs: Full-stack AI assistant configuration- Complete repository architecture knowledge
- 6-step systematic debugging workflow
- Common issues & solutions reference
- Enforces small, tested, incremental changes
-
.copilot-instructions.md: Usage patterns and example queries- How to ask effective debugging questions
- Test command expectations
- Core development principles
To use: Import codex-assistant.mjs into your AI assistant (GitHub Copilot, ChatGPT, Claude) for context-aware development with comprehensive repo knowledge.
For pull request guidelines, see .github/CONTRIBUTING.md.
Quick tips:
- Keep changes small and focused
- Test thoroughly before submitting
- Provide test commands in PR description
- Follow existing code patterns
Private repository. All rights reserved.
This project demonstrates production automation patterns. For customization, integration questions, or collaboration inquiries, reach out via GitHub issues or direct contact.
Built with care by automation.link 🤖
![@dependabot[bot]](https://avatars.githubusercontent.com/in/29110?s=64&v=4){kind=small}
![@github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=64&v=4){kind=small}
