דילוג לתוכן
תפריט

המוצר

פתרונות

אינטגרציות

מפתחים

שפה

מפתחים

תורמים ל-ai-memory

עד עכשיו 140 אנשים הכניסו קוד. הדף הזה לוקח אתכם מרעיון אל ה-issue הנכון, אל ה-crate הנכון ואל pull request שעובר review בפעם הראשונה.

בחירת דרך כניסה

כל אחת מהן מובילה בדיוק לדף הנכון ב-GitHub.

תרשים: תרומה עוברת שישה שלבים, מ-issue, ל-branch, לבדיקות החובה המקומיות, ל-pull request, ל-review, ומשם יוצאת בגרסה הבאה.
מרעיון עד גרסה. תיקונים יוצאים ב-patch הבא, ופיצ'רים שרק מוסיפים יוצאים ב-minor הבא.

מגיעים ל-build שעובד

ה-build עומד בפני עצמו. אף אחת מהפקודות האלה לא צריכה משתנה סביבה.

  1. עושים clone ו-build

    נדרש Rust 1.95, והוא מקובע ב-rust-toolchain.toml יחד עם rustfmt ו-clippy, כך ש-rustup מתקין את ה-toolchain הנכון ב-build הראשון. SQLite מגיע ארוז בפנים ו-libgit2 הוא vendored. צריך toolchain סטנדרטי של C ושום דבר מעבר לזה.

    סביבת פיתוח
    git clone https://github.com/akitaonrails/ai-memory
    cd ai-memory
    cargo build --workspace
    cargo test --workspace --all-targets
    
  2. עובדים עם הלולאה היומיומית

    cargo t צריך את nextest: cargo install cargo-nextest --locked. הוא מדלג על מודולים בשם slow או stress, שה-pre-push hook וה-CI עדיין מריצים.

    תוך כדי עבודה
    cargo t                        # הכול חוץ מהשכבה האיטית, כ-20 שניות כשה-cache חם
    cargo t -p ai-memory-store     # crate אחד: בונה רק את קובצי הטסט שלו
    cargo t -E 'test(/purge/)'     # נושא אחד (בונה הכול, מריץ תת-קבוצה)
    
  3. מתקינים את ה-pre-push hook

    פעם אחת לכל clone. הוא נוגע רק בבלוק של עצמו בתוך .git/hooks/pre-push. ב-branch של עבודה בתהליך, git push --no-verify מדלג עליו.

    פעם אחת לכל clone
    scripts/install-git-hooks.sh
    
  4. עוברים את בדיקות החובה לפני push

    ה-CI אוכף את כל החמש. בלי nextest, הפקודה cargo test --workspace --all-targets שקולה ל-cargo tf. אם האחרונה חסרה: cargo install cargo-deny cargo-audit.

    בדיקות החובה
    cargo fmt --all -- --check
    git diff --check
    cargo clippy --workspace --all-targets -- -D warnings
    cargo tf                            # כל הטסטים (alias: cargo nextest run -P full)
    cargo deny check                    # מדיניות תלויות
    
  5. בודקים על שם מי ה-commits שלכם רשומים

    משתמשים באימייל שאומת בחשבון ה-GitHub שלכם, או בכתובת ה-noreply שלו. ההיסטוריה ב-main אף פעם לא נכתבת מחדש כדי לתקן ייחוס.

    ייחוס של commits
    git log --format='%h %an <%ae>' "$(git merge-base HEAD origin/main)"..HEAD
    

כללי היסוד ורף הקבלה

AGENTS.md הוא קובץ הכללים הקנוני, לאנשים ולסוכני קוד. CONTRIBUTING.md מתמצת אותו לזה.

איך עבודה אמורה להיכנס

  • יומן השינויים הוא תנאי ל-merge

    כל שינוי שגלוי למשתמש מוסיף רשומה תחת [Unreleased] באותו pull request. רשומה חסרה חוסמת את ה-review. refactors ושינויים בטסטים בלבד פטורים.

  • טסטים לפני "גמור"

    עבודה נחשבת גמורה כשיש לה טסטים, ובראש ובראשונה parsers, גזירת מזהים וחישובי ה-retention.

  • בלי קוד מת, בלי פיצ'רים חצי בנויים

    stubs מתועדים בהערת המודול, יחד עם אבן הדרך שתשלים אותם.

  • נשארים בתוך גבולות השינוי

    לא עושים refactor לקוד שאבן הדרך הנוכחית לא צריכה.

  • הערות מסבירות למה

    הערה שחוזרת על השורה שמעליה נמחקת.

אינווריאנטים ש-pull request לא יכול לשבור

  • כל הכתיבות ל-SQLite עוברות דרך ה-writer actor היחיד, WriterHandle.
  • הקונפיגורציה נקראת פעם אחת בעלייה. אין std::env::var מחוץ ל-Config::load.
  • כתיבות לקבצים הן אטומיות: tmp, rename, fsync. אף פעם לא במקום.
  • כל דף ויקי משויך ל-namespace של (workspace_id, project_id).
  • ה-CLI הוא לקוח HTTP דק. הוא אף פעם לא פותח את קובץ ה-SQLite או את תיקיית הוויקי.

הרשימה המלאה, עם הבאג שכל אחד מהם מונע, נמצאת ב-AGENTS.md

איך הרף נשאר גבוה

AI כותב את רוב הקוד. אדם קורא את כולו, ושום קוד לא עובר merge על סמך אמון בלבד. כל כלל שמופיע כאן קיים כי משהו השתבש פעם אחת.

תרשים: לולאה בארבעה שלבים. טעות הופכת לכלל כתוב, הכלל מקבל טסט שמנסה לשבור אותו, והטסט רץ כשער על כל pull request. אדם יושב במרכז ומחליט.
שום דבר מזה לא היה קיים ביום הראשון. כל כלל נוסף אחרי טעות אמיתית, וכל אחד נבדק בכל pull request.
  • כללים מגיעים מטעויות

    כל אינווריאנט מפרט את הבאג שגרם לו ואת הקוד שמונע אותו. כלל שאי אפשר לשייך לתקלה מוסר.

  • כל pull request עובר ביקורת

    הטענות ב-pull request נבדקות מול הקוד, בדיקות החובה רצות שוב, ורק מה שאומת עובר merge. ה-checklists של הביקורת פומביים.

  • אדם מחליט

    ה-AI עושה את רוב ההקלדה. המתחזק קורא, מתקן, והופך את מה שהשתבש לכלל הבא.

לקריאת ה-checklists של הביקורת

שני מודלים, checklist אחד לביקורת

ניסוי קטן ב-ai-jail, ה-sandbox שאפשר למסור אליו הרצת --yolo. אותו checklist של security-audit הורץ על ידי שני מודלים, על אותו commit, ואז הושווה.

  • היעד

    ai-jail מריץ סוכן קוד בתוך sandbox של מערכת ההפעלה: bubblewrap עם Landlock ו-seccomp ב-Linux, sandbox-exec ב-macOS. זו שכבת הגנה, לא תחליף למכונה חד-פעמית כשהקוד עוין.

    aijail.io
  • הריצה הראשונה

    Genesys Pi, שהופעל דרך OpenCode, קודם ביצע עבודת פיתוח רגילה על ai-jail ומיזג אותה. אחר כך הוא הריץ את ה-checklist של security-audit ממאגר ה-skills הציבורי מול v2.3.0.

    הפוסט על ה-skills
  • הריצה השנייה

    Claude Fable 5.1 הריץ את אותו checklist על אותו commit, בלי לקרוא את הדוח הראשון. לאחר שרשימתו ננעלה, הוא גזר מחדש מהמקור כל ממצא משותף וכתב את ההשוואה.

  1. נמצא על ידי שניהם11
  2. רק Genesys Pi11
  3. רק Claude Fable 5.13
כל רמות החומרה כפי שכל דוח קבע אותן. שני הדוחות שחזרו בעצמם את אותם שני ממצאי High.
  • אותם שני ממצאי High

    מטא-דאטה מזויף של worktree העניק הרשאות קריאה וכתיבה על תיקיית host, וערכי environment כפולים עקפו את ה-phantom secret. כל אחד מהמודלים שחזר את שניהם בעצמו, בלי תלות באחר.

  • Genesys Pi כיסה יותר שטח

    אחד עשר ממצאים שרק הוא הגיע אליהם, וביניהם כל משטח ה-macOS ומגבלות המשאבים של ה-proxy, עם קביעות חומרה מדויקות יותר. Fable דחה באג אמיתי אחד והשאיר שניים נוספים לא פתורים עד ההצלבה בין הדוחות.

  • Fable איתר את הפספוס החד ביותר

    שני escape hatches שנועדו לטסטים בלבד בתוך ה-binary של ה-release, נקראים מה-environment וממוקמים בדיוק על הנתיב שה-phantom credentials אמורים להגן עליו. הוא גם הריץ בפועל את ה-exploits, במקום שבו הדוח השני רק נימק לגביהם.

שלושת הדוחות, במאגר ai-jail

מפה של בסיס הקוד

עשרה crates נכנסים לקובץ הבינארי. לכל אחד יש אחריות אחת ו-API מטופס, ואין תלויות מעגליות.

תרשים: ה-crates בארבע שכבות. ה-crate cli נמצא למעלה. מתחתיו hooks, mcp, web, consolidate ו-workstream. מתחתיהם store, wiki ו-llm. ה-crate core הוא היסוד שמתחת לכול.
שמות ה-crates בלי הקידומת ai-memory-. הכול תלוי ב-core, ורק ה-crate cli תלוי בכול.
Crateמה יושב שם
ai-memory-coreטיפוסי הדומיין, שגיאות ומזהים. בלי IO.
ai-memory-storeSQLite, ה-writer actor, מאגר הקוראים וחישובי הדעיכה.
ai-memory-wikiכתיבות markdown אטומיות, ה-file watcher ו-git.
ai-memory-mcpה-transport של MCP, נתב הכלים ונתיבי הניהול.
ai-memory-hooksסכמות ה-payload של ה-hooks, ה-sanitizer וה-endpoint של /hook.
ai-memory-llmגבול האימות מול הספקים וה-traits של ה-LLM ושל ה-embedder.
ai-memory-consolidateהזנה, lint, sweep וה-pipeline של auto-improve.
ai-memory-webהדפדפן לקריאה בלבד ב-/web ונתיבי ה-JSON של /api/v1.
ai-memory-workstreamקוראים לקריאה בלבד של תמלילים נייטיב, ומתאמי ההפעלה שמאחורי ai-memory run.
ai-memory-cliהקובץ הבינארי ai-memory ותת-הפקודות הדקות שלו מעל HTTP.

מחוץ ל-crates/

תיקייהמה יושב שם
companions/ai-memory-importer, חבילה עצמאית מחוץ ל-workspace הראשי. בונים אותה עם --manifest-path.
hooks/חבילות hooks של מחזור החיים, תיקייה לכל סוכן, ב-shell ונייטיב.
evals/ה-harness של הבנצ'מרק. חבר ב-workspace שאף פעם לא משוחרר.
docs/ארכיטקטורה, החלטות תכנון, ומדריכי התקנה, פריסה ושימוש.
tests/טסטי smoke מקצה לקצה, טסטי shell של ה-hooks ו-fixtures.

טסטי האינטגרציה יושבים ב-tests/suite/ בתוך כל crate. עזרים שמשותפים לכמה crates נכנסים ל-crates/ai-memory-test-support, שאף פעם לא משוחרר.

איך עושים review ל-pull requests

ה-review הולך לפי תבנית ה-pull request, אז מילוי כן שלה הוא רוב העבודה.

  • התבנית היא ה-checklist

    היא שואלת מה השתנה, למה, מה תוכנית הבדיקות עם בדיקות החובה מסומנות, ייחוס ה-commits, ההשפעה על הגרסה ורשומת יומן השינויים.

  • אומרים איזה סוג גרסה זה

    מסמנים patch, minor או major. תיקון שנרשם תחת "Added" עלול להקפיץ את הגרסה הלא נכונה, אז שמים את הרשומה ביומן השינויים תחת הכותרת הנכונה.

  • שינויים שוברים מחכים ל-major

    מציינים אותם בתיאור. הם מקבלים את התווית breaking-change ומתוזמנים, כך שהם לא מעכבים גרסאות patch ו-minor.

  • ה-CI מהיר בכל merge

    merge מותנה ב-jobs המהירים של Linux. ה-jobs של macOS ושל Windows רצים לפי תווית, מדי לילה או ידנית, ותמיד לפני גרסה.

  • תיקונים יוצאים ראשונים

    תיקון באג יוצא בגרסת ה-patch הבאה ולא מחכה לעבודה על פיצ'רים. harness חדש או ספק חדש יוצאים ב-minor הבא.

pull request של harness מריץ את הבדיקה המקוצרת הזאת, רושם מול איזו גרסת CLI הוא נבדק, וכולל מעבר ידני מול ה-harness האמיתי.

מתוך managed-harness-contributions.md
cargo fmt --check
git diff --check
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings

נסו אותו לפני שמשנים אותו.

מריצים אותו יום אחד על הפרויקטים שלכם. הבאג שתמצאו הוא ה-issue הראשון שלכם.