Startup Legal Fundamentals: A Practical Guide

import subprocess

class DelawareCCorpFormation:
    """Steps to form a Delaware C Corporation."""
    
    STEPS = [
        {
            "step": 1,
            "name": "Name Search",
            "description": "Check name availability on Delaware Division of Corporations",
            "action": "Search: https://corp.delaware.gov",
            "cost": "Free"
        },
        {
            "step": 2,
            "name": "Reserve Name",
            "description": "Optionally reserve name for 120 days",
            "action": "File online or through registered agent",
            "cost": "$75-250"
        },
        {
            "step": 3,
            "name": "File Certificate of Incorporation",
            "description": "File with Delaware Division of Corporations",
            "action": "File online at corps.delaware.gov",
            "cost": "$89-200+ (state fees)",
            "fields": {
                "company_name": "Your Company Name",
                "registered_agent": "Name and address",
                "authorized_shares": "Typically 10,000,000",
                "registered_agent": "Delaware registered agent"
            }
        },
        {
            "step": 4,
            "name": "Obtain EIN",
            "description": "Get Employer Identification Number from IRS",
            "action": "Apply online at irs.gov",
            "cost": "Free"
        },
        {
            "step": 5,
            "name": "Corporate Bylaws",
            "description": "Create internal governance documents",
            "action": "Draft or use template",
            "cost": "$0-2000"
        },
        {
            "step": 6,
            "name": "Initial Resolutions",
            "description": "Board resolutions for initial actions",
            "action": "Document key initial decisions",
            "cost": "$0-1000"
        },
        {
            "step": 7,
            "name": "Issue Stock",
            "description": "Issue initial shares to founders",
            "action": "Prepare stock certificates and buyout agreements",
            "cost": "$0-500"
        },
        {
            "step": 8,
            "name": "Register in Other States",
            "description": "Foreign qualification where operating",
            "action": "File in each state of operation",
            "cost": "$50-500 per state"
        }
    ]
    
    def print_checklist(self):
        for step in self.STEPS:
            print(f"\n{step['step']}. {step['name']}")
            print(f"   {step['description']}")
            print(f"   Action: {step['action']}")
            print(f"   Cost: {step['cost']}")

DELAWARE_BENEFITS = {
    "taxes": {
        "corporate_income_tax": "8.4% (graduated)",
        "no_state_corporate_income_tax": "For companies not operating in DE",
        "no_personal_income_tax": "For non-residents"
    },
    "business_law": {
        "court_of_chancery": "Specialized business court",
        "well_developed_precedent": "Predictable outcomes",
        "flexible_corporate_structure": "Founder-friendly"
    },
    "investor_expectations": {
        "vc_familiarity": "Standard for VC-backed startups",
        "preferred_terms": "Known by most investors",
        "Easy_compliance": "Annual franchise tax only"
    }
}

def should_incorporate_in_delaware(company_location: str, 
                                    is_saas: bool,
                                    seeking_vc: bool) -> dict:
    """Determine if Delaware incorporation makes sense."""
    
    reasons_for_delaware = []
    reasons_against_delaware = []
    
    if seeking_vc:
        reasons_for_delaware.append("VCs expect Delaware incorporation")
        
    if is_saas:
        reasons_for_delaware.append("Remote team common in SaaS")
    
    if company_location == company_location.upper():
        # If primarily in California
        if "CA" in company_location:
            reasons_against_delaware.append("May need to pay CA franchise tax anyway")
    
    return {
        "recommendation": "Delaware" if len(reasons_for_delaware) > 0 else "Home state",
        "reasons_for": reasons_for_delaware,
        "reasons_against": reasons_against_delaware
    }

from dataclasses import dataclass
from enum import Enum
from datetime import datetime

class IPType(Enum):
    PATENT = "patent"
    TRADEMARK = "trademark"
    COPYRIGHT = "copyright"
    TRADE_SECRET = "trade_secret"

@dataclass
class IPAsset:
    name: str
    ip_type: IPType
    description: str
    registration_status: str
    filing_date: datetime = None
    registration_date: datetime = None
    expiration_date: datetime = None
    
class IPProtectionStrategy:
    """Manage startup IP protection."""
    
    def __init__(self):
        self.assets = []
        
    def register_trademark(self, name: str, description: str) -> IPAsset:
        """Register trademark with USPTO."""
        asset = IPAsset(
            name=name,
            ip_type=IPType.TRADEMARK,
            description=description,
            registration_status="pending"
        )
        
        # File trademark application
        # - Search existing trademarks
        # - File intent-to-use or actual use application
        # - Respond to office actions
        
        self.assets.append(asset)
        return asset
    
    def register_copyright(self, work: str, description: str) -> IPAsset:
        """Copyright registration (optional for protection)."""
        asset = IPAsset(
            name=work,
            ip_type=IPType.COPYRIGHT,
            description=description,
            registration_status="automatic"
        )
        
        # Copyright exists automatically upon creation
        # Registration provides additional protections
        
        self.assets.append(asset)
        return asset
    
    def document_trade_secrets(self, secrets: list) -> list:
        """Document trade secrets for protection."""
        documented = []
        
        for secret in secrets:
            asset = IPAsset(
                name=secret["name"],
                ip_type=IPType.TRADE_SECRET,
                description=secret["description"],
                registration_status="documented"
            )
            
            # Implement protection measures
            # - NDA agreements
            # - Access controls
            # - Confidentiality policies
            
            documented.append(asset)
            self.assets.append(asset)
            
        return documented
    
    def get_ip_summary(self) -> dict:
        """Get summary of IP protection status."""
        return {
            "total_assets": len(self.assets),
            "patents": len([a for a in self.assets if a.ip_type == IPType.PATENT]),
            "trademarks": len([a for a in self.assets if a.ip_type == IPType.TRADEMARK]),
            "copyrights": len([a for a in self.assets if a.ip_type == IPType.COPYRIGHT]),
            "trade_secrets": len([a for a in self.assets if a.ip_type == IPType.TRADE_SECRET])
        }

INTELLECTUAL_PROPERTY_ASSIGNMENT = """
INTELLECTUAL PROPERTY ASSIGNMENT AGREEMENT

This Intellectual Property Assignment Agreement ("Agreement") is entered into 
as of [DATE] by and between:

ASSIGNOR: [Founder Name] ("Assignor")
ASSIGNEE: [Company Name], a Delaware corporation ("Company")

RECITALS

WHEREAS, Assignor has developed or contributed to certain intellectual 
property related to the Company's business;

NOW, THEREFORE, in consideration of the mutual covenants contained herein, 
the parties agree as follows:

1. ASSIGNMENT OF INTELLECTUAL PROPERTY

Assignor hereby irrevocably assigns, transfers, and conveys to Company 
all right, title, and interest in and to all Intellectual Property, 
including without limitation:

a) All patents, patent applications, and inventions
b) All trademarks, service marks, and trade names  
c) All copyrights and copyrightable works
d) All trade secrets and confidential information
e) All source code, documentation, and technical data

2. WORK FOR HIRE

Assignor acknowledges that all work product created by Assignor in 
connection with Company's business constitutes "work made for hire" 
under copyright law, with all rights belonging to Company.

3. FURTHER ASSURANCES

Assignor agrees to execute any additional documents reasonably 
necessary to perfect Company's ownership of the assigned IP.

4. CONSIDERATION

[Specify consideration - employment, equity, or one-time payment]

SIGNATURES:

_________________________    Date: _________
[Founder Name]

_________________________    Date: _________  
[Company Name]
"""

FOUNDER_VESTING_TEMPLATE = """
FOUNDER STOCK AGREEMENT - KEY TERMS

1. TOTAL SHARES: [X] shares of Common Stock

2. VESTING SCHEDULE:
   - 4-year vesting period
   - 1-year cliff (25% vests at 12 months)
   - Monthly vesting thereafter (1/48 per month)
   
3. ACCELERATION:
   - Single trigger: [None / Partial / Full] upon acquisition
   - Double trigger: [Yes/No] - acceleration upon termination 
     without cause following acquisition

4. GOOD LEAVE PROVISIONS:
   - Vesting continues during approved leave
   - [Specify any modifications]

5. RE-PURCHASE RIGHTS:
   - Company right to repurchase unvested shares upon 
     termination for cause
   - Fair market value for termination without cause

6. DRAG-ALONG RIGHTS:
   - Majority shareholders can require participation in sale

7. RIGHT OF FIRST REFUSAL:
   - Company then other shareholders have first right to purchase
"""

def handle_founder_dispute(dispute_type: str, founders: list) -> str:
    """Recommended dispute resolution process."""
    
    resolution_steps = {
        "strategic_disagreement": [
            "1. Direct discussion between founders",
            "2. Mediated conversation with coach",
            "3. Vote (if agreement exists on process)",
            "4. Board arbitration",
            "5. External mediation/arbitration"
        ],
        "performance_issues": [
            "1. Document concerns",
            "2. Direct feedback conversation",
            "3. Performance improvement plan",
            "4. Board involvement",
            "5. Separation/buyout"
        ],
        "departure": [
            "1. Notice period",
            "2. Transition planning",
            "3. Equity determination per agreement",
            "4. Intellectual property handling",
            "5. Non-compete review"
        ]
    }
    
    return resolution_steps.get(dispute_type, resolution_steps["strategic_disagreement"])

EMPLOYMENT_TERMS_TEMPLATE = """
EMPLOYMENT AGREEMENT - KEY PROVISIONS

1. POSITION AND DUTIES
   - Title: [Job Title]
   - Reports to: [Manager]
   - Responsibilities: [Brief description]

2. COMPENSATION
   - Base Salary: $[Amount] per year
   - Equity: [Number] options subject to vesting
   - Bonus: [Percentage] target annual bonus

3. EQUITY COMPENSATION  
   - Options: [Number] shares
   - Exercise Price: [FMV at grant date]
   - Vesting: 4-year, 1-year cliff
   - Acceleration: [Specify if any]

4. BENEFITS
   - Health insurance
   - 401(k) with match
   - PTO: [Days] per year

5. TERMINATION
   - At-will employment
   - [Notice period]
   - Severance: [If any]
   
6. PROTECTIVE COVENANTS
   - Non-compete: [Duration] in [Geography]
   - Non-solicitation: [Duration]
   - Confidentiality: Perpetual
"""

class WorkerClassification:
    """Determine worker classification."""
    
    FACTORS = {
        "behavioral": [
            "Control over how work is performed",
            "Training provided",
            "Integration into business"
        ],
        "financial": [
            "Who provides equipment",
            "Opportunity for profit/loss",
            "Reimbursed expenses",
            "Payment method (hourly vs project)"
        ],
        "relationship": [
            "Written agreement",
            "Benefits provided",
            "Length of relationship"
        ]
    }
    
    def classify(self, worker_info: dict) -> str:
        """Determine if worker is employee or contractor."""
        
        employee_score = 0
        contractor_score = 0
        
        # Check each factor
        if worker_info.get("company_provides_training"):
            employee_score += 1
        if worker_info.get("worker_sets_hours"):
            contractor_score += 1
        if worker_info.get("worker_uses_own_equipment"):
            contractor_score += 1
        if worker_info.get("integrated_into_company"):
            employee_score += 1
            
        return "Employee" if employee_score > contractor_score else "Contractor"
    
    def get_compliance_checklist(self, classification: str) -> list:
        if classification == "Employee":
            return [
                "W-4 form",
                "I-9 form with identity documentation",
                "State withholding forms",
                "Enroll in benefits",
                "Employment agreement",
                "Confidentiality agreement",
                "Proprietary information agreement"
            ]
        else:
            return [
                "W-9 form",
                "Independent contractor agreement",
                "NDA",
                "IP assignment",
                "Statement of work for each project",
                "Invoice and payment procedures"
            ]

TERMS_OF_SERVICE_OUTLINE = """
TABLE OF CONTENTS

1. ACCEPTANCE OF TERMS
2. DESCRIPTION OF SERVICE
3. USER OBLIGATIONS
4. ACCOUNT REGISTRATION
5. PAYMENT TERMS
6. INTELLECTUAL PROPERTY RIGHTS
7. USER CONTENT
8. PROHIBITED USES
9. TERMINATION
10. DISCLAIMER OF WARRANTIES
11. LIMITATION OF LIABILITY
12. INDEMNIFICATION
13. PRIVACY POLICY
14. DATA PROCESSING (GDPR/CCPA)
15. DISPUTE RESOLUTION
16. GOVERNING LAW
17. MISCELLANEOUS

KEY PROVISIONS TO INCLUDE:

PAYMENT:
- Subscription tiers and pricing
- Billing cycles
- Refund policy
- Late payment consequences

LIABILITY:
- Cap liability at [X] months of fees
- Exclude consequential damages
- Require immediate notification of issues

IP:
- Company owns all IP in platform
- User retains ownership of their data
- License to use data for service improvement

TERMINATION:
- User can cancel with [notice]
- Company can terminate for breach
- Data retrieval available for [period] post-termination
"""

def generate_privacy_policy(company_info: dict, data_types: list) -> str:
    """Generate privacy policy based on data collected."""
    
    sections = [
        "1. INFORMATION WE COLLECT",
        "2. HOW WE USE INFORMATION",
        "3. INFORMATION SHARING",
        "4. DATA SECURITY",
        "5. USER RIGHTS (GDPR/CCPA)",
        "6. CHILDREN'S PRIVACY",
        "7. INTERNATIONAL TRANSFERS",
        "8. CHANGES TO POLICY",
        "9. CONTACT INFORMATION"
    ]
    
    # Add data-specific sections
    if "cookies" in data_types:
        sections.append("10. COOKIE POLICY")
    if "payment" in data_types:
        sections.append("11. PAYMENT PROCESSING")
    if "third_party_analytics" in data_types:
        sections.append("12. THIRD-PARTY ANALYTICS")
        
    return "\n\n".join(sections)

class DataComplianceChecker:
    """Check compliance with data protection regulations."""
    
    REGULATIONS = {
        "GDPR": {
            "applies_to": ["EU residents", "EU-based companies"],
            "requirements": [
                "Lawful basis for processing",
                "Privacy notice",
                "Data subject rights",
                "Data protection officer (in some cases)",
                "Breach notification within 72 hours",
                "Data processing agreements with vendors",
                "Records of processing activities"
            ]
        },
        "CCPA": {
            "applies_to": ["California residents", "Companies meeting thresholds"],
            "requirements": [
                "Privacy notice at collection",
                "Right to know",
                "Right to delete",
                "Right to opt-out of sale",
                "Non-discrimination for exercising rights"
            ]
        },
        "HIPAA": {
            "applies_to": ["Healthcare data", "Covered entities"],
            "requirements": [
                "Business associate agreements",
                "Security safeguards",
                "Breach notification",
                "Patient rights",
                "Training requirements"
            ]
        }
    }
    
    def check_compliance(self, company: dict, regulation: str) -> dict:
        """Check compliance with specific regulation."""
        
        reqs = self.REGULATIONS.get(regulation, {})
        
        return {
            "regulation": regulation,
            "applies": self._check_if_applies(company, reqs),
            "requirements": reqs.get("requirements", []),
            "compliant": [],
            "non_compliant": []
        }