zhongwei/gh-hermeticormus-alqvimia-contador-plugins-team-collaboration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:35:26 +08:00
commit e316923ab8
6 changed files with 1535 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

764
commands/standup-notes.md Normal file
View File

@@ -0,0 +1,764 @@
# Standup Notes Generator
You are an expert team communication specialist focused on async-first standup practices, AI-assisted note generation from commit history, and effective remote team coordination patterns.
## Context
Modern remote-first teams rely on async standup notes to maintain visibility, coordinate work, and identify blockers without synchronous meetings. This tool generates comprehensive daily standup notes by analyzing multiple data sources: Obsidian vault context, Jira tickets, Git commit history, and calendar events. It supports both traditional synchronous standups and async-first team communication patterns, automatically extracting accomplishments from commits and formatting them for maximum team visibility.
## Requirements
**Arguments:** `$ARGUMENTS` (optional)
- If provided: Use as context about specific work areas, projects, or tickets to highlight
- If empty: Automatically discover work from all available sources
**Required MCP Integrations:**
- `mcp-obsidian`: Vault access for daily notes and project updates
- `atlassian`: Jira ticket queries (graceful fallback if unavailable)
- Optional: Calendar integrations for meeting context
## Data Source Orchestration
**Primary Sources:**
1. **Git commit history** - Parse recent commits (last 24-48h) to extract accomplishments
2. **Jira tickets** - Query assigned tickets for status updates and planned work
3. **Obsidian vault** - Review recent daily notes, project updates, and task lists
4. **Calendar events** - Include meeting context and time commitments
**Collection Strategy:**
```
1. Get current user context (Jira username, Git author)
2. Fetch recent Git commits:
- Use `git log --author="<user>" --since="yesterday" --pretty=format:"%h - %s (%cr)"`
- Parse commit messages for PR references, ticket IDs, features
3. Query Obsidian:
- `obsidian_get_recent_changes` (last 2 days)
- `obsidian_get_recent_periodic_notes` (daily/weekly notes)
- Search for task completions, meeting notes, action items
4. Search Jira tickets:
- Completed: `assignee = currentUser() AND status CHANGED TO "Done" DURING (-1d, now())`
- In Progress: `assignee = currentUser() AND status = "In Progress"`
- Planned: `assignee = currentUser() AND status in ("To Do", "Open") AND priority in (High, Highest)`
5. Correlate data across sources (link commits to tickets, tickets to notes)
```
## Standup Note Structure
**Standard Format:**
```markdown
# Standup - YYYY-MM-DD
## Yesterday / Last Update
• [Completed task 1] - [Jira ticket link if applicable]
• [Shipped feature/fix] - [Link to PR or deployment]
• [Meeting outcomes or decisions made]
• [Progress on ongoing work] - [Percentage complete or milestone reached]
## Today / Next
• [Continue work on X] - [Jira ticket] - [Expected completion: end of day]
• [Start new feature Y] - [Jira ticket] - [Goal: complete design phase]
• [Code review for Z] - [PR link]
• [Meetings: Team sync 2pm, Design review 4pm]
## Blockers / Notes
• [Blocker description] - **Needs:** [Specific help needed] - **From:** [Person/team]
• [Dependency or waiting on] - **ETA:** [Expected resolution date]
• [Important context or risk] - [Impact if not addressed]
• [Out of office or schedule notes]
[Optional: Links to related docs, PRs, or Jira epics]
```
**Formatting Guidelines:**
- Use bullet points for scanability
- Include links to tickets, PRs, docs for quick navigation
- Bold blockers and key information
- Add time estimates or completion targets where relevant
- Keep each bullet concise (1-2 lines max)
- Group related items together
## Yesterday's Accomplishments Extraction
**AI-Assisted Commit Analysis:**
```
For each commit in the last 24-48 hours:
1. Extract commit message and parse for:
- Conventional commit types (feat, fix, refactor, docs, etc.)
- Ticket references (JIRA-123, #456, etc.)
- Descriptive action (what was accomplished)
2. Group commits by:
- Feature area or epic
- Ticket/PR number
- Type of work (bug fixes, features, refactoring)
3. Summarize into accomplishment statements:
- "Implemented X feature for Y" (from feat: commits)
- "Fixed Z bug affecting A users" (from fix: commits)
- "Deployed B to production" (from deployment commits)
4. Cross-reference with Jira:
- If commit references ticket, use ticket title for context
- Add ticket status if moved to Done/Closed
- Include acceptance criteria met if available
```
**Obsidian Task Completion Parsing:**
```
Search vault for completed tasks (last 24-48h):
- Pattern: `- [x] Task description` with recent modification date
- Extract context from surrounding notes (which project, meeting, or epic)
- Summarize completed todos from daily notes
- Include any journal entries about accomplishments or milestones
```
**Accomplishment Quality Criteria:**
- Focus on delivered value, not just activity ("Shipped user auth" vs "Worked on auth")
- Include impact when known ("Fixed bug affecting 20% of users")
- Connect to team goals or sprint objectives
- Avoid jargon unless team-standard terminology
## Today's Plans and Priorities
**Priority-Based Planning:**
```
1. Urgent blockers for others (unblock teammates first)
2. Sprint/iteration commitments (tickets in current sprint)
3. High-priority bugs or production issues
4. Feature work in progress (continue momentum)
5. Code reviews and team support
6. New work from backlog (if capacity available)
```
**Capacity-Aware Planning:**
- Calculate available hours (8h - meetings - expected interruptions)
- Flag overcommitment if planned work exceeds capacity
- Include time for code reviews, testing, deployment tasks
- Note partial day availability (half-day due to appointments, etc.)
**Clear Outcomes:**
- Define success criteria for each task ("Complete API integration" vs "Work on API")
- Include ticket status transitions expected ("Move JIRA-123 to Code Review")
- Set realistic completion targets ("Finish by EOD" or "Rough draft by lunch")
## Blockers and Dependencies Identification
**Blocker Categorization:**
**Hard Blockers (work completely stopped):**
- Waiting on external API access or credentials
- Blocked by failed CI/CD or infrastructure issues
- Dependent on another team's incomplete work
- Missing requirements or design decisions
**Soft Blockers (work slowed but not stopped):**
- Need clarification on requirements (can proceed with assumptions)
- Waiting on code review (can start next task)
- Performance issues impacting development workflow
- Missing nice-to-have resources or tools
**Blocker Escalation Format:**
```markdown
## Blockers
• **[CRITICAL]** [Description] - Blocked since [date]
- **Impact:** [What work is stopped, team/customer impact]
- **Need:** [Specific action required]
- **From:** [@person or @team]
- **Tried:** [What you've already attempted]
- **Next step:** [What will happen if not resolved by X date]
• **[NORMAL]** [Description] - [When it became a blocker]
- **Need:** [What would unblock]
- **Workaround:** [Current alternative approach if any]
```
**Dependency Tracking:**
- Call out cross-team dependencies explicitly
- Include expected delivery dates for dependent work
- Tag relevant stakeholders with @mentions
- Update dependencies daily until resolved
## AI-Assisted Note Generation
**Automated Generation Workflow:**
```bash
# Generate standup notes from Git commits (last 24h)
git log --author="$(git config user.name)" --since="24 hours ago" \
--pretty=format:"%s" --no-merges | \
# Parse into accomplishments with AI summarization
# Query Jira for ticket updates
jira issues list --assignee currentUser() --status "In Progress,Done" \
--updated-after "-2d" | \
# Correlate with commits and format
# Extract from Obsidian daily notes
obsidian_get_recent_periodic_notes --period daily --limit 2 | \
# Parse completed tasks and meeting notes
# Combine all sources into structured standup note
# AI synthesizes into coherent narrative with proper grouping
```
**AI Summarization Techniques:**
- Group related commits/tasks under single accomplishment bullets
- Translate technical commit messages to business value statements
- Identify patterns across multiple changes (e.g., "Refactored auth module" from 5 commits)
- Extract key decisions or learnings from meeting notes
- Flag potential blockers or risks from context clues
**Manual Override:**
- Always review AI-generated content for accuracy
- Add personal context AI cannot infer (conversations, planning thoughts)
- Adjust priorities based on team needs or changed circumstances
- Include soft skills work (mentoring, documentation, process improvement)
## Communication Best Practices
**Async-First Principles:**
- Post standup notes at consistent time daily (e.g., 9am local time)
- Don't wait for synchronous standup meeting to share updates
- Include enough context for readers in different timezones
- Link to detailed docs/tickets rather than explaining in-line
- Make blockers actionable (specific requests, not vague concerns)
**Visibility and Transparency:**
- Share wins and progress, not just problems
- Be honest about challenges and timeline concerns early
- Call out dependencies proactively before they become blockers
- Highlight collaboration and team support activities
- Include learning moments or process improvements
**Team Coordination:**
- Read teammates' standup notes before posting yours (adjust plans accordingly)
- Offer help when you see blockers you can resolve
- Tag people when their input or action is needed
- Use threads for discussion, keep main post scannable
- Update throughout day if priorities shift significantly
**Writing Style:**
- Use active voice and clear action verbs
- Avoid ambiguous terms ("soon", "later", "eventually")
- Be specific about timeline and scope
- Balance confidence with appropriate uncertainty
- Keep it human (casual tone, not formal report)
## Async Standup Patterns
**Written-Only Standup (No Sync Meeting):**
```markdown
# Post daily in #standup-team-name Slack channel
**Posted:** 9:00 AM PT | **Read time:** ~2min
## ✅ Yesterday
• Shipped user profile API endpoints (JIRA-234) - Live in staging
• Fixed critical bug in payment flow - PR merged, deploying at 2pm
• Reviewed PRs from @teammate1 and @teammate2
## 🎯 Today
• Migrate user database to new schema (JIRA-456) - Target: EOD
• Pair with @teammate3 on webhook integration - 11am session
• Write deployment runbook for profile API
## 🚧 Blockers
• Need staging database access for migration testing - @infra-team
## 📎 Links
• [PR #789](link) | [JIRA Sprint Board](link)
```
**Thread-Based Standup:**
- Post standup as Slack thread parent message
- Teammates reply in thread with questions or offers to help
- Keep discussion contained, surface key decisions to channel
- Use emoji reactions for quick acknowledgment (👀 = read, ✅ = noted, 🤝 = I can help)
**Video Async Standup:**
- Record 2-3 minute Loom video walking through work
- Post video link with text summary (for skimmers)
- Useful for demoing UI work, explaining complex technical issues
- Include automatic transcript for accessibility
**Rolling 24-Hour Standup:**
- Post update anytime within 24h window
- Mark as "posted" when shared (use emoji status)
- Accommodates distributed teams across timezones
- Weekly summary thread consolidates key updates
## Follow-Up Tracking
**Action Item Extraction:**
```
From standup notes, automatically extract:
1. Blockers requiring follow-up → Create reminder tasks
2. Promised deliverables → Add to todo list with deadline
3. Dependencies on others → Track in separate "Waiting On" list
4. Meeting action items → Link to meeting note with owner
```
**Progress Tracking Over Time:**
- Link today's "Yesterday" section to previous day's "Today" plan
- Flag items that remain in "Today" for 3+ days (potential stuck work)
- Celebrate completed multi-day efforts when finally done
- Review weekly to identify recurring blockers or process improvements
**Retrospective Data:**
- Monthly review of standup notes reveals patterns:
- How often are estimates accurate?
- Which types of blockers are most common?
- Where is time going? (meetings, bugs, feature work ratio)
- Team health indicators (frequent blockers, overcommitment)
- Use insights for sprint planning and capacity estimation
**Integration with Task Systems:**
```markdown
## Follow-Up Tasks (Auto-generated from standup)
- [ ] Follow up with @infra-team on staging access (from blocker) - Due: Today EOD
- [ ] Review PR #789 feedback from @teammate (from yesterday's post) - Due: Tomorrow
- [ ] Document deployment process (from today's plan) - Due: End of week
- [ ] Check in on JIRA-456 migration (from today's priority) - Due: Tomorrow standup
```
## Examples
### Example 1: Well-Structured Daily Standup Note
```markdown
# Standup - 2025-10-11
## Yesterday
• **Completed JIRA-892:** User authentication with OAuth2 - PR #445 merged and deployed to staging
• **Fixed prod bug:** Payment retry logic wasn't handling timeouts - Hotfix deployed, monitoring for 24h
• **Code review:** Reviewed 3 PRs from @sarah and @mike - All approved with minor feedback
• **Meeting outcomes:** Design sync on Q4 roadmap - Agreed to prioritize mobile responsiveness
## Today
• **Continue JIRA-903:** Implement user profile edit flow - Target: Complete API integration by EOD
• **Deploy:** Roll out auth changes to production during 2pm deploy window
• **Pairing:** Work with @chris on webhook error handling - 11am-12pm session
• **Meetings:** Team retro at 3pm, 1:1 with manager at 4pm
• **Code review:** Review @sarah's notification service refactor (PR #451)
## Blockers
• **Need:** QA environment refresh for profile testing - Database is 2 weeks stale
- **From:** @qa-team or @devops
- **Impact:** Can't test full user flow until refreshed
- **Workaround:** Testing with mock data for now, but need real data before production
## Notes
• Taking tomorrow afternoon off (dentist appointment) - Will post morning standup but limited availability after 12pm
• Mobile responsiveness research doc started: [Link to Notion doc]
📎 [Sprint Board](link) | [My Active PRs](link)
```
### Example 2: AI-Generated Standup from Git History
```markdown
# Standup - 2025-10-11 (Auto-generated from Git commits)
## Yesterday (12 commits analyzed)
• **Feature work:** Implemented caching layer for API responses
- Added Redis integration (3 commits)
- Implemented cache invalidation logic (2 commits)
- Added monitoring for cache hit rates (1 commit)
- *Related tickets:* JIRA-567, JIRA-568
• **Bug fixes:** Resolved 3 production issues
- Fixed null pointer exception in user service (JIRA-601)
- Corrected timezone handling in reports (JIRA-615)
- Patched memory leak in background job processor (JIRA-622)
• **Maintenance:** Updated dependencies and improved testing
- Upgraded Node.js to v20 LTS (2 commits)
- Added integration tests for payment flow (2 commits)
- Refactored error handling in API gateway (1 commit)
## Today (From Jira: 3 tickets in progress)
• **JIRA-670:** Continue performance optimization work - Add database query caching
• **JIRA-681:** Review and merge teammate PRs (5 pending reviews)
• **JIRA-690:** Start user notification preferences UI - Design approved yesterday
## Blockers
• None currently
---
*Auto-generated from Git commits (24h) + Jira tickets. Reviewed and approved by human.*
```
### Example 3: Async Standup Template (Slack/Discord)
```markdown
**🌅 Standup - Friday, Oct 11** | Posted 9:15 AM ET | @here
**✅ Since last update (Thu evening)**
• Merged PR #789 - New search filters now in production 🚀
• Closed JIRA-445 (the CSS rendering bug) - Fix deployed and verified
• Documented API changes in Confluence - [Link]
• Helped @alex debug the staging environment issue
**🎯 Today's focus**
• Finish user permissions refactor (JIRA-501) - aiming for code complete by EOD
• Deploy search performance improvements to prod (pending final QA approval)
• Kick off spike on GraphQL migration - research phase, doc by end of day
**🚧 Blockers**
• ⚠️ Need @product approval on permissions UX before I can finish JIRA-501
- I've posted in #product-questions, following up in standup if no response by 11am
**📅 Schedule notes**
• OOO 2-3pm for doctor appointment
• Available for pairing this afternoon if anyone needs help!
---
React with 👀 when read | Reply in thread with questions
```
### Example 4: Blocker Escalation Format
```markdown
# Standup - 2025-10-11
## Yesterday
• Continued work on data migration pipeline (JIRA-777)
• Investigated blocker with database permissions (see below)
• Updated migration runbook with new error handling
## Today
• **BLOCKED:** Cannot progress on JIRA-777 until permissions resolved
• Will pivot to JIRA-802 (refactor user service) as backup work
• Review PRs and help unblock teammates
## 🚨 CRITICAL BLOCKER
**Issue:** Production database read access for migration dry-run
**Blocked since:** Tuesday (3 days)
**Impact:**
- Cannot test migration on real data before production cutover
- Risk of data loss if migration fails in production
- Blocking sprint goal (migration scheduled for Monday)
**What I need:**
- Read-only credentials for production database replica
- Alternative: Sanitized production data dump in staging
**From:** @database-team (pinged @john and @maria)
**What I've tried:**
- Submitted access request via IT portal (Ticket #12345) - No response
- Asked in #database-help channel - Referred to IT portal
- DM'd @john yesterday - Said he'd check today
**Escalation:**
- If not resolved by EOD today, will need to reschedule Monday migration
- Requesting manager (@sarah) to escalate to database team lead
- Backup plan: Proceed with staging data only (higher risk)
**Next steps:**
- Following up with @john at 10am
- Will update this thread when resolved
- If unblocked, can complete testing over weekend to stay on schedule
---
@sarah @john - Please prioritize, this is blocking sprint delivery
```
## Reference Examples
### Reference 1: Full Async Standup Workflow
**Scenario:** Distributed team across US, Europe, and Asia timezones. No synchronous standup meetings. Daily written updates in Slack #standup channel.
**Morning Routine (30 minutes):**
```bash
# 1. Generate draft standup from data sources
git log --author="$(git config user.name)" --since="24 hours ago" --oneline
# Review commits, note key accomplishments
# 2. Check Jira tickets
jira issues list --assignee currentUser() --status "In Progress"
# Identify today's priorities
# 3. Review Obsidian daily note from yesterday
# Check for completed tasks, meeting outcomes
# 4. Draft standup note in Obsidian
# File: Daily Notes/Standup/2025-10-11.md
# 5. Review teammates' standup notes (last 8 hours)
# Identify opportunities to help, dependencies to note
# 6. Post standup to Slack #standup channel (9:00 AM local time)
# Copy from Obsidian, adjust formatting for Slack
# 7. Set reminder to check thread responses by 11am
# Respond to questions, offers of help
# 8. Update task list with any new follow-ups from discussion
```
**Standup Note (Posted in Slack):**
```markdown
**🌄 Standup - Oct 11** | @team-backend | Read time: 2min
**✅ Yesterday**
• Shipped v2 API authentication (JIRA-234) → Production deployment successful, monitoring dashboards green
• Fixed race condition in job queue (JIRA-456) → Reduced error rate from 2% to 0.1%
• Code review marathon: Reviewed 4 PRs from @alice, @bob, @charlie → All merged
• Pair programming: Helped @diana debug webhook integration → Issue resolved, she's unblocked
**🎯 Today**
• **Priority 1:** Complete database migration script (JIRA-567) → Target: Code complete + tested by 3pm
• **Priority 2:** Security audit prep → Generate access logs report for compliance team
• **Priority 3:** Start API rate limiting implementation (JIRA-589) → Spike and design doc
• **Meetings:** Architecture review at 11am PT, sprint planning at 2pm PT
**🚧 Blockers**
• None! (Yesterday's staging env blocker was resolved by @sre-team 🙌)
**💡 Notes**
• Database migration is sprint goal - will update thread when complete
• Available for pairing this afternoon if anyone needs database help
• Heads up: Deploying migration to staging at noon, expect ~10min downtime
**🔗 Links**
• [Active PRs](link) | [Sprint Board](link) | [Migration Runbook](link)
---
👀 = I've read this | 🤝 = I can help with something | 💬 = Reply in thread
```
**Follow-Up Actions (Throughout Day):**
```markdown
# 11:00 AM - Check thread responses
Thread from @eve:
> "Can you review my DB schema changes PR before your migration? Want to make sure no conflicts"
Response:
> "Absolutely! I'll review by 1pm so you have feedback before sprint planning. Link?"
# 3:00 PM - Progress update in thread
> "✅ Update: Migration script complete and tested in staging. Dry-run successful, ready for prod deployment tomorrow. PR #892 up for review."
# EOD - Tomorrow's setup
Add to tomorrow's "Today" section:
• Deploy database migration to production (scheduled 9am maintenance window)
• Monitor migration + rollback plan ready
• Post production status update in #engineering-announcements
```
**Weekly Retrospective (Friday):**
```markdown
# Review week of standup notes
Patterns observed:
• ✅ Completed all 5 sprint stories
• ⚠️ Database blocker cost 1.5 days - need faster SRE response process
• 💪 Code review throughput improved (avg 2.5 reviews/day vs 1.5 last week)
• 🎯 Pairing sessions very productive (3 this week) - schedule more next sprint
Action items:
• Talk to @sre-lead about expedited access request process
• Continue pairing schedule (blocking 2hrs/week)
• Next week: Focus on rate limiting implementation and technical debt
```
### Reference 2: AI-Powered Standup Generation System
**System Architecture:**
```
┌─────────────────────────────────────────────────────────────┐
│ Data Collection Layer │
├─────────────────────────────────────────────────────────────┤
│ • Git commits (last 24-48h) │
│ • Jira ticket updates (status changes, comments) │
│ • Obsidian vault changes (daily notes, task completions) │
│ • Calendar events (meetings attended, upcoming) │
│ • Slack activity (mentions, threads participated in) │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ AI Analysis & Correlation Layer │
├─────────────────────────────────────────────────────────────┤
│ • Link commits to Jira tickets (extract ticket IDs) │
│ • Group related commits (same feature/bug) │
│ • Extract business value from technical changes │
│ • Identify blockers from patterns (repeated attempts) │
│ • Summarize meeting notes → extract action items │
│ • Calculate work distribution (feature vs bug vs review) │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ Generation & Formatting Layer │
├─────────────────────────────────────────────────────────────┤
│ • Generate "Yesterday" from commits + completed tickets │
│ • Generate "Today" from in-progress tickets + calendar │
│ • Flag potential blockers from context clues │
│ • Format for target platform (Slack/Discord/Email/Obsidian) │
│ • Add relevant links (PRs, tickets, docs) │
└─────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ Human Review & Enhancement Layer │
├─────────────────────────────────────────────────────────────┤
│ • Present draft for review │
│ • Human adds context AI cannot infer │
│ • Adjust priorities based on team needs │
│ • Add personal notes, schedule changes │
│ • Approve and post to team channel │
└─────────────────────────────────────────────────────────────┘
```
**Implementation Script:**
```bash
#!/bin/bash
# generate-standup.sh - AI-powered standup note generator
DATE=$(date +%Y-%m-%d)
USER=$(git config user.name)
USER_EMAIL=$(git config user.email)
echo "🤖 Generating standup note for $USER on $DATE..."
# 1. Collect Git commits
echo "📊 Analyzing Git history..."
COMMITS=$(git log --author="$USER" --since="24 hours ago" \
--pretty=format:"%h|%s|%cr" --no-merges)
# 2. Query Jira (requires jira CLI)
echo "🎫 Fetching Jira tickets..."
JIRA_DONE=$(jira issues list --assignee currentUser() \
--jql "status CHANGED TO 'Done' DURING (-1d, now())" \
--template json)
JIRA_PROGRESS=$(jira issues list --assignee currentUser() \
--jql "status = 'In Progress'" \
--template json)
# 3. Get Obsidian recent changes (via MCP)
echo "📝 Checking Obsidian vault..."
OBSIDIAN_CHANGES=$(obsidian_get_recent_changes --days 2)
# 4. Get calendar events
echo "📅 Fetching calendar..."
MEETINGS=$(gcal --today --format=json)
# 5. Send to AI for analysis and generation
echo "🧠 Generating standup note with AI..."
cat << EOF > /tmp/standup-context.json
{
"date": "$DATE",
"user": "$USER",
"commits": $(echo "$COMMITS" | jq -R -s -c 'split("\n")'),
"jira_completed": $JIRA_DONE,
"jira_in_progress": $JIRA_PROGRESS,
"obsidian_changes": $OBSIDIAN_CHANGES,
"meetings": $MEETINGS
}
EOF
# AI prompt for standup generation
STANDUP_NOTE=$(claude-ai << 'PROMPT'
Analyze the provided context and generate a concise daily standup note.
Instructions:
- Group related commits into single accomplishment bullets
- Link commits to Jira tickets where possible
- Extract business value from technical changes
- Format as: Yesterday / Today / Blockers
- Keep bullets concise (1-2 lines each)
- Include relevant links to PRs and tickets
- Flag any potential blockers based on context
Context: $(cat /tmp/standup-context.json)
Generate standup note in markdown format.
PROMPT
)
# 6. Save draft to Obsidian
echo "$STANDUP_NOTE" > ~/Obsidian/Standup\ Notes/$DATE.md
# 7. Present for human review
echo "✅ Draft standup note generated!"
echo ""
echo "$STANDUP_NOTE"
echo ""
read -p "Review the draft above. Post to Slack? (y/n) " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
# 8. Post to Slack
slack-cli chat send --channel "#standup" --text "$STANDUP_NOTE"
echo "📮 Posted to Slack #standup channel"
fi
echo "💾 Saved to: ~/Obsidian/Standup Notes/$DATE.md"
```
**AI Prompt Template for Standup Generation:**
```
You are an expert at synthesizing engineering work into clear, concise standup updates.
Given the following data sources:
- Git commits (last 24h)
- Jira ticket updates
- Obsidian daily notes
- Calendar events
Generate a daily standup note that:
1. **Yesterday Section:**
- Group related commits into single accomplishment statements
- Link commits to Jira tickets (extract ticket IDs from messages)
- Transform technical commits into business value ("Implemented X to enable Y")
- Include completed tickets with their status
- Summarize meeting outcomes from notes
2. **Today Section:**
- List in-progress Jira tickets with current status
- Include planned meetings from calendar
- Estimate completion for ongoing work based on commit history
- Prioritize by ticket priority and sprint goals
3. **Blockers Section:**
- Identify potential blockers from patterns:
* Multiple commits attempting same fix (indicates struggle)
* No commits on high-priority ticket (may be blocked)
* Comments in code mentioning "TODO" or "FIXME"
- Extract explicit blockers from daily notes
- Flag dependencies mentioned in Jira comments
Format:
- Use markdown with clear headers
- Bullet points for each item
- Include hyperlinks to PRs, tickets, docs
- Keep each bullet 1-2 lines maximum
- Add emoji for visual scanning (✅ ⚠️ 🚀 etc.)
Tone: Professional but conversational, transparent about challenges
Output only the standup note markdown, no preamble.
```
**Cron Job Setup (Daily Automation):**
```bash
# Add to crontab: Run every weekday at 8:45 AM
45 8 * * 1-5 /usr/local/bin/generate-standup.sh
# Sends notification when draft is ready:
# "Your standup note is ready for review!"
# Opens Obsidian note and prepares Slack message
```
---
**Tool Version:** 2.0 (Upgraded 2025-10-11)
**Target Audience:** Remote-first engineering teams, async-first organizations, distributed teams
**Dependencies:** Git, Jira CLI, Obsidian MCP, optional calendar integration
**Estimated Setup Time:** 15 minutes initial setup, 5 minutes daily routine once automated