Tutorial 2 How the Code Works kn

ಟ್ಯುಟೋರಿಯಲ್ 2 · ಕೋಡ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಗುರಿ: ಈ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು AI ಏಜೆಂಟ್ ಜೊತೆ ಬದಲಾಯಿಸಲು ಸುಲಭ — ಮತ್ತು ಸುರಕ್ಷಿತ — ಮಾಡುವ ಕೆಲವೇ ಡಿಸೈನ್ ಆಯ್ಕೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು. ನೀವು ಕೋಡ್ ಅನ್ನು ಬಾಯಿಪಾಠ ಮಾಡಬೇಕಿಲ್ಲ; ನಿಮಗೆ ಮಾನಸಿಕ ಮಾದರಿ ಬೇಕು, ಇದರಿಂದ ನೀವು ಏಜೆಂಟ್‌ಗೆ ನಿಖರವಾಗಿ ನಿರ್ದೇಶಿಸಬಹುದು.

← ಹಿಂದಿನದು: ಟ್ಯುಟೋರಿಯಲ್ 1 ಪರಿಚಯ · ಮುಂದೆ: ಟ್ಯುಟೋರಿಯಲ್ 3 ನಿಮ್ಮ ಮೊದಲ ಏಜೆಂಟ್ ಟಾಸ್ಕ್

---

ನಕ್ಷೆ

lockedin-cli/
├── bin/lockedin.js      # entry point — input/output ಮಾಡುವ ಏಕೈಕ ಭಾಗ
├── src/lockedin.js      # core — string ಹಿಂತಿರುಗಿಸುವ pure function ಗಳು
├── test/
│   ├── unit.test.js     # core function ಗಳನ್ನು ನೇರವಾಗಿ test ಮಾಡುತ್ತದೆ
│   └── cli.test.js      # ನಿಜವಾದ binary ಚಲಾಯಿಸಿ ಅದರ output ಪರಿಶೀಲಿಸುತ್ತದೆ
├── tools/screenshot.js  # docs/ ನಲ್ಲಿ ಕಾಣುವ SVG ಗಳನ್ನು render ಮಾಡುತ್ತದೆ
└── package.json         # metadata + `npm test` script

ನಾಲ್ಕು ಕಲ್ಪನೆಗಳು ಇದನ್ನು ನಡೆಸುತ್ತವೆ. ಇವನ್ನು ಕಲಿಯಿರಿ, ಆಗ ನೀವು ಬಹುತೇಕ ಯಾವುದೇ ಬದಲಾವಣೆಯನ್ನು ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ಏಜೆಂಟ್‌ಗೆ ಕೇಳಬಹುದು.

ಕಲ್ಪನೆ 1 — string ಹಿಂತಿರುಗಿಸುವ pure core

src/lockedin.js ತೆರೆಯಿರಿ. render function ಗಳು print ಮಾಡುವುದಿಲ್ಲ — ಅವು string ಹಿಂತಿರುಗಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ:

function renderConnect() {
  const names = shuffle(NAMES).slice(0, 6);
  // ...ಸಾಲುಗಳ ಒಂದು array ಕಟ್ಟುತ್ತದೆ...
  return out.join('\n');   // text ಹಿಂತಿರುಗಿಸುತ್ತದೆ; ಏನನ್ನೂ print ಮಾಡುವುದಿಲ್ಲ
}

ಎಲ್ಲಾ ನಿಜವಾದ printing (ಮತ್ತು ನಿಮ್ಮ keystroke ಓದುವುದು) bin/lockedin.js ನಲ್ಲಿ ನಡೆಯುತ್ತದೆ. ಈ "core data ಹಿಂತಿರುಗಿಸುತ್ತದೆ, edge I/O ಮಾಡುತ್ತದೆ" ವಿಭಜನೆ ಇಲ್ಲಿನ ಅತ್ಯಂತ ಮುಖ್ಯ ವಿಷಯ, ಏಕೆಂದರೆ ಕೇವಲ ಒಂದು string ಹಿಂತಿರುಗಿಸುವ function ಅನ್ನು test ಮಾಡುವುದು ಅತ್ಯಂತ ಸುಲಭ:

const out = app.renderConnect();
assert.ok(out.includes("“ನಿಮ್ಮನ್ನು ನನ್ನ professional network ಗೆ add ಮಾಡಲು ಇಷ್ಟ.” — ಕಳುಹಿಸಿದ್ದು "));

terminal mock ಇಲ್ಲ, stdout capture ಇಲ್ಲ. ನೀವು ಏಜೆಂಟ್‌ಗೆ ಒಂದು feature ಸೇರಿಸಲು ಹೇಳಿದಾಗ, ಈ ಕಾರಣಕ್ಕಾಗಿಯೇ ಅದು ಅದಕ್ಕೆ ಒಂದು ವೇಗದ, ವಿಶ್ವಾಸಾರ್ಹ test ಅನ್ನೂ ಸೇರಿಸಬಲ್ಲದು.

ಕಲ್ಪನೆ 2 — Content pool ಗಳು

ತಮಾಷೆಗಳು src/lockedin.js ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಸರಳ array ಗಳಲ್ಲಿ ವಾಸಿಸುತ್ತವೆ:

const HOOKS = [ 'Unpopular opinion:', 'ಅದನ್ನು sink in ಆಗಲು ಬಿಡಿ.', /* ...~25 total... */ ];
const LESSONS = [ '→ ನಿಮ್ಮ network ನಿಮ್ಮ net worth.', /* ... */ ];

Generator ಗಳು ಈ pool ಗಳಿಂದ ಆಯ್ಕೆ ಮಾಡುತ್ತವೆ. v1.2.0 ನಲ್ಲಿ ಪ್ರತಿ pool ~25 variation ಗೆ ಬೆಳೆಯಿತು, ಮತ್ತು template pool ಗಳ ಎರಡನೇ ಪದರ ಸೇರಿಸಲಾಯಿತು (POST_REVEALS ಮತ್ತು REFLECT_TAGSETS ನಂತಹವು) ಇದರಿಂದ ಪ್ರತಿ output ನ ರಚನೆ ಬದಲಾಗುತ್ತದೆ, ಕೇವಲ ಪದಗಳಲ್ಲ. content ಸೇರಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು array ಗೆ string ಸೇರಿಸುವಷ್ಟೇ ಸರಳ — ಏಜೆಂಟ್‌ಗೆ ಕೊಡಲು ಒಂದು ಪರಿಪೂರ್ಣ ಮೊದಲ ಟಾಸ್ಕ್.

ಕಲ್ಪನೆ 3 — Seeded randomness = deterministic test ಗಳು

random output ಮತ್ತು automated test ಗಳು ಕೇಳಲು ಹೊಂದಿಕೆಯಾಗದಂತೆ ತೋರುತ್ತವೆ. ಈ ಪ್ರಾಜೆಕ್ಟ್ ಆ ವೃತ್ತವನ್ನು ಒಂದು seed ಮಾಡಬಹುದಾದ random number generator ನೊಂದಿಗೆ ಪರಿಹರಿಸುತ್ತದೆ:

setSeed(42);
const a = generatePost();
setSeed(42);
const b = generatePost();
// a === b  → ಅದೇ seed, ಅದೇ post

ಪ್ರತಿ random ಆಯ್ಕೆ ಹಂಚಿದ pick() / shuffle() helper ಗಳ ಮೂಲಕ ಹೋಗುತ್ತದೆ, ಅವು ಆ seeded generator ನಿಂದ ಎಳೆಯುತ್ತವೆ. LOCKEDIN_SEED=42 ಸೆಟ್ ಮಾಡಿ ಮತ್ತು CLI ಸಂಪೂರ್ಣ reproducible. ಯಾವುದೇ ಬದಲಾವಣೆಗೆ ಸುವರ್ಣ ನಿಯಮ: ಹೊಸ randomness pick / shuffle ಬಳಸಬೇಕು, ಎಂದಿಗೂ ನೇರವಾಗಿ Math.random ಅಲ್ಲ — ಇಲ್ಲದಿದ್ದರೆ determinism (ಮತ್ತು test ಗಳು) ಮುರಿಯುತ್ತವೆ. ಇದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ; ಅಧ್ಯಾಯ 3 ರಲ್ಲಿ ನೀವು ಏಜೆಂಟ್‌ಗೆ ಇದನ್ನು ನೆನಪಿಸುತ್ತೀರಿ.

ಕಲ್ಪನೆ 4 — test ಗಳ ಎರಡು ಪದರಗಳು

• test/unit.test.js core function ಗಳನ್ನು call ಮಾಡುತ್ತದೆ ಮತ್ತು ಅವು ಹಿಂತಿರುಗಿಸುವ string ಗಳ ಮೇಲೆ assert ಮಾಡುತ್ತದೆ (ವೇಗ, ನಿಖರ).
• test/cli.test.js ವಾಸ್ತವವಾಗಿ bin/lockedin.js ಅನ್ನು ಚಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ನಿಜವಾದ stdout ಮತ್ತು exit code ಪರಿಶೀಲಿಸುತ್ತದೆ (ಇಡೀ ವಿಷಯ ಆದ್ಯಂತ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂದು ಸಾಬೀತುಪಡಿಸುತ್ತದೆ).

ಒಟ್ಟಿಗೆ ಇವು ಗೇಟ್. ಇವು invariant ಗಳನ್ನೂ encode ಮಾಡುತ್ತವೆ — ಆ್ಯಪ್ ಕೊಡುವ ಭರವಸೆಗಳು. ಉದಾಹರಣೆಗೆ, ಒಂದು post ಯಾವಾಗಲೂ ಒಂದು ತಿಳಿದ hook ನಿಂದ ಆರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಯಾವಾಗಲೂ ಕನಿಷ್ಠ ಮೂರು → lesson ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ; "connect" screen ಯಾವಾಗಲೂ incalculable ಎನ್ನುತ್ತದೆ. ಏಜೆಂಟ್ ಕೋಡ್ ಬದಲಾಯಿಸಿದಾಗ, ಈ test ಗಳು ಮೌನವಾಗಿ ಮುರಿದ ಯಾವುದೇ ಭರವಸೆಯನ್ನು ಹಿಡಿಯುತ್ತವೆ.

---

ಏಜೆಂಟ್ ಜೊತೆ ಕೆಲಸಕ್ಕೆ ಇದು ಏಕೆ ಮುಖ್ಯ

ನಾಲ್ಕು ಕಲ್ಪನೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಇಡಿ ಮತ್ತು ನಿಮಗೆ ಒಂದು ಏಜೆಂಟ್ ಈ ಕೆಲಸ ಮಾಡಬಲ್ಲ codebase ಸಿಗುತ್ತದೆ:

1. string ಹಿಂತಿರುಗಿಸುವ pure function ಆಗಿ ಒಂದು feature ಸೇರಿಸುವುದು,
2. ಯಾವುದೇ I/O ಸರ್ಕಸ್ ಇಲ್ಲದೆ ಅದಕ್ಕೆ ಒಂದು test ಸೇರಿಸುವುದು,
3. seeded RNG ಮೂಲಕ output ಅನ್ನು reproducible ಇಡುವುದು, ಮತ್ತು
4. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗೇಟ್ ಚಲಾಯಿಸಿ ಏನೂ ಮುರಿಯಲಿಲ್ಲ ಎಂದು ಸಾಬೀತುಪಡಿಸುವುದು.

ಇದೇ ನೀವು ಮುಂದಿನ ಅಧ್ಯಾಯದಲ್ಲಿ ಚಲಾಯಿಸುವ loop.

✅ ನಿಮ್ಮ ಏಜೆಂಟ್ ಜೊತೆ ಪ್ರಯತ್ನಿಸಿ

ನಿಮ್ಮ ಏಜೆಂಟ್‌ಗೆ ನಿಮ್ಮ ತಿಳಿವಳಿಕೆಯನ್ನು verify ಮಾಡಲು ಹೇಳಿ — ಓದಿ, edit ಮಾಡದೆ:

1. "src/lockedin.js ನ ಪ್ರತಿ content pool ಮತ್ತು ಪ್ರತಿಯೊಂದರಲ್ಲಿ ಎಷ್ಟು entry ಇವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡು."
2. "test/unit.test.js generatePost ಬಗ್ಗೆ ಜಾರಿಗೊಳಿಸುವ ಒಂದು invariant ಅನ್ನು ತೋರಿಸು, ಮತ್ತು ಅದನ್ನು ಏನು ಮುರಿಯುತ್ತದೆ ಎಂದು ವಿವರಿಸು."
3. "seeded RNG ಎಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಮತ್ತು ಯಾವ function ಗಳು Math.random ಬದಲಿಗೆ ಅದನ್ನು ಬಳಸಲೇಬೇಕು? ಏನನ್ನೂ ಬದಲಾಯಿಸಬೇಡ — ಕೇವಲ ವಿವರಿಸು."

ಏಜೆಂಟ್‌ನ ಉತ್ತರಗಳು ಈ ಅಧ್ಯಾಯದೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾದಾಗ, ನೀವು ಕಟ್ಟಲು ಸಿದ್ಧ.

ಮುಂದೆ: ಟ್ಯುಟೋರಿಯಲ್ 3 ನಿಮ್ಮ ಮೊದಲ ಏಜೆಂಟ್ ಟಾಸ್ಕ್