GitHub repo එකකින් ව්‍යාපෘතියක් පිරවීම

agent එකක් GitHub repository එකකට යොමු කරන්න, ඔබට වැඩ කරන board එකක් ආපසු ලැබේ: සෑම issue එකක්ම ස්ටෝරියක් ලෙස, එහි ඉතිහාසය කියන තත්ත්වයේම, checklists, labels සහ milestones සමඟ. පසුව එම agent එකම ස්ටෝරියක් ගෙන, එය තමන් සතු කරගෙන, state machine හරහා ගෙන ගොස්, එය විවෘත කළ pull request එක සම්බන්ධ කරයි.

මෙම පිටුව එම චක්‍රය කෙළවරේ සිට කෙළවර දක්වා විස්තර කරයි. පිරවීමේ පියවරට මාර්ග දෙකක් ඇත: East Agile හි විවෘත මූලාශ්‍ර importer වන GitHub-to-EAT එය එක් විධානයකින් කරයි (පියවර 3); import API එය කැඳවුමෙන් කැඳවුමට කරයි (පියවර 4 සහ 5) — job handle එක අවශ්‍ය විට agent එකක් ධාවනය කරන්නේ එයයි. ඉන් පසු සියල්ල API මත ධාවනය වේ, මන්ද ඉතිරිය agent එකකට අධීක්ෂණයකින් තොරව කළ හැකි වීමයි මෙහි අරමුණ.

මෙය වෙනම «AI import» එකක් නොවේ. පිරවීමේ පියවර යනු ව්‍යාපෘති සැකසුම් → Import / Export හරහා ඔබට අතින් ධාවනය කළ හැකි එම GitHub importer එකමයි; එය මෙහෙයුම් උපදෙස් → වෙනත් trackers වලින් import කිරීම හි විස්තර වේ. Agent එක කැඳවන්නේ ඔබ කැඳවන එම endpoint එකමයි. මෙම පිටුව එකතු කරන්නේ ඒ වටා ඇති සියල්ලයි: යතුර ඇත්තේ කා අතේද, ලිවීමට පෙර import එක පරීක්ෂා කරන්නේ කෙසේද, සහ board එක නිර්මාණය වූ පසු agent එක එයින් කරන්නේ කුමක්ද යන්නයි.

ඔබට අවශ්‍ය දේ

• ව්‍යාපෘතියක් — සහ එය නිර්මාණය කිරීමට session එකක් හෝ ea_user_… යතුරක්.
• agent යතුරක් — එම ව්‍යාපෘතියට සීමා වූ ea_agent_… යතුරක්. එයට අවශ්‍ය භූමිකාව රඳා පවතින්නේ චක්‍රයෙන් කොපමණ ප්‍රමාණයක් agent එකට ධාවනය කිරීමට ඔබට අවශ්‍යද යන්න මතය; පියවර 2 බලන්න. API මාර්ගෝපදේශය → යතුරු වර්ග දෙකක් ද බලන්න.
• GitHub පෞද්ගලික access token එකක් — repository එකේ issues කියවීමේ අවසරය සහිත. සෑම import එකක්ම සත්‍යාපනය වේ, මන්ද fetch එක GitHub හි GraphQL API මත ධාවනය වන අතර GraphQL token එකක් නොමැති ඉල්ලීමක් ප්‍රතික්ෂේප කරයි. එය අත්හැරිය හැක්කේ Tracker ඔබ වෙනුවෙන් fetch කරන විට පමණි: පොදු repository එකක්, බෙදාගත් fallback token එකක් ඇති deployment එකක (සත්කාරක eastagiletracker.com සතුව එකක් ඇත; ස්වයං-සත්කාරක ස්ථාපනයකට එහි ක්‍රියාකරු GITHUB_IMPORT_PAT සකසන තෙක් කිසිවක් නැත), සහ GitHub-to-EAT හි --engine direct සමඟ නොවේ. ටෝකන සහ අනුපාත සීමා බලන්න.
• Node.js 22+ — පියවර 3 හි GitHub-to-EAT මාර්ගය සඳහා පමණි. API මාර්ගයට curl හැර වෙන කිසිවක් අවශ්‍ය නැත.

1. ව්‍යාපෘතිය නිර්මාණය කරන්න

agent යතුරට පෙර ව්‍යාපෘතිය පැවතිය යුතු අතර, එය පුද්ගලයෙකු විසින් නිර්මාණය කළ යුතුය: agent යතුරු නිකුත් කරන අවස්ථාවේදීම එක් ව්‍යාපෘතියකට බැඳී ඇති අතර ව්‍යාපෘති නිර්මාණය කළ නොහැක. එය අතුරුමුහුණතේ නිර්මාණය කරන්න, නැතහොත් ඔබේම ea_user_… යතුරෙන්:

curl -X POST https://eastagiletracker.com/api/v1/projects \
  -H "X-TrackerToken: $TRACKER_USER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "hello-world", "iteration_length_weeks": 1}'

පහත සෑම කැඳවුමකටම අවශ්‍ය project_id එක ප්‍රතිචාරයේ ඇත.

2. agent යතුරක් නිකුත් කරන්න

ව්‍යාපෘති හිමිකරු ව්‍යාපෘති සැකසුම් → Agents හි agent යතුරු නිර්මාණය කරයි. ඔබ තෝරන භූමිකාව මෙම පිටුවෙන් කොපමණ ප්‍රමාණයක් agent එකට තනිවම කළ හැකිද යන්න තීරණය කරයි, සහ තේරුම්ගත හැකි පිළිතුරු දෙකක් ඇත:

• owner — එක් යතුරක් import ඇතුළුව මුළු චක්‍රයම ධාවනය කරයි. import එකක් ව්‍යාපෘතියක හැඩය සම්පූර්ණයෙන් නැවත ලියන බැවින්, import කිරීම හිමිකරුට පමණි. owner භූමිකාව සහිත agent එකක් නිකුත් කිරීමට ඔබම ව්‍යාපෘති හිමිකරු විය යුතුය: agent එකක භූමිකාව එය නිර්මාණය කළ තැනැත්තාගේ භූමිකාව කිසිවිටෙක ඉක්මවා නොයයි.
• member — අවම වරප්‍රසාදය. Agent එක ස්ටෝරි ගනී, ඒවා ගෙනයයි, අදහස් දක්වයි, pull requests සම්බන්ධ කරයි; නමුත් import කළ නොහැක. Import එක ඔබම ඔබේ යතුරෙන් ධාවනය කරයි (පියවර 5), පසුව board එක agent එකට භාර දෙයි.

කෙසේ වෙතත්, පෙරනිමි අගය මත එය අත් නොහරින්න. නව agent යතුරක් ඔබ වෙනත් දෙයක් නොකියන තුරු viewer වේ, සහ viewer කෙනෙකුට board එක කියවිය හැකි නමුත් ස්ටෝරියක් ගැනීමට හෝ ගෙනයාමට නොහැක — එයයි මෙම චක්‍රයේ බොහෝ කොටස.

ප්‍රවේශයෙන් ඔබ්බට ගිය හේතුවක් නිසා agent යතුරු මෙහිදී වැදගත් වේ. agent යතුරක් එක් ව්‍යාපෘතියක නම් කරන ලද සහභාගිවන්නෙකු ලෙස ක්‍රියා කරයි, එබැවින් එය නිර්මාණය කරන සෑම ස්ටෝරියක්ම, එය කරන සෑම තත්ත්ව වෙනසක්ම, එය ලියන සෑම අදහසක්ම ඉතිහාසයේ එම agent එකට ආරෝපණය වේ — ඔබේම කාර්යය සමඟ මිශ්‍ර නොවී වෙන් කර හඳුනාගත හැකිව.

export TRACKER_TOKEN="ea_agent_xxxxx"

අන් සියල්ලට පෙර agent එකට /meta කියවීමට දෙන්න:

curl https://eastagiletracker.com/api/v1/meta \
  -H "X-TrackerToken: $TRACKER_TOKEN"

එය නැතිනම් agent එකට අනුමාන කිරීමට සිදුවන ප්‍රශ්න දෙකට පිළිතුරු දෙයි: යතුර බැඳී ඇත්තේ කුමන ව්‍යාපෘතියටද (auth.project_id), සහ එක් එක් ස්ටෝරි වර්ගය සඳහා නීත්‍යානුකූල තත්ත්ව මාරුවීම් මොනවාද (transitions). feature එකක් unstarted → started → finished → delivered → accepted ලෙස ගමන් කරයි; chore එකක් unstarted → started → accepted පමණි. සිතියම කියවීම එය කේතයේ දැඩිව ලිවීමට වඩා හොඳය.

3. GitHub-to-EAT සමඟ import කරන්න

GitHub-to-EAT යනු East Agile හි ම විවෘත මූලාශ්‍ර importer එකයි: පිරවීමේ මුළු පියවරම — පහත පියවර 4 සහ 5 — එක් විධානයකින් කරන MIT බලපත්‍රලාභී විධාන රේඛා මෙවලමකි. පුද්ගලයෙකු terminal එකක් ඉදිරියේ සිටින විට එය භාවිත කරන්න. agent එකක් අධීක්ෂණයකින් තොරව ධාවනය කරමින් විමසීමට job handle එකක් අවශ්‍ය විට එය යටින් ඇති API එක භාවිත කරන්න.

එයට Node.js 22+ අවශ්‍ය වන අතර තමන්ගේම runtime dependencies නොමැත. එය තවම npm වෙත ප්‍රකාශයට පත් කර නැත, එබැවින් repository එකෙන් ස්ථාපනය කරන්න:

git clone git@github.com:EastAgile/GitHub-to-EAT.git
cd GitHub-to-EAT
npm install --global .

පසුව එය පියවර 2 හි නිකුත් කළ යතුරට සහ පියවර 1 හි නිර්මාණය කළ ව්‍යාපෘතියට යොමු කරන්න:

export EAT_AGENT_KEY="ea_agent_xxxxx"
github-to-eat --project $PROJECT_ID --repo octocat/hello-world

එය මුලින්ම mapping legend එකක් මුද්‍රණය කරයි — තෝරාගත් සෑම වර්ගයක්ම හරියටම කෙසේ ගොඩබසීද යන්න — සහ කිසිවක් ලිවීමට පෙර තහවුරු කිරීමක් ඉල්ලයි. Terminal එකෙන් පිටත, pipe එකක, CI හෝ agent එකක එම විමසුම පෙන්වීමට තැනක් නැත, එබැවින් ලියන ධාවනයක් --yes යැවිය යුතුය; එය නොමැතිව මෙවලම ඔබේ පිළිතුර අනුමාන කිරීම වෙනුවට 2 සමඟ පිටවී කිසිවක් නොලියයි. නැවත ධාවනය කිරීම ආරක්ෂිතයි: දැනටමත් import කර ඇති දෑ මඟ හැරේ, කිසිවිටෙක අනුපිටපත් නොවේ.

Flag	එය කරන දේ
--dry-run	පූර්ව පරීක්ෂාව, පසුව එය ක්‍රියාත්මක කරන්නට තිබූ සැලැස්ම මුද්‍රණය කරයි — ස්ටෝරි කීයක් import කරන්නේද, දැනටමත් ඇති බැවින් කීයක් මඟ හරින්නේද — සහ කිසිවක් නොලියයි. --yes අවශ්‍ය නැත.
--include	import කළ යුතු වර්ග, කොමා වලින් වෙන් කර: issues,prs,milestones,releases,deps. පෙරනිමිය issues වන අතර සෑම තේරීමකම එය තිබිය යුතුය. මේවා පියවර 6 හි වගුවේ ඇති එම විකල්පම වේ.
--token	ඔබේ GitHub පෞද්ගලික access token එක (පරිසරයේ හෝ .env හි ඇති GITHUB_TOKEN ද ගණන් ගැනේ). එම repository එකෙහි එයට repo, නැතහොත් සියුම් Issues: Read අවශ්‍යයි. පෞද්ගලික repository එකකට, බෙදාගත් fallback token එකක් නොමැති සේවාදායකයකට, සහ --engine direct සඳහා සැමවිටම අවශ්‍යයි. සත්කාරක සේවාවේ පෙරනිමි engine එකේ එය අත්හැරියොත් Tracker තමන්ගේම බෙදාගත් අයවැය වියදම් කරයි — ටෝකන සහ අනුපාත සීමා බලන්න.
--engine	පෙරනිමි server එක /import/json කැඳවුමක් යවා fetch, map සහ ලිවීම Tracker එකට භාර දෙයි. direct එම pipeline එකම ඔබේ යන්ත්‍රයේ ධාවනය කර පොදු API හරහා ලියයි — එනම් එය GitHub තනිවම කියවන බැවින් සැමවිටම token එකක් අවශ්‍ය වන අතර, නොමැති නම් 2 සමඟ පිටවේ.
--states, --milestones, --story-type, --no-comments, --no-tasks	එක් ධාවනයක් සඳහා mapping එක පටු කරයි හෝ ප්‍රතිස්ථාපනය කරයි; කිසිවක් සුරැකෙන්නේ නැත. ඒ එක් එක් එක --engine direct අඟවයි.

EAT_API_BASE සහ EAT_APP_BASE සකසා එය ස්වයං-සත්කාරක හෝ දේශීය Tracker එකකට යොමු කරන්න; දෙකම පෙරනිමියෙන් සත්කාරක සේවාවට යොමු වේ. README හි සම්පූර්ණ flag යොමුව, පිටවීමේ කේත සහ දෝෂ නිරාකරණය ඇත.

පහත සියල්ල එම import එකමයි, කැඳවුමෙන් කැඳවුමට ධාවනය කරන ලද — agent එකක් එය ධාවනය කරන විට ඔබට අවශ්‍ය වන්නේ එයයි.

4. පළමුව වියළි ධාවනයක්

Import කිරීම හිමිකරුට පමණි — owner භූමිකාව සහිත agent යතුරක් භාවිත කරන්න, නැතහොත් agent එක member ලෙස තැබුවේ නම් ඔබේම යතුර. කිසිවක් ලිවීමට ඉඩ දීමට පෙර, පළමුව dry_run සමඟ ධාවනය කරන්න:

curl -X POST https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/import/json \
  -H "X-TrackerToken: $TRACKER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "source": "github",
        "owner": "octocat",
        "repo": "hello-world",
        "include_pull_requests": true,
        "include_milestones": true,
        "dry_run": true
      }'

වියළි ධාවනයක් GitHub වෙතින් ලබාගෙන, විසඳා, අනුපිටපත් ඉවත් කරයි — හරියටම සැබෑ එක මෙන් — එම ගණන්ම (imported, skipped, errors, unmatched) වාර්තා කර, පසුව මුළු ගනුදෙනුවම ආපසු හරවයි. කිසිවක් රැඳෙන්නේ නැත, සම්පූර්ණ වූ import සිදුවීමක් ඔබේ audit log එකට ළඟා නොවේ. milestones ඇතුළත් කිරීමට අදහස් කළ බව, නැතහොත් repo එක ඔබ සිතුවාට වඩා විශාල බව — තවම කිසිදු වියදමක් නොමැති අවස්ථාවේ — දැනගැනීමට ඇති ලාභම ක්‍රමය එයයි.

/import/json වෙත කරන සෑම ඇමතුමක්ම අසමමුහුර්තයි, වියළි ධාවනයද ඇතුළුව: endpoint එක ප්‍රතිඵලයක් නොව job handle එකක් සමඟ 202 ලබා දෙයි, ඔබ job එක poll කරන විට ගණන් එහි ලැබේ (පියවර 5). වියළි ධාවනයක job එකද සැබෑ එකක් මෙන් done වෙත ළඟා වේ; වෙනස වන්නේ කිසිවක් ලියා නොතිබීමයි.

5. import එක ධාවනය කරන්න

dry_run ඉවත් කර නැවත යවන්න. පෙර පරිදිම, endpoint එක job handle එකක් සමඟ 202 ලබා දෙයි:

{ "import_id": "…", "status": "pending" }

අවසාන තත්ත්වයකට එළඹෙන තුරු job එක විමසන්න:

curl https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/imports/$IMPORT_ID \
  -H "X-TrackerToken: $TRACKER_TOKEN"

තත්ත්වය pending → fetching → writing → done | failed ලෙස ගමන් කරයි. අවසාන දෙක පමණක් අවසන් තත්ත්ව වේ: done ප්‍රතිඵල ගණන් දරයි, failed දෝෂ පණිවිඩයක් සහ ඔබට branch කළ හැකි ස්ථාවර යන්ත්‍ර කේතයක් දරයි. Fetch එක පිටු බෙදමින් සිටින විට, progress_current සහ progress_total එය කුමන පිටුවේද යන්න කියයි — පුද්ගලයෙකු බලා සිටී නම් පෙන්වීම වටී.

Tokens. "token": "github_pat_…" යවන්න. එය අත්හැරියොත් සේවාදායකය බෙදාගත් platform token එක ආදේශ කරයි; එය පොදු repositories පමණක් කියවන අතර එහි අයවැය එම deployment එකේ සෑම කැඳවුම්කරුවෙකුගෙන්ම අඩු වේ — ටෝකන සහ අනුපාත සීමා එහි වියදම විස්තර කරයි. කුමන token එක භාවිත වුවත්, එය upstream GitHub calls පමණක් ධාවනය කරයි: එය කිසිවිටෙක log නොවේ, audit log නොවේ, ගබඩා නොවේ, ප්‍රතිචාරයක හෝ දෝෂයක නැවත echo නොවේ.

නැවත ධාවනය ආරක්ෂිතයි. දැනටමත් import වූ පේළියක් එහි source id අනුව ගැළපී මඟ හැරේ, අනුපිටපත් නොවේ. දෙවන import එක පළමු එකෙන් පසු පෙනී ගිය දෑ වලින් board එක පුරවයි.

6. board එකට ගොඩබසින දේ

Issues පෙරනිමියෙන් import වේ. අනෙක් සියල්ල විකල්ප වන අතර, වර්ගයකට එක් flag බැගින්:

GitHub වෙතින්	බවට පත් වේ	Flag
Issue	ස්ටෝරියක්. විවෘත → Backlog හි unstarted. වසා ඇත → accepted, නැතහොත් GitHub කියන්නේ issue එක not_planned හෝ duplicate ලෙස වසා ඇති බව නම් → rejected (ස්ටෝරිය එවිට ගැළපෙන label එකක් දරයි).	පෙරනිමි
Issue බඳෙහි checklist	කාර්ය — සෑම - [ ] / - [x] පේළියක්ම බඳෙහි අනුපිළිවෙළට එක් කාර්යයක් වන අතර, [x] සම්පූර්ණ තත්ත්වයෙන් පැමිණේ. Checklist එක විස්තරයේ ද රැඳේ.	පෙරනිමි
Labels	Labels, ඇති සැටියෙන් ගෙන එනු ලැබේ.	පෙරනිමි
Pull request	pull-request label සහිත ස්ටෝරියක්. විවෘත → started, merge වී ඇත → accepted, merge නොකර වසා ඇත → rejected.	include_pull_requests
Milestone	milestone එකේ නමින් epic එකක්, මාතෘකාව අනුව අනුපිටපත් ඉවත් කරන ලද — එකම milestone එක බෙදාගන්නා issues දෙකක් එකම epic එකට ගොඩබසී. Flag එක නිවා ඇත්නම් එය milestone:<මාතෘකාව> label එකක් ලෙස සමඟ එයි.	include_milestones
Release	release ස්ටෝරියක්. ප්‍රකාශයට පත් → accepted, කෙටුම්පත → unstarted.	include_releases
Issue dependency	ස්ටෝරිය මත blocker එකක්. Issues පමණි, කිසිවිටෙක pull requests නොවේ.	include_dependencies

Issue එක නොකියන විට ස්ටෝරි වර්ගය අනුමාන කෙරේ. bug, fix හෝ defect අඩංගු label එකක් — නැතහොත් fix හෝ bug වලින් ආරම්භ වන මාතෘකාවක් — එය bug එකක් කරයි; chore, maintenance, devops හෝ infra එය chore එකක් කරයි; අනෙක් සියල්ල feature වේ. Import කිරීමට පෙර මෙය දැනගැනීම වටී, මන්ද East Agile Tracker හි points දරන්නේ features පමණක් වන අතර velocity සඳහා දායක වන්නේ ද features පමණි. හැඳින්වීම → ස්ටෝරි බලන්න.

7. agent එක ස්ටෝරියක් මත වැඩ කරයි

දැන් board එකට ඉතිහාසයක් ඇත, agent එකට යතුරක් ඇත. මෙතැන් සිට චක්‍රය කැඳවුම් හතරකි.

ස්ටෝරියක් සොයන්න, නැතහොත් එකක් ලියන්න. ගැනීමට යමක් සොයා board එක පෙරන්න:

curl "https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/stories?state=unstarted" \
  -H "X-TrackerToken: $TRACKER_TOKEN"

import_source=github එය import එක ගෙනා දේට පමණක් සීමා කරයි. repo එක කිසිවිටෙක සටහන් නොකළ වැඩක් agent එක සොයාගත්තේ නම්, එය ස්ටෝරිය තනිවම නිර්මාණය කරයි — API මාර්ගෝපදේශය → ස්ටෝරියක් නිර්මාණය කිරීම බලන්න.

එය තමන් සතු කරගන්න. Agent එක හිස් body එකක් POST කිරීමෙන් තමන් හිමිකරු ලෙස එක් කරයි:

curl -X POST https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/stories/$STORY_ID/owners \
  -H "X-TrackerToken: $TRACKER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{}'

හිස් body එකක් යනු කැඳවුම්කරු යන්නයි, එබැවින් agent එකට තමන්ගේ id දැනගැනීමට අවශ්‍ය නැත. Board එක දැන් agent එක හිමිකරු ලෙස පෙන්වයි, බලා සිටින පුද්ගලයෙකු වැඩ භාරගෙන ඇති බව දැනගන්නේ එයින්ය.

එය ආරම්භ කරන්න.

curl -X POST https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/stories/$STORY_ID/transitions \
  -H "X-TrackerToken: $TRACKER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"to": "started"}'

පසුව agent එක ගොස් වැඩ කරයි — repo එක කියවයි, කේතය ලියයි, pull request එක විවෘත කරයි. එම කොටස සිදුවන්නේ ඔබේ කේතන මෙවලමේ මිස මෙහි නොවේ.

pull request එක අමුණන්න.

curl -X POST https://eastagiletracker.com/api/v1/projects/$PROJECT_ID/stories/$STORY_ID/links \
  -H "X-TrackerToken: $TRACKER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://github.com/octocat/hello-world/pull/42"}'

GitHub pull request URL එකක් එලෙසින්ම හඳුනාගැනේ — ඔබට එය කිව යුතු නැත. ස්ටෝරිය සහ එය වසන කේතය දැන් දෙපැත්තටම එක් ක්ලික් එකක් දුරින්.

එය අවසන් කරන්න. finished වෙත ගෙන ගොස් එතැනින් නවතින්න. feature එකකට තවම delivered සහ accepted ඉදිරියේ ඇත, ඒවා සමාලෝචන දොරටු වේ: වැඩ නිවැරදිද යන්න තීරණය කරන්නේ agent එක නොවන වෙනත් කෙනෙකි. chore එකකට එවැනි දොරටුවක් නැත — started → accepted යනු එහි ඉතිරි මුළු මාර්ගයයි.

ටෝකන සහ අනුපාත සීමා

සෑම import එකක්ම සත්‍යාපනය වේ. Issues, අදහස් සහ pull requests ලබාගැනීම GitHub හි GraphQL API මත ධාවනය වන අතර, GraphQL token එකක් නොමැති ඉල්ලීමක් ප්‍රතික්ෂේප කරයි — පොදු repository එකක හෝ පෞද්ගලික එකක, නිර්නාමික තලයක් නැත. ප්‍රශ්නය කිසිවිටෙක GitHub වෙත token එකක් යාද යන්න නොව, කාගේද යන්න පමණි.

ඔබේම token එක

Import කැඳවුමේ token යවන්න, නැතහොත් GitHub-to-EAT වෙත --token. repository එකේ issues කියවීමේ අවසරය සහිත සියුම් පෞද්ගලික access token එකක් ප්‍රමාණවත්. එය upstream GitHub calls පමණක් ධාවනය කරයි: කිසිවිටෙක log නොවේ, audit log නොවේ, ගබඩා නොවේ, ප්‍රතිචාරයක හෝ දෝෂයක නැවත echo නොවේ.

නිරූපණයකට වඩා වැඩි ඕනෑම දෙයකට ඔබේම එක ගෙන එන්න. එවිට ඔබ වියදම් කරන්නේ වෙන කිසිවෙකු ස්පර්ශ නොකරන අයවැයකි, තවත් කෙනෙකුගේ import එකක් නිසා කිසිදු පූර්ව පරීක්ෂාවක් ඔබට අවසර නොදී සිටිය නොහැක.

--engine direct ඔබට තේරීමක් ඉතිරි නොකරයි. එම engine එක GitHub කියවන්නේ Tracker හරහා නොව ඔබේ යන්ත්‍රයෙන් බැවින්, සේවාදායකයේ token එක ළඟා විය නොහැක; token නොමැති ධාවනයක් කිසිවක් ලබාගැනීමට හෝ ලිවීමට පෙර භාවිත දෝෂයක් සමඟ 2 වෙතින් පිටවේ. ඔබේ පරිසරයේ හෝ .env හි ඇති GITHUB_TOKEN ද --token මෙන්ම ගණන් ගැනේ.

token එක අනිවාර්ය කරන්නේ issues කරන ගමන මිස මුළු engine එක නොවේ. direct විසින් issues, අදහස් සහ pull requests GraphQL හරහා කියවයි; GraphQL හි නිර්නාමික ප්‍රකාරයක් නැත. එය REST ස්පර්ශ කරන්නේ releases ලැයිස්තුව සහ නොමිලේ /rate_limit පරීක්ෂාව සඳහා පමණි. මෙම මෙවලම තවමත් පැරණි නිර්නාමික REST fetcher එකක් සමඟ එයි — එය පැයට 60 අයවැය තුළ පොදු repository import එකක් ධාවනය කළේය — නමුත් කිසිදු CLI මාර්ගයක් තවදුරටත් එයට ළඟා නොවන අතර එය මකා දැමීමට නියමිතය. එබැවින් direct සඳහා --token අවශ්‍ය යැයි සලකන්න.

deployment එකේ බෙදාගත් token එක

token කිසිවක් නොයවන්න, එවිට සේවාදායකය එහි ක්‍රියාකරු වින්‍යාස කළ platform token එක (GITHUB_IMPORT_PAT) ආදේශ කරයි. සීමා තුනක් එය සමඟ එයි:

• එය විකල්ප වින්‍යාසයකි. සත්කාරක eastagiletracker.com එකක් සපයයි, එබැවින් token රහිත පොදු repository import එකක් එහි ක්‍රියා කරයි. ස්වයං-සත්කාරක ස්ථාපනයකට — බාගත කළ binary එකට — එහි ක්‍රියාකරු පරිසරයේ GITHUB_IMPORT_PAT සකසන තෙක් කිසිවක් නැත, එතෙක් එය සෑම token රහිත import එකක්ම 400 import_github_no_token සමඟ ප්‍රතික්ෂේප කරයි.
• එය පොදු repositories පමණක් කියවයි. සත්කාරක සේවාව එය පොදු repos මත කියවීම-පමණක් ලෙස නිකුත් කරන බැවින්, පෞද්ගලික repository එකකට සැමවිටම ඔබේම token එක අවශ්‍යයි.
• deployment එකේ සෑම කැඳවුම්කරුවෙක්ම එක් අයවැයක් බෙදාගනී. token රහිත import එකක් ධාවනය වීමට පෙර, සේවාදායකය බෙදාගත් token එකේ ඉතිරි GraphQL points කියවා, 500 ට වඩා අඩු නම් 400 import_github_shared_quota_low සමඟ ප්‍රතික්ෂේප කරයි. import එක මැද අයවැය අවසන් වුවහොත් job එක import_github_rate_limited_platform සමඟ අසාර්ථක වේ. පණිවිඩ දෙකම එකම විසඳුම නම් කරයි: ඔබේම token එක සපයන්න.

token එකෙන් ලැබෙන දේ

GitHub තම API දෙක වෙන වෙනම මනියි, සහ සත්‍යාපනය නොකළ සීමාව විශාලත්ව අනුපිළිවෙළ දෙකකින් පහළය.

GitHub API	භාවිතය	token සමඟ	token නොමැතිව
GraphQL	Issues, අදහස්, pull requests, උප-issues, dependencies	පැයට points 5,000, query එක ලබා දෙන nodes අනුව ලකුණු කරනු ලැබේ	ප්‍රතික්ෂේපයි — GraphQL හි නිර්නාමික තලයක් නැත
REST	Releases (include_releases), සහ /rate_limit පූර්ව පරීක්ෂාව	පැයට ඉල්ලීම් 5,000	පැයට ඉල්ලීම් 60, IP ලිපිනයකට ගණන් කර එය පිටුපස සිටින සියල්ලන් සමඟ බෙදාගනී

Import එකක් කිසිවිටෙක එම පැයට 60 තලයට වැටෙන්නේ නැත: යැවීමට token එකක් නොමැති විට, ඉල්ලීම නිර්නාමිකව නැවත උත්සාහ කිරීම වෙනුවට කලින්ම ප්‍රතික්ෂේප වේ. එම සංඛ්‍යාව වැදගත් වන්නේ ඔබ import එක වටා කරන දේට — GitHub කෙලින්ම කියවන script එකක්, හෝ වෙනත් clients සමඟ එකම ජාලයේ ඇති shell එකක්, තත්පර කිහිපයකින් ඉල්ලීම් 60 අවසන් කරයි.

ඔබේ ඉතිරි අයවැය ඕනෑම වේලාවක කියවන්න; GET /rate_limit සීමා දෙකෙන්ම නිදහස් බැවින්, එම පරීක්ෂාවට කිසිදු වියදමක් නැත:

curl -H "Authorization: Bearer $GITHUB_TOKEN" https://api.github.com/rate_limit

GraphQL points යනු ඉල්ලීම් නොවේ. GitHub query එකක් ලකුණු කරන්නේ එය ලබා දෙන nodes අනුව බැවින්, issues 100 ක එක් පිටුවක් ඒවායේ අදහස් සහ assignees සමඟ බොහෝ points වැය කරයි, සහ විශාල repository එකක් පැයේ අයවැය REST යුගයේ සංඛ්‍යා යෝජනා කරනවාට වඩා බෙහෙවින් අඩු කැඳවුම් ගණනකින් වැය කරයි. --dry-run (පියවර 3) සහ dry_run (පියවර 4) එක් එක් සැබෑ fetch එකට යන එම points ම වැය කරයි — ඒවායේ ගණන් විශ්වාසනීය වන්නේ එබැවිනි — එබැවින් විශාල import එකක් පූර්ව පරීක්ෂා කරන විට ගමන් දෙකකට අයවැය තබන්න.

ඊළඟට කොහෙද

• API මාර්ගෝපදේශය — සෙවුම් ව්‍යාකරණ, සිදුවීම් ධාරාව, තොග මාරුවීම්, idempotent ලිවීම්, සහ ඉතිරි මතුපිට.
• මෙහෙයුම් උපදෙස් — අතුරුමුහුණතෙන් එම ම මෙහෙයුම්, සහ අනෙක් importers දහය.
• හැඳින්වීම — state machine එක සහ ස්ටෝරි වර්ග හතර මෙම හැඩය ගන්නේ ඇයි.
• GitHub-to-EAT — importer එකේම repository එක: සෑම flag එකක්ම, engines දෙකම, සහ එයට දායක වන ආකාරය.