Due diligence prep skill for Claude

---
name: due-diligence-prep
description: Prepares a startup for investor due diligence at seed or Series A. Builds a data room index, maps the founder's existing files to it by name, and flags gaps and red flags such as unsigned IP assignments, missing board or shareholder approvals, a cap table that does not match the share register or allotment filings, contractors without IP clauses and unfiled statutory forms. For Indian companies it adds ROC filings, statutory registers, demat, valuation reports for share issues and FEMA reporting for foreign investment (FC-GPR, FC-TRS, FLA). Use when a founder mentions due diligence, a DD checklist or request list, a data room, preparing documents for investors or lawyers, a signed term sheet, closing a round, or asks what investors will check, even before a term sheet arrives.
license: MIT
compatibility: Works on claude.ai, Claude Code and the Claude API. The script needs Python 3.8+ (standard library only) and no network access.
metadata:
  author: StartupReader
  version: "1.0"
  homepage: https://startupreader.com/claude-skills/due-diligence-prep
---

# Due diligence prep

Get the founders' records into the shape an investor's lawyers will ask for, and surface the problems before the lawyers do. The output is a prep plan for the founders and their lawyer or company secretary, not legal advice. Say so once, at the end.

## Workflow

Copy this checklist and tick it off as you go:

```
- [ ] 1. Establish the facts that decide which items apply
- [ ] 2. Get the file names and run scripts/data_room_index.py
- [ ] 3. Check each found item and each red flag with references/checklist.md
- [ ] 4. Ask the questions the file names cannot answer
- [ ] 5. Write the prep plan in the output format below
- [ ] 6. Check the plan against the script output and the checklist
```

### 1. Establish the facts

Ask only for what is not already clear:
- Country of incorporation, and whether there is a parent company abroad.
- The round: angel, seed or Series A, and whether a term sheet is signed.
- Every security issued so far: equity, CCPS, CCDs, SAFEs, convertible notes, options.
- Any investor outside India (for an Indian company), any share transfers between residents and non-residents, any convertible notes, any investment in another Indian company.
- Head count (an Indian company with 10 or more employees needs a POSH internal committee) and anyone who built the product as a contractor.
- Whether the company is a small company under Indian company law (most other private companies must hold shares in demat form).

### 2. Index the files

The script reads file names and paths only, never contents. Do not open documents to build the index.

```bash
# A folder the founder has shared (Claude Code, or files uploaded to the sandbox)
python scripts/data_room_index.py --folder "path/to/data room" --india --fema

# Names pasted in chat: save them one per line to a text file first
python scripts/data_room_index.py --list files.txt --india --fema --show table
python scripts/data_room_index.py --list files.txt --india --fema --show tree
```

- `--india` for an Indian company; add `--fema` only if it has, or is about to have, foreign investors.
- `--show table` prints found, missing and check counts per section, the gaps, names that look like drafts or copies, and unmatched files. `--show tree` prints a suggested folder structure with each file under its closest checklist item. The default prints both.
- "Found" means a file with a matching name exists, not that it is complete or signed. "Check" items apply only in some cases: decide each one from the facts in step 1.
- Place unmatched files by hand. If a file is clearly under the wrong item, say so in the plan.
- See [assets/example-files.txt](assets/example-files.txt) for the list format. If the script exits with an error, fix what it names and run it again.

### 3. Check items and red flags

Read [references/checklist.md](references/checklist.md) for what each section must contain, the India and FEMA items with their deadlines, and the red flag table. Look hardest at:

- **Cap table against the legal record**: every holder and every issue in the cap table should appear in the register of members, the share certificates or demat records, and a return of allotment (PAS-3). Ask for the numbers if only the files are shared.
- **IP**: a signed assignment from every founder, and an IP clause or assignment from every contractor who built product, code, design or content. Unsigned or draft assignments count as missing.
- **Approvals**: board and shareholder resolutions for each share issue and for the ESOP plan (in India, shareholders approve the plan by special resolution).
- **Filings**: PAS-3 for each issue, annual ROC filings, and for foreign investors FC-GPR within 30 days of issue, a fair value certificate behind each foreign issue, and annual FLA returns.
- **Names to check** from the script: drafts, unsigned copies, templates and version numbers. The data room should hold only final, signed versions.

Sort each red flag by what it takes: **Fix now** (sign, ratify or file before diligence starts), **Start now** (FEMA lapses take longer; bigger ones may need compounding with the RBI), **Disclose** (known issues for the disclosure list). Whatever is left when diligence runs is fixed before closing as a condition precedent, disclosed and accepted, or covered by indemnities.

### 4. Ask what names cannot show

File names cannot show signatures, dates, whether a filing was on time, or whether a contractor agreement has an IP clause. List these as short, specific questions for the founders, for example: "Is the Founder B IP assignment signed? If not, can it be signed this week?"

### 5. Output format

```markdown
# Due diligence prep: [Company], [round]

## Readiness
Two or three sentences: how complete the data room is (found, missing and to-check counts from the script), the most serious red flag, and what to fix first.

## Red flags
| Red flag | Evidence (file or missing item) | Action | Fix now / Start now / Disclose |
|---|---|---|---|

## Missing documents
Grouped by data room folder, each with who usually holds it (founders, accountant, company secretary, lawyer).

## Items to confirm
"Check" items from the script, each with the fact that decides whether it applies.

## Questions for the founders
Numbered, specific, answerable this week.

## Suggested data room structure
The folder tree from the script, with unmatched files placed and renames suggested.

## Draft disclosure list
Known issues to raise with investors before they find them.
```

### 6. Check before sending

- Every count and file name comes from the script output; every rule, form and deadline from references/checklist.md.
- No document is called complete or signed on the strength of its name alone.
- India and FEMA items appear only for Indian companies, and FEMA items only with foreign investors.
- The plan ends with: "This is a preparation checklist to review with your lawyer or company secretary, not legal advice."

## Rules

- Never ask the founders to upload confidential documents just to build the index; names are enough for steps 2 and 3.
- Do not state a form name, deadline or fee that is not in references/checklist.md. For companies outside India, ask for the local equivalents instead of guessing.
- Rules on company law, FEMA and tax change often: tell the founders to confirm current requirements with their adviser or on mca.gov.in and rbi.org.in.

# Made-up example: the shared drive of Tealbrook Labs Private Limited,
# a fictional Indian SaaS startup preparing for a seed round.
# One file name or path per line. Only these names are read, never contents.
Company/Certificate of Incorporation.pdf
Company/MOA and AOA (amended 2024).pdf
Company/Board minutes FY2024-25.pdf
Company/Board resolution - ESOP pool.pdf
Company/EGM special resolution - ESOP plan.pdf
Company/Founders agreement.pdf
Company/AOC-4 and MGT-7 FY2024-25.pdf
Fundraising/Angel SHA 2024.pdf
Fundraising/Angel SSA 2024.pdf
Fundraising/Cap table v7.xlsx
Fundraising/PAS-3 angel allotment.pdf
Fundraising/Valuation report - angel round.pdf
Fundraising/FC-GPR acknowledgement - angel round.pdf
People/ESOP Plan 2024.pdf
People/Employment agreement template.docx
IP/IP assignment - Founder A.pdf
IP/IP assignment - Founder B (unsigned).pdf
IP/Trademark application - Tealbrook.pdf
Contractors/Freelance design agreement.pdf
Finance/Audited financials FY2024-25.pdf
Finance/Bank statements Apr-Sep 2025.pdf
Finance/MIS Sep 2025.xlsx
Tax/GST returns FY2024-25.zip
Tax/TDS returns Q1-Q2 FY2025-26.pdf
Customers/MSA - pilot customer.pdf
Misc/Pitch deck v12 draft.pdf

# Due diligence checklist: seed and Series A

## Contents
- How diligence runs
- 1. Corporate records
- 2. Cap table and ESOP
- 3. Finance
- 4. Tax
- 5. Intellectual property
- 6. Contracts
- 7. People
- 8. FEMA (Indian companies with foreign investors)
- 9. Regulatory, litigation and disclosures
- Red flags and how each is usually resolved
- Setting up the data room
- Companies outside India

Built from StartupReader's startup due diligence checklist, cap table, term sheet and FDI explainers. Items marked **(India)** apply to Indian companies. Rules in these areas change with budgets, RBI Master Directions and MCA notifications: tell the founders to confirm current requirements on mca.gov.in and rbi.org.in, or with an adviser.

## How diligence runs

After the term sheet is signed, the investor's lawyers (and sometimes accountants) send a request list. The company shares documents in a data room and answers follow-up questions, and the advisers write a report. Each finding is then:
- fixed before closing, as a condition precedent;
- disclosed and accepted; or
- covered by indemnities in the transaction documents.

Angel rounds usually involve a lighter review of the basics. There is no fixed timeline: as a rough guide from practitioners, a seed round often takes two to four weeks of diligence and a Series A four to six, and gaps found along the way add time. Closing after a term sheet commonly takes one to three months in all.

## 1. Corporate records
- Certificate of incorporation.
- Memorandum and articles of association, and every amendment.
- Board minutes and resolutions.
- Shareholder minutes and resolutions.
- **(India)** Statutory registers, including the register of members.
- Founders' agreement and any earlier investment agreements (in India, usually a share subscription agreement and a shareholders' agreement for each priced round).
- **(India)** Annual filings with the Registrar of Companies: financial statements and the annual return.
- **(India)** Demat status. Most private companies other than small companies must now issue and hold securities in dematerialised form, with a compliance deadline of 30 June 2025, so investors check it.

## 2. Cap table and ESOP
- A cap table on a fully diluted basis: issued shares, all options (granted and unallocated pool) and convertible instruments (SAFEs, notes, CCDs, CCPS) as if converted.
- The cap table must reconcile with the legal record: in India, the register of members, share certificates or demat records, and every return of allotment (Form PAS-3) filed with the Registrar. Investors' lawyers reconcile these at every round.
- For each past share issue: the valuation report, the approvals, the offer letter and the filings.
- **(India)** Valuation reports. Shares issued to a non-resident cannot be priced below fair value certified under FEMA; a preferential allotment by an unlisted company needs a registered valuer's report under company law. Keep a report for every round, dated close to the allotment.
- The ESOP plan, with its approval. **(India)** The plan must be approved by shareholders by special resolution.
- Option grant letters and vesting records.
- A US parent company that grants stock options (for example after a flip) needs a 409A valuation before the first grant, at least every 12 months while it keeps granting, and after a material event such as a new round.

## 3. Finance
- Audited financial statements.
- Recent management accounts.
- Bank statements.

## 4. Tax
- **(India)** GST registrations and returns, with reconciliations.
- **(India)** TDS deducted and deposited on salaries, contractor payments and rent, and the related returns.
- Income tax returns, assessments and any notices. **(India)** Including old angel tax cases: the provision stopped applying from 1 April 2025, but assessments and appeals for earlier years continue under the old rule.
- **(India)** Provident fund and ESI registrations and payments, where they apply.

## 5. Intellectual property
- IP assignments from founders, employees and contractors to the company. Check everyone who built product, code, design or content, including before incorporation.
- Trademarks and domains held in the company's name, not a founder's.

## 6. Contracts
- Key customer, supplier and partner contracts, especially their change-of-control, exclusivity and liability clauses.

## 7. People
- Employment contracts with confidentiality and invention assignment terms.
- **(India)** An internal committee under the POSH Act if the company has 10 or more employees.
- How personal data is handled. **(India)** The Digital Personal Data Protection Act, 2023 applies; its rules were notified in November 2025 and are being phased in.

## 8. FEMA (Indian companies with foreign investors)
Investors look closely at these, and lapses take the longest to fix.

| Event | Filing or action | Deadline |
|---|---|---|
| Money received from a foreign investor | Issue the shares, or refund | Issue within 60 days; refund within 15 days after that |
| Shares issued to a foreign investor | Form FC-GPR on the RBI's FIRMS portal | Within 30 days of issue |
| Convertible notes issued | Form CN | Within 30 days of issue |
| Share transfer between a resident and a non-resident | Form FC-TRS | 60 days from transfer or payment, whichever is earlier |
| Company holding foreign investment | Annual FLA return | By 15 July each year |
| Downstream investment by a foreign-owned company | Form DI | Within 30 days of allotment |

Also check:
- A fair value certificate behind each foreign issue, from a chartered accountant, a SEBI-registered merchant banker or a practising cost accountant. The issue price must be at least that fair value. For convertible instruments, the price or conversion formula must be fixed at issue.
- Instruments: foreign investors can hold equity shares, fully and compulsorily convertible preference shares and debentures (CCPS, CCDs), share warrants, and convertible notes from DPIIT-recognised startups only. A US-style SAFE is not one of the listed instruments.
- Beneficial ownership of each foreign investor against the rules on investment from countries sharing a land border with India (government approval since Press Note 3 of 2020; a March 2026 clarification lets non-controlling beneficial ownership of up to 10% from such countries use the automatic route, subject to conditions). Check the current wording before relying on it.
- The sector's entry route and any cap.

Late filings attract a late submission fee set by the RBI; bigger lapses may need compounding with the RBI, which takes time and can delay a round.

## 9. Regulatory, litigation and disclosures
- Sector licences the business needs.
- Pending litigation and regulatory notices.
- A short disclosure list of known issues. Investors trust problems the founders raise first.

## Red flags and how each is usually resolved

| Red flag | What to check | Usual fix | Time |
|---|---|---|---|
| Cap table does not match the register of members, share certificates or demat records, or the PAS-3 filings | Reconcile holder by holder, issue by issue | Correct the cap table or the records, with the company's advisers | Depends on the gap |
| IP still owned by a founder or contractor | Signed assignment from every founder and every contractor who built product, code, design or content | Get assignments signed now by founders and contractors | Quick if people are reachable |
| Unsigned or draft agreements in the data room | Final signed copy exists | Replace with the signed copy, or get it signed | Quick |
| Missing board or shareholder approval for a share issue or the ESOP plan | Minutes and resolutions for every issue and the plan | Ratify the approval | Quick to medium |
| ESOP plan without shareholder approval (India: special resolution) | Plan date against the resolution date | Pass the resolution; review grants made before it | Medium |
| Unfiled or late ROC forms (PAS-3, annual filings) | Filing acknowledgements | Late company filings can usually be made with additional fees | Medium |
| Missing or late FEMA filings (FC-GPR, FC-TRS, FLA) | Acknowledgements, dates against the deadlines above | Late submission fee; compounding with the RBI for bigger lapses | Long: start early |
| Share issue to a foreign investor without a fair value certificate | Certificate dated close to the issue, price at or above fair value | Take advice: may need regularising | Long |
| Undisclosed disputes, tax notices or old angel tax cases | Notices, correspondence, assessments | Put on the disclosure list | Quick to disclose |
| No POSH internal committee with 10 or more employees (India) | Constitution of the committee | Constitute it | Quick to medium |

"Quick", "medium" and "long" are relative: the explainers give no fixed durations, so do not promise any.

## Setting up the data room
- Run the company's own review first and fix gaps: file missed forms, ratify approvals, get IP assignments signed.
- One folder per area (corporate, cap table and ESOPs, finance, tax, IP, contracts, people, FEMA, litigation), with an index in each.
- Name files clearly and keep only final, signed versions.
- Give named access rather than open links, and keep a log of questions and answers.
- Prepare a short disclosure list of known issues.

## Companies outside India
Sections 1 to 3 and 5 to 7 broadly apply everywhere, as do the red flags on IP, approvals, the cap table and unsigned documents. The India items (ROC forms, statutory registers, demat, GST, TDS, PF and ESI, POSH, FEMA) have local equivalents that this checklist does not cover: ask the founders' lawyer or company secretary for the local list rather than guessing form names or deadlines.

#!/usr/bin/env python3
"""Data room index: map a startup's file names to a due diligence checklist.

Reads file NAMES only, never file contents, so it is safe to point at a
folder of confidential documents. Standard library only, no network, so it
runs in the Claude API sandbox, on claude.ai and in Claude Code.

Usage:
  python scripts/data_room_index.py --folder "path/to/shared drive" [--india] [--fema]
  python scripts/data_room_index.py --list assets/example-files.txt --india --fema
  python scripts/data_room_index.py --list files.txt --india --show table
  python scripts/data_room_index.py --list files.txt --india --show tree

--folder walks a folder and its subfolders. --list reads a text file with one
file name or path per line (blank lines and lines starting with # are skipped),
for when the founder pastes names instead of sharing a folder.
--india adds Indian company-law, tax and employment items; --fema adds the
foreign-investment items for an Indian company with investors outside India.
--show table prints found / missing / check counts and the gaps; --show tree
prints a suggested folder structure with each file under its best match.

Matching is by keywords in the file name and path, so "found" means a file
with a matching name exists, not that the document is complete or signed.
"""
import argparse
import os
import re
import sys

# Pointing --folder at a whole drive by mistake would list far more than any
# data room holds; stop and ask for the right folder instead.
MAX_FILES = 5000
# Operating-system and editor files that are never documents.
JUNK_NAMES = {"thumbs.db", "desktop.ini", ".ds_store"}
JUNK_DIRS = {"__macosx", ".git"}

# Sections in the order StartupReader's startup-due-diligence-checklist
# explainer suggests for data room folders. Scope: core (every company),
# india (Indian companies), fema (Indian companies with foreign investors).
SECTIONS = [
    ("corporate", "Corporate records"),
    ("captable", "Cap table and ESOP"),
    ("finance", "Finance"),
    ("tax", "Tax"),
    ("ip", "Intellectual property"),
    ("contracts", "Contracts"),
    ("people", "People"),
    ("fema", "FEMA (foreign investment)"),
    ("regulatory", "Regulatory, litigation and disclosures"),
]

# (section, scope, label, condition or None, keywords). A keyword is a phrase
# matched as whole words in the normalised path, or a tuple of phrases that
# must all appear. Items with a condition show "check", not "missing", when
# nothing matches, because they apply only to some companies.
ITEMS = [
    ("corporate", "core", "Certificate of incorporation", None,
     ["certificate of incorporation", "incorporation certificate", "incorporation", "coi"]),
    ("corporate", "core", "Memorandum and articles, with amendments", None,
     ["memorandum", "articles", "moa", "aoa", "charter", "bylaws"]),
    ("corporate", "core", "Board minutes and resolutions", None,
     ["board"]),
    ("corporate", "core", "Shareholder minutes and resolutions", None,
     ["shareholder resolution", "shareholders resolution", "members resolution", "special resolution",
      "ordinary resolution", "general meeting", "egm", "agm", "stockholder consent"]),
    ("corporate", "india", "Statutory registers (register of members and others)", None,
     ["register of members", "statutory register", "statutory registers", "register", "registers"]),
    ("corporate", "core", "Founders' agreement", None,
     ["founders agreement", "founder agreement", "cofounder agreement", "co founder agreement"]),
    ("corporate", "core", "Earlier investment agreements (SHA, SSA, SAFE, notes)", None,
     ["sha", "ssa", "shareholders agreement", "shareholder agreement", "subscription agreement",
      "investment agreement", "safe", "convertible note", "ccps", "ccd", "term sheet"]),
    ("corporate", "india", "ROC annual filings: financial statements and annual return", None,
     ["aoc 4", "mgt 7", "mgt 7a", "annual return", "roc"]),
    ("corporate", "india", "Demat records for the company's shares",
     "most private companies other than small companies",
     ["demat", "isin", "nsdl", "cdsl", "depository"]),
    ("captable", "core", "Fully diluted cap table", None,
     ["cap table", "capitalisation table", "capitalization table", "shareholding pattern", "shareholding"]),
    ("captable", "core", "Share certificates", None,
     ["share certificate", "share certificates", "stock certificate", "stock certificates"]),
    ("captable", "india", "Return of allotment for every issue (PAS-3)", None,
     ["pas 3", "return of allotment"]),
    ("captable", "core", "Valuation report for every share issue", None,
     ["valuation report", "valuation", "fair value", "fmv", "409a"]),
    ("captable", "india", "Offer letter for every private placement", None,
     ["pas 4", "pas 5", "private placement"]),
    ("captable", "core", "ESOP plan", None,
     ["esop plan", "esop scheme", "esop policy", "stock option plan", "option plan", "equity incentive plan"]),
    ("captable", "core", "Option grant letters and vesting records", None,
     ["grant letter", "grant letters", "option grant", "esop grant", "option agreement", "vesting"]),
    ("finance", "core", "Audited financial statements", None,
     ["audited", "audit report", "financial statements", "balance sheet", "annual accounts", "financials"]),
    ("finance", "core", "Recent management accounts", None,
     ["management accounts", "mis", "monthly accounts", "management report", "profit and loss", "p l"]),
    ("finance", "core", "Bank statements", None,
     ["bank statement", "bank statements", "bank"]),
    ("tax", "core", "Indirect tax registrations and returns (GST, VAT)", None,
     ["gst", "gstr", "vat", "sales tax"]),
    ("tax", "india", "TDS deposits and TDS returns", None,
     ["tds", "24q", "26q"]),
    ("tax", "core", "Income tax returns, assessments and notices", None,
     ["income tax", "itr", "tax return", "tax returns", "assessment", "tax notice"]),
    ("tax", "india", "Provident fund and ESI registrations and payments",
     "where they apply to the company",
     ["pf", "epf", "epfo", "provident fund", "esi", "esic"]),
    ("ip", "core", "IP assignment from each founder", None,
     [("assignment", "founder"), ("ip", "founder"), ("invention", "founder")]),
    ("ip", "core", "Contractor agreements with IP assignment", None,
     ["contractor", "contractors", "consultant", "consultancy", "freelance", "freelancer", "agency agreement"]),
    ("ip", "core", "Trademarks, domains and other registered IP", None,
     ["trademark", "trade mark", "tm application", "patent", "copyright", "domain", "domains"]),
    ("contracts", "core", "Key customer contracts", None,
     ["customer", "customers", "client", "msa", "master services", "master service", "order form",
      "statement of work", "sow", "pilot agreement"]),
    ("contracts", "core", "Key supplier and partner contracts", None,
     ["supplier", "vendor", "partner", "partnership", "reseller", "distribution", "licence agreement",
      "license agreement"]),
    ("people", "core", "Employment contracts (confidentiality, invention assignment)", None,
     ["employment", "employee agreement", "appointment letter", "offer letter", "offer letters"]),
    ("people", "india", "POSH Act internal committee",
     "if the company has 10 or more employees",
     ["posh", "internal committee", "sexual harassment"]),
    ("people", "core", "Privacy policy and personal data handling", None,
     ["privacy", "data protection", "dpdp", "dpa", "personal data"]),
    ("fema", "fema", "FC-GPR for every issue to a foreign investor", None,
     ["fc gpr", "fcgpr"]),
    ("fema", "fema", "Fair value certificate for every foreign issue", None,
     ["fair value certificate", "fair valuation certificate", ("fema", "valuation"), ("fema", "fair value")]),
    ("fema", "fema", "Annual FLA returns", None,
     ["fla", "foreign liabilities and assets"]),
    ("fema", "fema", "Beneficial ownership check (land-border rules)", None,
     ["beneficial owner", "beneficial ownership", "ubo", "land border", "press note 3"]),
    ("fema", "fema", "FC-TRS, Form CN, Form DI",
     "only for transfers with non-residents, convertible notes or downstream investment",
     ["fc trs", "fctrs", "form cn", "form di", "downstream"]),
    ("regulatory", "core", "Sector licences", "if the business needs any",
     ["licence", "license", "licences", "licenses", "permit"]),
    ("regulatory", "core", "Litigation, disputes and regulatory notices", "if there are any",
     ["litigation", "legal notice", "dispute", "court", "arbitration", "show cause"]),
    ("regulatory", "core", "Disclosure list of known issues", None,
     ["disclosure", "disclosures", "known issues"]),
]

# Names that suggest a file is not the final, signed version. Checked on the
# file name only. The explainer's advice: keep only final, signed versions.
NAME_FLAGS = [
    (r"\bunsigned\b", "unsigned"),
    (r"\bdraft\b", "draft"),
    (r"\btemplate\b", "template, not a signed document"),
    (r"\b(redline|redlined|tracked|markup)\b", "marked-up version"),
    (r"\b(old|backup|wip)\b", "working or old copy"),
    (r"\bv\d+\b|\bversion\s*\d+\b", "version number: confirm it is the final one"),
    (r"\(\d+\)|(?<!certified) copy\s*$", "looks like a duplicate download"),
]


def fail(message):
    print(f"Error: {message}", file=sys.stderr)
    sys.exit(2)


def normalise(text):
    """Lower-case words: camelCase and letter/digit runs split, punctuation dropped."""
    text = re.sub(r"['’]", "", text)
    text = text.replace("&", " and ")
    text = re.sub(r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", " ", text)
    text = re.sub(r"(?<=[A-Za-z])(?=\d)|(?<=\d)(?=[A-Za-z])", " ", text)
    return " ".join(re.sub(r"[^a-z0-9]+", " ", text.lower()).split())


def strip_extension(path):
    root, ext = os.path.splitext(path)
    return root if 0 < len(ext) <= 6 else path


def keyword_score(words, keyword):
    """Length of the matched keyword (longer means more specific), or 0."""
    parts = keyword if isinstance(keyword, tuple) else (keyword,)
    score = 0
    for part in parts:
        phrase = normalise(part)
        if f" {phrase} " not in words:
            return 0
        score += len(phrase)
    return score


def read_folder(folder):
    if not os.path.exists(folder):
        fail(f"folder not found: {folder}")
    if not os.path.isdir(folder):
        fail(f"not a folder: {folder} (use --list for a text file of names)")
    unreadable = []
    paths = []
    for root, dirs, files in os.walk(folder, onerror=lambda e: unreadable.append(e.filename)):
        dirs[:] = sorted(d for d in dirs if not d.startswith(".") and d.lower() not in JUNK_DIRS)
        for name in files:
            if name.startswith(".") or name.startswith("~$") or name.lower() in JUNK_NAMES:
                continue
            paths.append(os.path.relpath(os.path.join(root, name), folder).replace(os.sep, "/"))
            if len(paths) > MAX_FILES:
                fail(f"more than {MAX_FILES:,} files under {folder}: point --folder at the data room folder, not a whole drive")
    for name in unreadable:
        print(f"Note: could not open {name}; its files are not counted.")
    return sorted(paths, key=str.lower)


def read_list(list_file):
    if os.path.isdir(list_file):
        fail(f"{list_file} is a folder: use --folder for a folder, --list for a text file of names")
    if not os.path.isfile(list_file):
        fail(f"list file not found: {list_file}")
    try:
        with open(list_file, encoding="utf-8-sig", errors="replace") as handle:
            lines = handle.read().splitlines()
    except OSError as error:
        fail(f"cannot read {list_file}: {error.strerror}")
    seen = set()
    paths = []
    for line in lines:
        name = line.strip().replace("\\", "/").strip("/")
        if not name or name.startswith("#") or name in seen:
            continue
        seen.add(name)
        paths.append(name)
    if len(paths) > MAX_FILES:
        fail(f"more than {MAX_FILES:,} names in {list_file}: list the data room files only")
    return paths


def build(paths, scopes):
    items = [item for item in ITEMS if item[1] in scopes]
    sections = [s for s in SECTIONS if any(item[0] == s[0] for item in items)]
    folder_names = {key: f"{i:02d} {label}" for i, (key, label) in enumerate(sections, 1)}
    matches = {i: [] for i in range(len(items))}
    best = {}
    for path in paths:
        words = f" {normalise(strip_extension(path))} "
        scored = []
        for i, item in enumerate(items):
            score = max(keyword_score(words, k) for k in item[4])
            if score:
                matches[i].append(path)
                scored.append((-score, i))
        if scored:
            best[path] = min(scored)[1]
    return items, sections, folder_names, matches, best


def name_flags(paths):
    flagged = []
    for path in paths:
        name = strip_extension(path.rsplit("/", 1)[-1]).lower().replace("_", " ")
        reasons = [reason for pattern, reason in NAME_FLAGS if re.search(pattern, name)]
        if reasons:
            flagged.append((path, "; ".join(reasons)))
    return flagged


def print_table(items, sections, folder_names, matches):
    status = {}
    for i, item in enumerate(items):
        status[i] = "found" if matches[i] else ("check" if item[3] else "missing")
    print(f"  {'Section':<42}  {'Found':>5}  {'Missing':>7}  {'Check':>5}")
    for key, _ in sections:
        ids = [i for i, item in enumerate(items) if item[0] == key]
        counts = [sum(1 for i in ids if status[i] == s) for s in ("found", "missing", "check")]
        print(f"  {folder_names[key]:<42}  {counts[0]:>5}  {counts[1]:>7}  {counts[2]:>5}")
    missing = [i for i in status if status[i] == "missing"]
    check = [i for i in status if status[i] == "check"]
    if missing:
        print("Missing")
        for i in missing:
            print(f"  {folder_names[items[i][0]][:2]}  {items[i][2]}")
    if check:
        print("Check: needed only in some cases")
        for i in check:
            print(f"  {folder_names[items[i][0]][:2]}  {items[i][2]}: {items[i][3]}")


def print_tree(paths, items, sections, folder_names, best):
    print("Suggested folder structure (each file under its closest match; add an index to each folder)")
    for key, _ in sections:
        files = [p for p in paths if p in best and items[best[p]][0] == key]
        print(f"{folder_names[key]}/" + ("" if files else "  (empty)"))
        for path in files:
            print(f"  {path}  [{items[best[path]][2]}]")
    unsorted = [p for p in paths if p not in best]
    if unsorted:
        print("To sort by hand/")
        for path in unsorted:
            print(f"  {path}")


def main():
    if hasattr(sys.stdout, "reconfigure"):
        # File names can hold characters the console cannot show: print "?" rather than crash.
        sys.stdout.reconfigure(errors="replace")
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    source = parser.add_mutually_exclusive_group(required=True)
    source.add_argument("--folder", help="folder to walk (file names only are read)")
    source.add_argument("--list", dest="list_file", help="text file with one file name or path per line")
    parser.add_argument("--india", action="store_true", help="add Indian company-law, tax and employment items")
    parser.add_argument("--fema", action="store_true", help="add foreign-investment (FEMA) items; needs --india")
    parser.add_argument("--show", choices=["all", "table", "tree"], default="all",
                        help="table: found / missing counts and gaps; tree: suggested folders; all: both")
    args = parser.parse_args()
    if args.fema and not args.india:
        fail("--fema covers Indian foreign-investment filings, so it needs --india as well")

    paths = read_folder(args.folder) if args.folder else read_list(args.list_file)
    scopes = {"core"} | ({"india"} if args.india else set()) | ({"fema"} if args.fema else set())
    items, sections, folder_names, matches, best = build(paths, scopes)
    source_name = args.folder or args.list_file
    found = sum(1 for i in matches if matches[i])
    scope_label = " + ".join(["core"] + (["India"] if args.india else []) + (["FEMA"] if args.fema else []))
    noun = "file name" if len(paths) == 1 else "file names"
    print(f"Data room check: {len(paths)} {noun} from {source_name} (names only; no file was opened)")
    print(f"Checklist: {scope_label}, {len(items)} items, {found} with a matching file")
    if not paths:
        print("Note: no files found, so every item shows as missing or to check.")

    if args.show in ("all", "table"):
        print_table(items, sections, folder_names, matches)
        flagged = name_flags(paths)
        if flagged:
            print("Names to check (keep only final, signed versions)")
            for path, reason in flagged:
                print(f"  {path}: {reason}")
        unmatched = [p for p in paths if p not in best]
        if unmatched:
            print("Not matched to any item (place by hand)")
            for path in unmatched:
                print(f"  {path}")
    if args.show in ("all", "tree"):
        print_tree(paths, items, sections, folder_names, best)


if __name__ == "__main__":
    main()