failproofai 0.0.6-beta.2 → 0.0.6-beta.4

package/.next/standalone/docs/he/testing.mdx

@@ -1,260 +0,0 @@
----
-title: בדיקות
-description: "בדיקות יחידה, בדיקות E2E ומסייעי בדיקה"
-icon: flask-vial
----
-
-failproofai כולל שתי חבילות בדיקה: **בדיקות יחידה** (מהירות, עם mocked) ו**בדיקות end-to-end** (קריאות subprocess אמיתיות).
-
----
-
-## הרצת בדיקות
-
-```bash
-# הרץ את כל בדיקות היחידה פעם אחת
-bun run test:run
-
-# הרץ בדיקות יחידה במצב watch
-bun run test
-
-# הרץ בדיקות E2E (דורש הגדרה - ראה להלן)
-bun run test:e2e
-
-# Type-check ללא בנייה
-bunx tsc --noEmit
-
-# Lint
-bun run lint
-```
-
----
-
-## בדיקות יחידה
-
-בדיקות יחידה נמצאות ב-`__tests__/` והן משתמשות ב-[Vitest](https://vitest.dev) עם `happy-dom`.
-
-```text
-__tests__/
-  hooks/
-    builtin-policies.test.ts      # Logic מדיניות עבור כל builtin
-    hooks-config.test.ts          # טעינת config והיתוך scope
-    policy-evaluator.test.ts      # Param injection וסדר הערכה
-    custom-hooks-registry.test.ts # globalThis registry add/get/clear
-    custom-hooks-loader.test.ts   # ESM loader, transitive imports, טיפול בשגיאות
-    manager.test.ts               # פעולות install/remove/list
-  components/
-    sessions-list.test.tsx        # רכיב רשימת sessions
-    project-list.test.tsx         # רכיב רשימת projects
-    ...
-  lib/
-    logger.test.ts
-    paths.test.ts
-    date-filters.test.ts
-    telemetry.test.ts
-    ...
-  actions/
-    get-hooks-config.test.ts
-    get-hook-activity.test.ts
-    ...
-  contexts/
-    ThemeContext.test.tsx
-    AutoRefreshContext.test.tsx
-```
-
-### כתיבת בדיקת יחידה למדיניות
-
-```typescript
-import { describe, it, expect, beforeEach } from "vitest";
-import { getBuiltinPolicies } from "../../src/hooks/builtin-policies";
-import { allow, deny } from "../../src/hooks/policy-types";
-
-describe("block-sudo", () => {
-  const policy = getBuiltinPolicies().find((p) => p.name === "block-sudo")!;
-
-  it("denies sudo commands", () => {
-    const ctx = {
-      eventType: "PreToolUse" as const,
-      payload: {},
-      toolName: "Bash",
-      toolInput: { command: "sudo apt install nodejs" },
-      params: { allowPatterns: [] },
-    };
-    expect(policy.fn(ctx)).toEqual(deny("sudo command blocked by failproofai"));
-  });
-
-  it("allows non-sudo commands", () => {
-    const ctx = {
-      eventType: "PreToolUse" as const,
-      payload: {},
-      toolName: "Bash",
-      toolInput: { command: "ls -la" },
-      params: { allowPatterns: [] },
-    };
-    expect(policy.fn(ctx)).toEqual(allow());
-  });
-
-  it("allows patterns in allowPatterns", () => {
-    const ctx = {
-      eventType: "PreToolUse" as const,
-      payload: {},
-      toolName: "Bash",
-      toolInput: { command: "sudo systemctl status nginx" },
-      params: { allowPatterns: ["sudo systemctl status"] },
-    };
-    expect(policy.fn(ctx)).toEqual(allow());
-  });
-});
-```
-
----
-
-## בדיקות end-to-end
-
-בדיקות E2E מפעילות את ה-failproofai הבינארי האמיתי כתת-תהליך, מעביר payload JSON ל-stdin, וקובע את ה-stdout וקוד היציאה. זה בדוק את הנתיב של האינטגרציה המלא שבו Claude Code משתמש.
-
-### הגדרה
-
-בדיקות E2E מריצות את הבינארי ישירות מה-source של ה-repo. לפני ההרצה הראשונה, בנה את ה-CJS bundle שקובצי custom hook משתמשים בהם כאשר הם מייבאים מ-`'failproofai'`:
-
-```bash
-bun build src/index.ts --outdir dist --target node --format cjs
-```
-
-ואז הרץ את הבדיקות:
-
-```bash
-bun run test:e2e
-```
-
-בנה מחדש את `dist/` בכל פעם שאתה משנה את public hook API (`src/hooks/custom-hooks-registry.ts`, `src/hooks/policy-helpers.ts`, או `src/hooks/policy-types.ts`).
-
-### מבנה בדיקה E2E
-
-```text
-__tests__/e2e/
-  helpers/
-    hook-runner.ts      # Spawn הבינארי, pipe payload JSON, ספור exit code + stdout + stderr
-    fixture-env.ts      # temp directories מבודדים per-test עם קובצי config
-    payloads.ts         # Claude-accurate payload factories עבור כל event type
-  hooks/
-    builtin-policies.e2e.test.ts   # כל מדיניות builtin עם subprocess אמיתי
-    custom-hooks.e2e.test.ts       # טעינה והערכה של custom hook
-    config-scopes.e2e.test.ts      # היתוך config על פני project/local/global
-    policy-params.e2e.test.ts      # Param injection עבור כל מדיניות parametrized
-```
-
-### שימוש ב-E2E helpers
-
-**`FixtureEnv`** - סביבה מבודדת per-test:
-
-```typescript
-import { createFixtureEnv } from "../helpers/fixture-env";
-
-const env = createFixtureEnv();
-// env.cwd    - temp dir; העבר כ-payload.cwd כדי להרים את .failproofai/policies-config.json
-// env.home   - isolated home dir; אין דליפה של ~/.failproofai אמיתי
-
-env.writeConfig({
-  enabledPolicies: ["block-sudo"],
-  policyParams: {
-    "block-sudo": { allowPatterns: ["sudo systemctl status"] },
-  },
-});
-```
-
-`createFixtureEnv()` רושם ניקוי `afterEach` באופן אוטומטי.
-
-**`runHook`** - קרא את הבינארי:
-
-```typescript
-import { runHook } from "../helpers/hook-runner";
-import { Payloads } from "../helpers/payloads";
-
-const result = await runHook(
-  "PreToolUse",
-  Payloads.preToolUse.bash("sudo apt install nodejs", env.cwd),
-  { homeDir: env.home }
-);
-
-expect(result.exitCode).toBe(0);
-expect(result.parsed?.hookSpecificOutput?.permissionDecision).toBe("deny");
-```
-
-**`Payloads`** - factories payload מוכנות:
-
-```typescript
-Payloads.preToolUse.bash(command, cwd)
-Payloads.preToolUse.write(filePath, content, cwd)
-Payloads.preToolUse.read(filePath, cwd)
-Payloads.postToolUse.bash(command, output, cwd)
-Payloads.postToolUse.read(filePath, content, cwd)
-Payloads.notification(message, cwd)
-Payloads.stop(cwd)
-```
-
-### כתיבת בדיקת E2E
-
-```typescript
-import { describe, it, expect } from "vitest";
-import { createFixtureEnv } from "../helpers/fixture-env";
-import { runHook } from "../helpers/hook-runner";
-import { Payloads } from "../helpers/payloads";
-
-describe("block-rm-rf (E2E)", () => {
-  it("denies rm -rf", async () => {
-    const env = createFixtureEnv();
-    env.writeConfig({ enabledPolicies: ["block-rm-rf"] });
-
-    const result = await runHook(
-      "PreToolUse",
-      Payloads.preToolUse.bash("rm -rf /", env.cwd),
-      { homeDir: env.home }
-    );
-
-    expect(result.exitCode).toBe(0);
-    expect(result.parsed?.hookSpecificOutput?.permissionDecision).toBe("deny");
-  });
-
-  it("allows non-recursive rm", async () => {
-    const env = createFixtureEnv();
-    env.writeConfig({ enabledPolicies: ["block-rm-rf"] });
-
-    const result = await runHook(
-      "PreToolUse",
-      Payloads.preToolUse.bash("rm /tmp/file.txt", env.cwd),
-      { homeDir: env.home }
-    );
-
-    expect(result.exitCode).toBe(0);
-    expect(result.stdout).toBe("");  // allow → empty stdout
-  });
-});
-```
-
-### צורות תגובה E2E
-
-| החלטה | קוד יציאה | stdout |
-|----------|-----------|--------|
-| `PreToolUse` deny | `0` | `{"hookSpecificOutput":{"permissionDecision":"deny","permissionDecisionReason":"..."}}` |
-| `PostToolUse` deny | `0` | `{"hookSpecificOutput":{"additionalContext":"Blocked ... because: ..."}}` |
-| Instruct (non-Stop) | `0` | `{"hookSpecificOutput":{"additionalContext":"Instruction from failproofai: ..."}}` |
-| Stop instruct | `2` | empty stdout; reason in stderr |
-| Allow | `0` | empty string |
-
-### תצורת Vitest
-
-בדיקות E2E משתמשות ב-`vitest.config.e2e.mts` עם:
-
-- `environment: "node"` - אין צורך בגלובלים של דפדפן
-- `pool: "forks"` - isolation true process (בדיקות spawn subprocesses)
-- `testTimeout: 20_000` - 20s per test (binary startup + hook eval)
-
-ה-`forks` pool חשוב: עובדים המבוססים על thread משתפים `globalThis`, שיכול להפריע לבדיקות spawning-subprocess. Process-based forks להימנע מזה.
-
----
-
-## CI
-
-הרצת CI המלאה (`bun run lint && bunx tsc --noEmit && bun run test:run && bun run build`) נדרשת להעביר לפני merge. חבילת E2E רצה כעבודת CI נפרדת במקביל.
-
-ראה [Contributing](../CONTRIBUTING.md) לרשימת הבדיקה המוקדמת המלאה למיזוג.

package/.next/standalone/docs/hi/architecture.mdx

@@ -1,334 +0,0 @@
----
-
----
-title: आर्किटेक्चर
-description: "हुक हैंडलर, कॉन्फ़िगरेशन लोडिंग और पॉलिसी मूल्यांकन आंतरिक रूप से कैसे काम करते हैं"
-icon: sitemap
----
-
-यह दस्तावेज़ बताता है कि failproofai आंतरिक रूप से कैसे काम करता है: हुक सिस्टम एजेंट टूल कॉल को कैसे इंटरसेप्ट करता है, कॉन्फ़िगरेशन कैसे लोड और मर्ज होता है, पॉलिसीज़ का मूल्यांकन कैसे होता है, और डैशबोर्ड एजेंट गतिविधि को कैसे मॉनिटर करता है।
-
----
-
-## सारांश
-
-failproofai के दो स्वतंत्र उपप्रणालियां हैं:
-
-1. **हुक हैंडलर** - एक तेज़ CLI उपप्रक्रिया जो Claude Code हर एजेंट टूल कॉल पर आमंत्रित करती है। पॉलिसीज़ का मूल्यांकन करता है और एक निर्णय देता है।
-2. **एजेंट मॉनिटर (डैशबोर्ड)** - एजेंट सत्रों की निगरानी और पॉलिसीज़ को प्रबंधित करने के लिए एक Next.js वेब एप्लिकेशन।
-
-दोनों उपप्रणालियां `~/.failproofai/` और प्रोजेक्ट की `.failproofai/` डायरेक्टरी में कॉन्फ़िगरेशन फ़ाइलें साझा करती हैं, लेकिन वे अलग-अलग प्रक्रियाओं के रूप में चलती हैं और केवल फ़ाइलसिस्टम के माध्यम से संचार करती हैं।
-
----
-
-## हुक हैंडलर
-
-### Claude Code के साथ एकीकरण
-
-जब आप `failproofai policies --install` चलाते हैं, तो यह `~/.claude/settings.json` में इस तरह की प्रविष्टियां लिखता है:
-
-```json
-{
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "failproofai --hook PreToolUse"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [ ... ]
-  }
-}
-```
-
-Claude Code फिर प्रत्येक टूल कॉल से पहले `failproofai --hook PreToolUse` को एक उपप्रक्रिया के रूप में आमंत्रित करता है, stdin पर एक JSON पेलोड पास करता है।
-
-### पेलोड प्रारूप
-
-```json
-{
-  "session_id": "abc123",
-  "transcript_path": "/home/user/.claude/projects/myproject/sessions/abc123.jsonl",
-  "cwd": "/home/user/myproject",
-  "permission_mode": "default",
-  "hook_event_name": "PreToolUse",
-  "tool_name": "Bash",
-  "tool_input": { "command": "sudo apt install nodejs" }
-}
-```
-
-`PostToolUse` इवेंट्स के लिए, पेलोड में टूल के आउटपुट के साथ `tool_result` भी शामिल है।
-
-हैंडलर 1 MB stdin सीमा लागू करता है। इस सीमा से अधिक पेलोड को छोड़ दिया जाता है और सभी पॉलिसीज़ अर्थपूर्ण रूप से अनुमति देती हैं।
-
-### प्रतिक्रिया प्रारूप
-
-**अस्वीकार करें (PreToolUse):**
-```json
-{
-  "hookSpecificOutput": {
-    "permissionDecision": "deny",
-    "permissionDecisionReason": "Blocked by failproofai: sudo command blocked"
-  }
-}
-```
-
-**अस्वीकार करें (PostToolUse):**
-```json
-{
-  "hookSpecificOutput": {
-    "additionalContext": "Blocked by failproofai because: API key detected in output"
-  }
-}
-```
-
-**निर्देशन (Stop को छोड़कर किसी भी इवेंट):**
-```json
-{
-  "hookSpecificOutput": {
-    "additionalContext": "Instruction from failproofai: Verify tests pass before committing."
-  }
-}
-```
-
-**Stop इवेंट निर्देशन:**
-- Exit code: `2`
-- कारण stderr को लिखा गया (stdout को नहीं)
-
-**अनुमति दें:**
-- Exit code: `0`
-- खाली stdout
-
-**संदेश के साथ अनुमति दें:**
-
-`allow(message)` एक पॉलिसी को Claude को सूचनात्मक संदर्भ भेजने देता है भले ही ऑपरेशन की अनुमति हो। हुक हैंडलर निम्नलिखित JSON को **stdout** में लिखता है (कॉन्फ़िगरेशन फ़ाइल में नहीं — यह हैंडलर की Claude Code को प्रतिक्रिया है, जैसे अस्वीकार और निर्देश प्रतिक्रियाएं ऊपर दी गई हैं):
-
-```json
-// हुक हैंडलर प्रक्रिया द्वारा stdout में लिखा गया
-{
-  "hookSpecificOutput": {
-    "additionalContext": "All CI checks passed on branch 'feat/my-feature'."
-  }
-}
-```
-- Exit code: `0` (ऑपरेशन की अनुमति है)
-- जब कई पॉलिसीज़ एक संदेश के साथ `allow` देती हैं, तो उनके संदेश नई पंक्तियों के साथ एक एकल `additionalContext` स्ट्रिंग में जुड़ जाते हैं
-- यदि कोई पॉलिसी संदेश प्रदान नहीं करती है, तो stdout खाली है (पहले की तरह)
-
-### प्रोसेसिंग पाइपलाइन
-
-`src/hooks/handler.ts` पूरी पाइपलाइन को लागू करता है:
-
-```text
-stdin JSON
-  → parse payload (max 1 MB)
-  → extract session metadata (session_id, cwd, tool_name, tool_input, etc.)
-  → readMergedHooksConfig(cwd)    ← merges project + local + global config
-  → register enabled builtin policies with resolved params
-  → load custom policies from customPoliciesPath (if set)
-  → register custom policies into policy registry
-  → evaluate all policies (builtins first, then custom)
-      → first deny short-circuits
-      → instruct decisions accumulate
-      → allow messages accumulate
-  → write JSON decision to stdout
-  → persist event to ~/.failproofai/hook-activity.jsonl
-  → exit
-```
-
-बिना LLM कॉल्स के सामान्य पेलोड्स के लिए पूरी प्रक्रिया 100ms से कम में चलती है।
-
----
-
-## कॉन्फ़िगरेशन लोडिंग
-
-`src/hooks/hooks-config.ts` तीन-स्कोप कॉन्फ़िगरेशन लोडिंग को लागू करता है।
-
-```text
-[1] {cwd}/.failproofai/policies-config.json        ← project  (highest priority)
-[2] {cwd}/.failproofai/policies-config.local.json  ← local
-[3] ~/.failproofai/policies-config.json             ← global   (lowest priority)
-```
-
-मर्ज तर्क:
-- `enabledPolicies` - सभी तीन फ़ाइलों में डीडुप्लिकेटेड यूनियन
-- `policyParams` - प्रति-पॉलिसी कुंजी, पहली फ़ाइल जो इसे परिभाषित करती है पूरी तरह जीतती है
-- `customPoliciesPath` - पहली फ़ाइल जो इसे परिभाषित करती है जीतती है
-- `llm` - पहली फ़ाइल जो इसे परिभाषित करती है जीतती है
-
-वेब डैशबोर्ड पढ़ने और लिखने के लिए `readHooksConfig()` (केवल वैश्विक) का उपयोग करता है, क्योंकि इसे प्रोजेक्ट cwd के साथ आमंत्रित नहीं किया जाता है।
-
----
-
-## पॉलिसी मूल्यांकन
-
-`src/hooks/policy-evaluator.ts` पॉलिसीज़ को क्रम में चलाता है।
-
-प्रत्येक पॉलिसी के लिए:
-
-1. पॉलिसी के `params` स्कीमा को देखें (यदि इसके पास है)।
-2. मर्ज किए गए कॉन्फ़िगरेशन से `policyParams[policy.name]` पढ़ें।
-3. `ctx.params` बनाने के लिए स्कीमा डिफ़ॉल्ट्स पर उपयोगकर्ता-प्रदान किए गए मानों को मर्ज करें।
-4. हल किए गए संदर्भ के साथ `policy.fn(ctx)` को कॉल करें।
-5. यदि परिणाम `deny` है, तो तुरंत रुकें और उस निर्णय को वापस करें।
-6. यदि परिणाम `instruct` है, तो संदेश को जमा करें और जारी रखें।
-7. यदि परिणाम `allow` है, तो अगली पॉलिसी पर जाएं।
-
-सभी पॉलिसीज़ चलने के बाद:
-- यदि कोई `deny` वापस किया गया था, तो अस्वीकार प्रतिक्रिया दें।
-- यदि कोई `instruct` वापसी एकत्र किए गए थे, तो सभी संदेशों को जोड़ने के साथ एक एकल निर्देश प्रतिक्रिया दें।
-- अन्यथा, अनुमति प्रतिक्रिया दें (खाली stdout, exit 0)।
-
----
-
-## अंतर्निहित पॉलिसीज़
-
-`src/hooks/builtin-policies.ts` सभी 26 अंतर्निहित पॉलिसीज़ को `BuiltinPolicyDefinition` ऑब्जेक्ट्स के रूप में परिभाषित करता है:
-
-```typescript
-interface BuiltinPolicyDefinition {
-  name: string;
-  description: string;
-  fn: (ctx: PolicyContext) => PolicyResult;
-  match: {
-    events: HookEventType[];
-    tools?: string[];
-  };
-  defaultEnabled: boolean;
-  category: string;
-  beta?: boolean;
-  params?: PolicyParamsSchema;
-}
-```
-
-जो पॉलिसीज़ `params` स्वीकार करती हैं वे प्रत्येक पैरामीटर के लिए प्रकार और डिफ़ॉल्ट्स के साथ `PolicyParamsSchema` घोषित करती हैं। पॉलिसी मूल्यांकन `fn` को कॉल करने से पहले `ctx.params` में हल किए गए मानों को इंजेक्ट करता है। पॉलिसी फ़ंक्शन्स `ctx.params` को पढ़ते हैं बिना null-गार्डिंग के क्योंकि डिफ़ॉल्ट्स हमेशा पहले लागू होते हैं।
-
-पॉलिसीज़ के अंदर पैटर्न मिलान पार्स किए गए कमांड टोकन्स (argv) का उपयोग करता है, कच्ची स्ट्रिंग मिलान नहीं। यह shell ऑपरेटर इंजेक्शन के माध्यम से बाईपास को रोकता है (उदाहरण के लिए `sudo systemctl status *` के लिए एक पैटर्न को `; rm -rf /` को जोड़कर बाईपास नहीं किया जा सकता)।
-
----
-
-## कस्टम पॉलिसीज़
-
-`src/hooks/custom-hooks-registry.ts` एक `globalThis`-समर्थित रजिस्ट्री को लागू करता है:
-
-```typescript
-const REGISTRY_KEY = "__failproofai_custom_hooks__";
-
-export const customPolicies = {
-  add(hook: CustomHook): void { ... }
-};
-
-export function getCustomHooks(): CustomHook[] { ... }
-export function clearCustomHooks(): void { ... }  // used in tests
-```
-
-`src/hooks/custom-hooks-loader.ts` उपयोगकर्ता की पॉलिसी फ़ाइल लोड करता है:
-
-1. कॉन्फ़िगरेशन से `customPoliciesPath` पढ़ें; यदि अनुपस्थित है तो छोड़ दें।
-2. निरपेक्ष पथ में हल करें; फ़ाइल मौजूदगी की जांच करें।
-3. सभी `from "failproofai"` आयातों को वास्तविक dist पथ में फिर से लिखें ताकि `customPolicies` एक ही `globalThis` रजिस्ट्री में हल हो।
-4. ESM अनुकूलता सुनिश्चित करने के लिए संक्रमणकालीन स्थानीय आयातों को पुनरावर्ती रूप से फिर से लिखें।
-5. अस्थायी `.mjs` फ़ाइलें लिखें और प्रविष्टि फ़ाइल को `import()` करें।
-6. पंजीकृत हुक्स को पुनः प्राप्त करने के लिए `getCustomHooks()` को कॉल करें।
-7. `finally` ब्लॉक में सभी अस्थायी फ़ाइलों को साफ़ करें।
-
-किसी भी त्रुटि पर (फ़ाइल नहीं मिली, सिंटैक्स त्रुटि, आयात विफलता), त्रुटि को `~/.failproofai/hook.log` में लॉग किया जाता है और लोडर एक खाली सरणी देता है। अंतर्निहित पॉलिसीज़ प्रभावित नहीं होती हैं।
-
-कस्टम पॉलिसीज़ का मूल्यांकन सभी अंतर्निहित पॉलिसीज़ के बाद किया जाता है। एक कस्टम पॉलिसी `deny` अभी भी आगे की कस्टम पॉलिसीज़ को छोटा करता है (लेकिन सभी अंतर्निहित पॉलिसीज़ पहले ही चल चुकी हैं)।
-
----
-
-## गतिविधि लॉगिंग
-
-प्रत्येक हुक इवेंट के बाद, हैंडलर `~/.failproofai/hook-activity.jsonl` में एक JSONL पंक्ति जोड़ता है:
-
-```json
-{
-  "timestamp": "2026-04-06T12:34:56.789Z",
-  "sessionId": "abc123",
-  "eventType": "PreToolUse",
-  "toolName": "Bash",
-  "policyName": "block-sudo",
-  "decision": "deny",
-  "reason": "sudo command blocked by failproofai",
-  "durationMs": 12
-}
-```
-
-प्रत्येक पॉलिसी के लिए एक पंक्ति जिसने एक गैर-अनुमति निर्णय दिया। अनुमति के निर्णय लॉग नहीं किए जाते हैं (फ़ाइल को छोटा रखने के लिए)।
-
----
-
-## डैशबोर्ड आर्किटेक्चर
-
-डैशबोर्ड एक **Next.js 16** एप्लिकेशन है जो App Router के साथ React Server Components और Server Actions का उपयोग करता है।
-
-```text
-app/
-  layout.tsx                  ← Root layout (theme, telemetry, nav)
-  projects/page.tsx           ← Server component: list all Claude projects
-  project/[name]/page.tsx     ← Server component: list sessions in a project
-  project/[name]/session/
-    [sessionId]/page.tsx      ← Server component: render session viewer
-  policies/page.tsx           ← Client component: policy management + activity log
-  actions/
-    get-hooks-config.ts       ← Read config + policy list
-    update-hooks-config.ts    ← Toggle policy on/off
-    update-policy-params.ts   ← Update policy parameters
-    get-hook-activity.ts      ← Paginate/search activity log
-    install-hooks-web.ts      ← Install/remove hooks from the browser
-  api/
-    download/[project]/[session]/route.ts   ← Export session as ZIP/JSONL
-```
-
-**डेटा प्रवाह:**
-
-- पेज कंपोनेंट्स प्रोजेक्ट/सेशन डेटा को सीधे फ़ाइलसिस्टम से पढ़ने के लिए `lib/projects.ts` और `lib/log-entries.ts` को कॉल करते हैं (पढ़ने के लिए कोई API परत नहीं)।
-- पॉलिसीज़ पेज सभी म्यूटेशन्स के लिए Server Actions का उपयोग करता है (टॉगल, पैरामीटर अपडेट, इंस्टॉल/निकालना)।
-- सेशन दर्शक Claude की JSONL ट्रांसक्रिप्ट प्रारूप को पार्स करता है और संदेशों और टूल कॉल्स की एक समयरेखा प्रस्तुत करता है।
-
-**मुख्य डिज़ाइन निर्णय:**
-
-- कोई डेटाबेस नहीं - सभी स्थायी स्थिति सादी फ़ाइलों में है (`~/.failproofai/`, `~/.claude/projects/`)।
-- म्यूटेशन्स के लिए Server Actions - CRUD ऑपरेशन्स के लिए कोई REST API आवश्यक नहीं है।
-- पढ़ने पन्नों के लिए React Server Components - तेज़ प्रारंभिक लोड, डेटा फेचिंग के लिए कोई क्लाइंट बंडल नहीं।
-- क्लाइंट कंपोनेंट्स केवल जहां इंटरैक्टिविटी आवश्यक है (पॉलिसी टॉगल, गतिविधि खोज, लॉग दर्शक)।
-
----
-
-## फ़ाइल लेआउट
-
-```text
-failproofai/
-├── bin/
-│   └── failproofai.mjs           # CLI router (hook / dashboard / install / etc.)
-├── src/hooks/
-│   ├── handler.ts                # Hook event pipeline
-│   ├── builtin-policies.ts       # 26 policy definitions
-│   ├── policy-evaluator.ts       # Policy execution engine
-│   ├── policy-registry.ts        # Policy registration and lookup
-│   ├── policy-types.ts           # TypeScript interfaces
-│   ├── hooks-config.ts           # Multi-scope config loading
-│   ├── custom-hooks-registry.ts  # globalThis-backed hook registry
-│   ├── custom-hooks-loader.ts    # ESM loader for user JS hooks
-│   ├── manager.ts                # install / remove / list operations
-│   ├── install-prompt.ts         # Interactive policy selection prompt
-│   ├── hook-logger.ts            # Logging to hook.log
-│   ├── hook-activity-store.ts    # Persist activity to hook-activity.jsonl
-│   └── llm-client.ts             # LLM API client (for AI-powered policies)
-├── app/                          # Next.js dashboard (pages + server actions)
-├── lib/                          # Shared utilities
-│   ├── projects.ts               # Enumerate Claude projects from filesystem
-│   ├── log-entries.ts            # Parse Claude transcript JSONL format
-│   ├── paths.ts                  # Resolve system paths
-│   └── ...
-├── components/                   # Shared React UI components
-├── contexts/                     # React context providers (theme, auto-refresh, telemetry)
-├── examples/                     # Example custom hook files
-└── __tests__/                    # Unit and E2E tests
-```