Przejdź do treści
Biblioteka skilli
Finanse i księgowość · Analiza

trader-entry

/trader-entry

Pokazuje moment wejścia w akcje NSE na podstawie świec Yahoo: wybicie zakresu otwarcia lub poziomu, z opcjonalnym filtrem wolumenu.

Licencja
MIT
Ostatnia zmiana repozytorium
30.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
1
Komentarze HTML
2
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 30.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
  • SKILL.md zawiera komentarze HTML (2). Nie widać ich w podglądzie Markdown, a model je czyta.

Skrypty: entry.py

Co robi i kiedy

Pokazuje moment wejścia w akcje NSE na podstawie świec Yahoo: wybicie zakresu otwarcia lub poziomu, z opcjonalnym filtrem wolumenu.

Argumenty

/trader-entry [SYMBOL] [--setup orb|level] [--interval 5m|1m]
Oryginalny opis (EN)

Entry Timer for NSE stocks. Watches a setup bar by bar and tells you the moment to get in. Reads free Yahoo 1-minute or 5-minute bars for SYMBOL.NS, builds the opening range (the first 15 minutes after the 09:15 IST open by default) and calls the entry on the first completed bar that CLOSES above the range high, or above a level you give it (like a 20-day high from the scanner), with an optional volume check. Says waiting and how far, triggered with the time and the price in rupees, expired, or not open yet, and writes trader/entry.json for /trader-exit. Long side only. It never places an orde

Jak działa

  1. What it reads and writes
  2. When Yahoo fails: the trader-data cache
  3. The rule
  4. Steps
  5. Example
  6. Rules
  7. What it never does
  8. Safety
  9. Results in Claude: an interactive page, not a wall of text
Sekcje z nagłówków SKILL.md, w oryginale · 193 linii, 1 802 słów
Podgląd SKILL.md
---
name: trader-entry
description: >-
  Entry Timer for NSE stocks. Watches a setup bar by bar and tells you the
  moment to get in. Reads free Yahoo 1-minute or 5-minute bars for SYMBOL.NS,
  builds the opening range (the first 15 minutes after the 09:15 IST open by
  default) and calls the entry on the first completed bar that CLOSES above
  the range high, or above a level you give it (like a 20-day high from the
  scanner), with an optional volume check. Says waiting and how far,
  triggered with the time and the price in rupees, expired, or not open yet,
  and writes trader/entry.json for /trader-exit. Long side only. It never
  places an order. Use when the user says "tell me when to get in", "watch
  RELIANCE", "has HINDCOPPER broken out", "did it break the opening range",
  "entry signal", "time my entry", "check my watchlist", or after
  /trader-scanner and /trader-news, before /trader-exit.
argument-hint: "[SYMBOL] [--setup orb|level] [--interval 5m|1m]"
---

# trader-entry

The Entry Timer turns a setup on an NSE stock into one moment: the bar that
confirms it. It reads bars, 1-minute or 5-minute, and waits for each one to
finish. A price that pokes above the high in the middle of a bar is not an
entry. A bar that CLOSES above it is. Then it says the time and the price,
writes them down for the Exit Planner, and stops. It never buys anything. Day
trading loses most people money, and a clean signal does not change that.

`${CLAUDE_SKILL_DIR}` below is this skill's folder (where this SKILL.md lives).

```bash
python3 "${CLAUDE_SKILL_DIR}/entry.py" check RELIANCE                # 15-minute opening range, 5-minute bars
python3 "${CLAUDE_SKILL_DIR}/entry.py" check RELIANCE --write        # also save trader/entry.json
python3 "${CLAUDE_SKILL_DIR}/entry.py" check HINDCOPPER --setup level --level 371.20
python3 "${CLAUDE_SKILL_DIR}/entry.py" check HDFCBANK --interval 1m --min-volume-x 1.5
python3 "${CLAUDE_SKILL_DIR}/entry.py" watch BEL --until 15:00       # one line per closed bar, stops on the trigger
python3 "${CLAUDE_SKILL_DIR}/entry.py" watchlist                     # every hit in trader/watchlist.json
```

Symbols are NSE symbols (RELIANCE, M&M, BAJAJ-AUTO); a trailing `.NS` is
fine. F&O contracts (NIFTY26OCT25000CE) are refused: cash equities only.
Other flags: `--or-minutes N` (default 15), `--json`, `--offline FILE` (a
saved Yahoo chart JSON, `.json` or `.json.gz`, or a folder of
`<SYMBOL>.json`), `--now "2026-10-19 10:00"` (IST) to replay a day.
`watch` with `--now` or `--offline` runs on a simulated clock and replays the
day bar by bar without waiting. `--cache` reads the trader-data cache
instead of Yahoo (5-minute bars only).

## What it reads and writes

| file | what |
| --- | --- |
| `trader/watchlist.json` | the scanner's hits (`hits[].symbol`), for `watchlist` |
| `trader/config.json` | `no_entries_before` (09:30) and `no_entries_after` (15:00), IST. Optional |
| Yahoo chart API | today's bars for `SYMBOL.NS`, `range=1d&interval=5m` (or `1m`): free, unofficial, can lag. query1 first, then query2 |
| `trader/data/intraday/<SYMBOL>-5m.json` | the trader-data cache: read with `--cache` or when Yahoo fails, with a note of its time. `trader/entry.json` then says `"source": "cache"` |
| `trader/entry.json` | with `check --write`, or when `watch` triggers: symbol, setup, status, time, bar, price, level, opening range |

## When Yahoo fails: the trader-data cache

The live fetch is Yahoo's v8 chart, query1 first, then query2 (one retry
after a pause on a 429, a browser User-Agent). With `--cache`, or when both
hosts fail, the script reads `trader/data/intraday/<SYMBOL>-5m.json`, the
cache trader-data writes in the same Yahoo shape, and prints "using cached
data from <time> ... run `python3 trader-data/data.py intraday SYMBOL` to
refresh". Tell the user the data's time. With no cache either it stops with
the way out: run `python3 trader-data/data.py doctor`; or, when the Kite MCP
tools are in the session, call `get_historical_data` (5-minute candles),
save the raw JSON and run `python3 trader-data/data.py import-kite FILE --kind historical --symbol SYMBOL`,
then re-run with `--cache`.

## The rule

- **Session.** NSE cash market, 09:15 to 15:30 IST (UTC+05:30, no daylight
  saving): 75 five-minute bars. The 09:00 to 09:08 pre-open is not tradable.
- **Opening range (orb).** The high and low of the first 15 minutes: the
  9:15, 9:20 and 9:25 five-minute bars, or fifteen 1-minute bars. The level
  to beat is the range high.
- **Level.** A price you give, like a 20-day high from `/trader-scanner`.
- **The trigger** is the first completed bar after the range that CLOSES
  above the level. A wick above is not a trigger. A close exactly at the
  level is not above it.
- **The time** is that bar's close time (the 9:55 bar closes at 10:00 AM).
  The price is its close, to the paisa.
- **Only closed bars count.** A bar is closed when the clock passes its start
  plus 5 (or 1) minutes and Yahoo has caught up to that moment (it waits a
  minute at most). Yahoo's live tick, like 10:34:45, is never a bar.
- **Volume, if you want it.** `--min-volume-x 1.5` also needs the trigger
  bar's volume at 1.5 times the range bars' average. The 9:15 bar carries the
  pre-open auction's matched orders, so 1.0 is already strict.
- **Time limits.** No entries before 9:30 or after 15:00 IST (config). The
  broker squares off intraday (MIS) positions at about 15:20, so a late entry
  has almost no room. NSE has no early closes; the Muhurat session is treated
  as closed.
- **What it says.** Waiting (and how far the last close is from the level),
  triggered, expired, or no data. Before 9:15: not open yet. Before 9:30: the
  range is still forming. Weekends and NSE holidays (the built-in 2024 to 2026
  lists plus `trader/data/calendar.json`, which `python3 trader-data/data.py
  calendar` writes; a year in neither gets a "check nseindia.com" warning):
  the market is closed. A normal-hours special session on a weekend counts as
  open.
- **Circuit limits.** A stock locked at its upper or lower circuit (2, 5, 10
  or 20 %) may print bars nobody could trade. A breakout that runs straight
  into the upper circuit may not fill.

## Steps

1. Get the symbol from the user, or run `entry.py watchlist` after
   `/trader-scanner`. Check `/trader-news` for it first.
2. Run `entry.py check SYMBOL`. Tell the user the status in one line:
   waiting and how far, triggered at what time and price, or expired.
3. To wait for it, Claude can run `entry.py watch SYMBOL --until 15:00` in
   the background, or `entry.py check SYMBOL --write` on a `/loop` every 5
   minutes. `watch` wakes just after each bar closes, prints one line per
   bar, and exits 0 on the trigger (it writes `trader/entry.json`) or 1 when
   the setup expires. Keep the computer awake while it watches: a sleeping
   laptop pauses it, and it catches up, late, when it wakes.
4. When it triggers, say the time and the price, and that nothing was placed.
   If the trigger is more than a bar old, say that too: a late entry is a
   different trade.
5. Hand off to `/trader-exit` to set the stop and the target BEFORE anything
   is bought.

## Example

RELIANCE, Monday 2026-10-19, 5-minute bars (the test fixture: synthetic
bars, not real RELIANCE prices). The opening range is 354.47 to 362.18. At
9:57 the 9:55 bar is still open, so it waits:

```
WAITING  last close ₹361.68 (9:50 bar), ₹0.50 under the range high ₹362.18 (-0.14%).
The 9:55 bar is still forming (₹364.18 so far, closes 10:00 AM); it does not count until it closes.
```

At 10:00 the bar has closed:

```
RELIANCE  Mon 2026-10-19 10:00 IST  opening-range breakout (15-minute range) on 5-minute bars (Yahoo, free, can lag)
Opening range 9:15-9:30: high ₹362.18, low ₹354.47 (3 of 3 bars).
TRIGGERED 10:00 AM at ₹364.18: the 9:55 bar (bar 8) closed above the range high ₹362.18 (+0.55%).
This is the moment to get in, if you take the trade. Nothing was placed.
Next: set the stop and target BEFORE you buy: /trader-exit (exit.py plan --from trader/entry.json).
```

With `--min-volume-x 1` the 9:55 bar is too thin (0.60x the range's volume)
and the trigger moves to 10:20 AM at ₹365.75 (the 10:15 bar, 7.98x).

## Rules

- Bar by bar, on free Yahoo 1-minute or 5-minute bars. They are unofficial
  and can lag. Say so when a minute matters.
- A signal is information, not an order, and not a promise. Nothing here
  promises winning trades or money.
- Long side only: this skill plans longs only. Intraday shorts on NSE are
  MIS-only and squared off the same day; if the user wants a short, say that.
- One trigger per setup per day: the first close above. Later closes do not
  reset it.
- Never call an entry early because a bar looks like it will close above.

## What it never does

It never places an order, never sizes a position, never sets the stop (that
is `/trader-exit`), never moves the level after the fact, and never counts a
bar that has not closed. It never runs `/trader-broker` from a background
watch: nobody is there to say yes.

## Safety

- Education and tooling, not financial advice. A PASS is a rules check, not a recommendation.
- Paper by default (`"paper": true`): Kite has no paper account, so paper tickets are logged only,
  never sent. Going live is the user's own decision, in their own config.
- Nothing in this pack places an order except trader-broker, and only when all three hold: trader-risk
  passed that exact order today, the user typed an explicit yes for that one order in the chat, and the
  user clicked Allow once on Claude's own card because the order tool is set to "Needs approval"
  (Customize > Connectors > tool permissions). Never set an order tool to "Always allow".
- No F&O, MIS leverage or short selling unless the config allows it and the user confirms.
- Kite login is OAuth in the browser; no keys or tokens in the chat.

<!-- html output: keep byte-identical in every SKILL.md (tests/test_repo.py checks) -->
## Results in Claude: an interactive page, not a wall of text

`output` in `trader/config.json` decides how a result reaches the user: `"html"` (the default when the key
is missing) or `"text"`. In html mode, when Claude has an Artifact tool (Claude Code, claude.ai):

1. Run this skill's command as usual (with `--write` where it has one, so the result lands in a file).
2. Rebuild the page with the sections that skill fills, for the symbols in play:
   `python3 "${CLAUDE_SKILL_DIR}/../trader-report/report.py" build --public --sections SECTIONS [--symbol SYM ...]`
3. Publish `trader/report.html` as an Artifact. Always the same file, so the page keeps one URL and every
   skill updates the same living dashboard (first publish: icon `chart`).
4. Reply in chat in 2 to 4 lines: the headline (verdict, setup, PASS or BLOCK), any warning (stale data,
   a missing source, results soon), and the link. The detail lives on the page, not in the chat.

| skill | sections |
| --- | --- |
| trader-data | market, symbols |
| trader-scanner | scans, market (`patterns --study`: study) |
| trader-news | news, market |
| trader-invest, trader-thesis | symbols, thesis, market |
| trader-entry, trader-exit, trader-timemachine, trader-budget, trader-risk | plan, symbols |
| trader-backtest | backtest |
| trader-portfolio | portfolio (only with the user's yes, see below) |
| trader-alerts, trader-broker | plan (its orders only with the user's yes, see below) |
| trader-report | all of them |

`--public` leaves out holdings, proposed orders and risk verdicts. Publishing distributes the page, so those
go on it only after the user says yes to that exact page; otherwise keep `--public` or answer in chat.
Without an Artifact tool, or in text mode, answer in chat as the steps above describe and mention
`trader/report.html` for a browser. The page is a view of the files; the files stay the source of truth,
and nothing on it places an order.
<!-- end html output -->
Pliki w paczce (2)
  • SKILL.md 12 KB
  • entry.py 53 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · Vatsa10/nse-trader-skills100MIT
rajumegal01-source/nse-day-trader-skill100MIT
sandysc0202-beep/day-trader-skill-india100MIT
trmxvibs/day-trader-skill-india100MIT
jakeschincariol/day-trader-skill100MIT
Khuranasidharth/day-trader-india100MIT
fenilmodi00/day-trader-skill-india100MIT
AtiqMunawwar/crypto-day-trader-skill100MIT
rajdavee/bharat-trader87MIT

Migawka bazy z 13.11.2026 · wersja paczki 61dffb5bf613 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100trader-in-entry
    Pokazuje moment wejścia na indyjskim rynku, świeca po świecy, gdy zamknięcie przebija zakres otwarcia lub wskazany poziom.
  • 100nse-entry
    Pilnuje wejścia w akcje NSE i BSE i sygnalizuje przebicie zakresu otwarcia po zamknięciu świecy, z opcjonalnym potwierdzeniem wolumenem.
  • 100bharat-entry
    Obserwuje świecę po świecy setup na NSE i podaje moment wejścia po przebiciu zakresu otwarcia lub wskazanego poziomu.
  • 87trader-in-entry
    Obserwuje ustawienie na akcjach indyjskich i wskazuje moment wejścia, gdy świeca zamknie się powyżej zakresu otwarcia.
  • 100nse-entry
    Śledzi ustawienie transakcji na świecach minutowych lub 5-minutowych i podaje moment wejścia po zamknięciu nad zakresem otwarcia.
  • 100nse-entry
    Obserwuje akcje NSE świeca po świecy i wskazuje moment wejścia, gdy świeca zamknie się powyżej zakresu otwarcia.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.