flyee 0.1.0

package/core/scripts/prepare_notion_updates.py

@@ -0,0 +1,172 @@
+import re
+import json
+import argparse
+import os
+import sys
+
+# =============================================================================
+# AUTO-FILL MAPPINGS (Generic defaults)
+# =============================================================================
+
+# Default category based on Agent responsible
+DEFAULT_AGENT_TO_CATEGORY = {
+    "frontend-specialist": ["Frontend", "UI/UX"],
+    "backend-specialist": ["Backend", "API"],
+    "mobile-developer": ["Mobile", "Frontend"],
+    "devops-engineer": ["DevOps", "Infra"],
+    "security-auditor": ["Backend", "Security"],
+    "debugger": ["Debug"],
+    "orchestrator": ["Planejamento"],
+    "database-architect": ["Backend", "Database"],
+}
+
+# Story Points based on Estimate
+ESTIMATE_TO_POINTS = {
+    "S": 2,      "XS": 1,
+    "Pequeno": 2,
+    "M": 3,
+    "Médio": 3,
+    "L": 5,
+    "Grande": 5,
+    "XL": 8,
+    "Muito Grande": 8,
+}
+
+def get_category(agent: str, custom_mapping=None) -> list:
+    """Returns category list based on agent."""
+    mapping = custom_mapping or DEFAULT_AGENT_TO_CATEGORY
+    agent_key = agent.lower().replace(" ", "-").split(",")[0].strip()
+    
+    for key, cats in mapping.items():
+        if key in agent_key or agent_key in key:
+            return cats
+    return ["Outros"]
+
+def get_points(estimate: str) -> int:
+    """Returns story points based on estimate."""
+    return ESTIMATE_TO_POINTS.get(estimate, 3)
+
+def parse_markdown_stories(file_path):
+    """Simple parser for Markdown user stories if JSON not provided"""
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    tasks = {}
+    current_task = None
+
+    lines = content.split('\n')
+    for line in lines:
+        m = re.match(r"^### (\d+\.\d+) (.+)", line)
+        if m:
+            if current_task:
+                tasks[current_task['id']] = current_task
+            
+            current_task = {
+                'id': m.group(1),
+                'title': m.group(2).strip(),
+                'content': [],
+                'priority': 'MUST',
+                'estimate': 'S',
+                'agent': 'frontend-specialist'
+            }
+        elif current_task:
+            current_task['content'].append(line)
+            
+            if "**Priority:**" in line:
+                current_task['priority'] = line.split("**Priority:**")[1].strip()
+            if "**Estimate:**" in line:
+                current_task['estimate'] = line.split("**Estimate:**")[1].strip()
+            if "**Agent:**" in line:
+                current_task['agent'] = line.split("**Agent:**")[1].strip()
+
+    if current_task:
+        tasks[current_task['id']] = current_task
+        
+    return tasks
+
+def main():
+    parser = argparse.ArgumentParser(description="Prepare Notion Updates from Stories")
+    parser.add_argument("--input", required=True, help="Input file (Markdown stories or parsed JSON)")
+    parser.add_argument("--database-id", required=True, help="Target Notion Database ID")
+    parser.add_argument("--epic", required=True, help="Epic name for the tasks (e.g. 'Authentication')")
+    parser.add_argument("--id-map", help="JSON file mapping Task IDs to Page IDs (for updates)")
+    parser.add_argument("--output", default="notion_updates.json", help="Output JSON file")
+    
+    args = parser.parse_args()
+
+    # 1. Load Tasks
+    if args.input.endswith('.json'):
+        with open(args.input, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            # Convert list to dict if needed, or assume list format
+            if isinstance(data, list):
+                tasks = {t['id']: t for t in data}
+            else:
+                tasks = data
+    else:
+        tasks = parse_markdown_stories(args.input)
+
+    # 2. Load ID Map (if exists)
+    id_map = {}
+    if args.id_map and os.path.exists(args.id_map):
+        with open(args.id_map, 'r', encoding='utf-8') as f:
+            id_map = json.load(f)
+    
+    print(f"Loaded {len(tasks)} tasks.")
+    if id_map:
+        print(f"Loaded {len(id_map)} ID mappings.")
+
+    updates = []
+    creates = []
+
+    for tid, tdata in tasks.items():
+        # Handle different structures (parsed json vs markdown dict)
+        description = tdata.get('description', "") 
+        if not description and 'content' in tdata:
+             description = "\n".join(tdata['content']).strip()
+
+        agent = tdata.get('agent', 'Pending')
+        estimate = tdata.get('estimate', 'M')
+        priority = tdata.get('priority', 'Medium')
+        title = tdata.get('title', f"{tid} Task")
+
+        props = {
+            "ID": {"rich_text": [{"text": {"content": str(tid)}}]},
+            "Épico": {"select": {"name": args.epic}},
+            "Prioridade": {"select": {"name": priority}},
+            "Estimativa": {"rich_text": [{"text": {"content": estimate}}]},  # Changed to text as per ARCHITECTURE
+            "Agente": {"select": {"name": agent.replace(" + ", ",").split(",")[0].strip()}},
+            "Descrição": {"rich_text": [{"text": {"content": description[:1900]}}]},
+            
+            # Auto-fill
+            "Categoria": {"multi_select": [{"name": "Feature"}]}, # Standardized to Feature
+            "Pontos": {"number": get_points(estimate)},
+            "% Progresso": {"number": 0},
+            "Tags": {"multi_select": [{"name": cat} for cat in get_category(agent)]} # Moved technical tags to Tags
+        }
+        
+        # Check if updating or creating
+        page_id = id_map.get(tid)
+        
+        if page_id:
+            updates.append({"page_id": page_id, "properties": props})
+        else:
+            create_props = props.copy()
+            # Ensure title is set for creation
+            if "Nome da tarefa" not in create_props:
+                 create_props["Nome da tarefa"] = {"title": [{"text": {"content": title}}]}
+            
+            create_props["Status"] = {"status": {"name": "backlog"}}
+            creates.append({"parent": {"database_id": args.database_id}, "properties": create_props})
+
+    # Output
+    output_data = {"updates": updates, "creates": creates}
+    
+    with open(args.output, "w", encoding="utf-8") as f:
+        json.dump(output_data, f, indent=2, ensure_ascii=False)
+
+    print(f"✅ Generated {len(updates)} updates and {len(creates)} creates")
+    print(f"📄 Output written to: {args.output}")
+
+if __name__ == "__main__":
+    main()

package/core/scripts/print_create_payload.py

@@ -0,0 +1,18 @@
+import json
+import sys
+
+target = sys.argv[1]
+with open('notion_updates.json', 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+found = False
+for c in data['creates']:
+    title = c['properties']['Nome da tarefa']['title'][0]['text']['content']
+    if target in title:
+        with open('temp_payload.json', 'w', encoding='utf-8') as out:
+            json.dump(c, out, indent=2, ensure_ascii=False)
+        found = True
+        break
+
+if not found:
+    print(f"Task containing '{target}' not found in creates.")

package/core/scripts/session_manager.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Session Manager - Antigravity Kit
+=================================
+Analyzes project state, detects tech stack, tracks file statistics, and provides
+a summary of the current session.
+
+Usage:
+    python .agent/scripts/session_manager.py status [path]
+    python .agent/scripts/session_manager.py info [path]
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, Any, List
+
+def get_project_root(path: str) -> Path:
+    return Path(path).resolve()
+
+def analyze_package_json(root: Path) -> Dict[str, Any]:
+    pkg_file = root / "package.json"
+    if not pkg_file.exists():
+        return {"type": "unknown", "dependencies": {}}
+    
+    try:
+        with open(pkg_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            
+        deps = data.get("dependencies", {})
+        dev_deps = data.get("devDependencies", {})
+        all_deps = {**deps, **dev_deps}
+        
+        stack = []
+        if "next" in all_deps: stack.append("Next.js")
+        elif "react" in all_deps: stack.append("React")
+        elif "vue" in all_deps: stack.append("Vue")
+        elif "svelte" in all_deps: stack.append("Svelte")
+        elif "express" in all_deps: stack.append("Express")
+        elif "nestjs" in all_deps or "@nestjs/core" in all_deps: stack.append("NestJS")
+        
+        if "tailwindcss" in all_deps: stack.append("Tailwind CSS")
+        if "prisma" in all_deps: stack.append("Prisma")
+        if "typescript" in all_deps: stack.append("TypeScript")
+        
+        return {
+            "name": data.get("name", "unnamed"),
+            "version": data.get("version", "0.0.0"),
+            "stack": stack,
+            "scripts": list(data.get("scripts", {}).keys())
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+def count_files(root: Path) -> Dict[str, int]:
+    stats = {"created": 0, "modified": 0, "total": 0}
+    # Simple count for now, comprehensive tracking would require git diff or extensive history
+    exclude = {".git", "node_modules", ".next", "dist", "build", ".agent", ".gemini", "__pycache__"}
+    
+    for root_dir, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in exclude]
+        stats["total"] += len(files)
+        
+    return stats
+
+def detect_features(root: Path) -> List[str]:
+    # Heuristic: look at folder names in src/
+    features = []
+    src = root / "src"
+    if src.exists():
+        possible_dirs = ["components", "modules", "features", "app", "pages", "services"]
+        for d in possible_dirs:
+            p = src / d
+            if p.exists() and p.is_dir():
+                # List subdirectories as likely features
+                for child in p.iterdir():
+                    if child.is_dir():
+                        features.append(child.name)
+    return features[:10] # Limit to top 10
+
+def print_status(root: Path):
+    info = analyze_package_json(root)
+    stats = count_files(root)
+    features = detect_features(root)
+    
+    print("\n=== Project Status ===")
+    print(f"\n📁 Project: {info.get('name', root.name)}")
+    print(f"📂 Path: {root}")
+    print(f"🏷️  Type: {', '.join(info.get('stack', ['Generic']))}")
+    print(f"📊 Status: Active")
+    
+    print("\n🔧 Tech Stack:")
+    for tech in info.get('stack', []):
+        print(f"   • {tech}")
+        
+    print(f"\n✅ Detected Modules/Features ({len(features)}):")
+    for feat in features:
+        print(f"   • {feat}")
+    if not features:
+        print("   (No distinct feature modules detected)")
+        
+    print(f"\n📄 Files: {stats['total']} total files tracked")
+    print("\n====================\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Session Manager")
+    parser.add_argument("command", choices=["status", "info"], help="Command to run")
+    parser.add_argument("path", nargs="?", default=".", help="Project path")
+    
+    args = parser.parse_args()
+    root = get_project_root(args.path)
+    
+    if args.command == "status":
+        print_status(root)
+    elif args.command == "info":
+        print(json.dumps(analyze_package_json(root), indent=2))
+
+if __name__ == "__main__":
+    main()

package/core/scripts/task_complete.py

@@ -0,0 +1,127 @@
+
+import sys
+import os
+import argparse
+import re
+
+def update_task_md(file_path: str, task_id: str):
+    """Updates the tabular status in task.md"""
+    if not os.path.exists(file_path):
+        return False
+        
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+        
+    lines = content.split('\n')
+    new_lines = []
+    updated = False
+    
+    # Regex to match | 1 | or | 1.1 |
+    # Matches: pipe, space, id, space, pipe
+    # Using strict check for the ID column
+    
+    for line in lines:
+        if line.strip().startswith('|'):
+            parts = [p.strip() for p in line.split('|')]
+            # parts[0] is empty (before first pipe), parts[1] is ID
+            if len(parts) > 2 and parts[1] == str(task_id):
+                # Found the row. Update last column (Status)
+                # Assuming standard 5-6 column layout. 
+                # Let's rebuild the line carefully retaining structure if possible, 
+                # or just replacing the last part.
+                # Easiest: Replace the last column content.
+                if "✅ Complete" not in parts[-2]: # Check status column (ignoring empty last part)
+                     # Reconstruct line: replace last segment
+                     # This is brittle if columns change. Let's use simple logic: replace last pipe content
+                     last_pipe_index = line.rfind('|')
+                     second_last_pipe = line.rfind('|', 0, last_pipe_index)
+                     if second_last_pipe != -1:
+                        new_line = line[:second_last_pipe] + "| ✅ Complete |"
+                        new_lines.append(new_line)
+                        updated = True
+                        continue
+        new_lines.append(line)
+        
+    if updated:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(new_lines))
+        print(f"✅ Updated task.md for Task {task_id}")
+    return updated
+
+def update_project_progress(file_path: str, task_id: str):
+    """Updates inline status in PROJECT-PROGRESS.md e.g. #1 -> #1 ✅"""
+    if not os.path.exists(file_path):
+        print(f"⚠️ {file_path} not found.")
+        return False
+
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Check if already marked
+    # Pattern: #{task_id} followed by check or ✅
+    # Regex: #{task_id}(?![^|\n]*✅) - negative lookahead is tricky with other text
+    
+    # Simple approach: Find "#{task_id}" not followed closely by "✅"
+    updated_content = content
+    pattern = rf"#{task_id}(?![:\s-]*✅)"
+    
+    # If we find specifically "#{task_id}" and it doesn't have a check next to it
+    # We replace it with "#{task_id} ✅"
+    # But wait, the format is "#1-#4...". 
+    # If tasks are grouped "#1-#4", verifying individual task #2 is hard.
+    # However, sometimes they are listed individually.
+    
+    # If found individual marker:
+    if re.search(rf"#{task_id}\b", content):
+        # Naive replacement: #{id} -> #{id} ✅
+        # But we must avoid double checking
+        updated_content = re.sub(rf"(#{task_id})\b(?![:\s-]*✅)", r"\1 ✅", content)
+    
+    if updated_content != content:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(updated_content)
+        print(f"✅ Updated PROJECT-PROGRESS.md for Task {task_id}")
+        return True
+    else:
+        print(f"ℹ️  Task {task_id} not found or already marked in PROJECT-PROGRESS.md")
+        return False
+
+def main():
+    parser = argparse.ArgumentParser(description="Automate Task Completion")
+    parser.add_argument("task_id", help="Task ID (e.g. 1)")
+    parser.add_argument("time_spent", help="Time spent (e.g. '1h')")
+    parser.add_argument("summary", help="Summary message")
+    parser.add_argument("--project-root", default=".", help="Project root directory")
+    
+    args = parser.parse_args()
+    
+    # Update local files
+    # 1. task.md (Artifact)
+    # The artifact might be in a variable path, but usually we know the relative path or it's in the brain dir.
+    # We will search for task.md in the current directory or standard paths.
+    
+    # Since we are running from root, let's try to find task.md
+    task_md_path = None
+    # Search recursively for task.md? No, usually in .brain or docs or root
+    # For now, let's assume the user passes absolute path or we look in typical spots
+    # In this environment, task.md is in the ephemeral brain dir.
+    # We can try to find it using `fd` logic or just checking known artifact path provided in memory?
+    # Actually, the agent knows the path. But the script doesn't.
+    # Hack: Update the script to look into the 'brain' folder if it knows it, or just scan current dir and subdirs
+    
+    # For PROJECT-PROGRESS.md it is in docs/
+    proj_progress_path = os.path.join(args.project_root, "docs", "PROJECT-PROGRESS.md")
+    update_project_progress(proj_progress_path, args.task_id)
+
+    # Output Instructions for Agent
+    print(f"\n📢 ACTION REQUIRED: Run bridge.py to sync with Flyee")
+    print(f"----------------------------------------")
+    print(f"TASK ID: {args.task_id}")
+    print(f"TIME: {args.time_spent}")
+    print(f"SUMMARY: {args.summary}")
+    print(f"----------------------------------------")
+    print("Run: python3 .agent/flyee-bridge/bridge.py --update-task <flyee-id> --status completed --result success")
+    print("Then: update docs/INDEX.md if any documents were created during this task.")
+
+if __name__ == "__main__":
+    main()