claudeos-core 2.4.1 → 2.4.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +17 -0
- package/README.de.md +172 -174
- package/README.es.md +161 -163
- package/README.fr.md +159 -161
- package/README.hi.md +166 -168
- package/README.ja.md +166 -168
- package/README.ko.md +139 -141
- package/README.md +55 -57
- package/README.ru.md +173 -175
- package/README.vi.md +169 -171
- package/README.zh-CN.md +168 -170
- package/package.json +1 -1
package/README.hi.md
CHANGED
|
@@ -7,58 +7,40 @@
|
|
|
7
7
|
[](LICENSE)
|
|
8
8
|
[](https://www.npmjs.com/package/claudeos-core)
|
|
9
9
|
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
एक deterministic Node.js scanner पहले आपके कोड को पढ़ता है; फिर एक 4-pass Claude पाइपलाइन पूरा सेट लिखती है — `CLAUDE.md` + auto-loaded `.claude/rules/` + standards + skills + L4 memory. 10 output भाषाएँ, 5 post-generation validators, और एक स्पष्ट path allowlist जो LLM को आपके कोड में मौजूद न होने वाली फ़ाइलें या frameworks आविष्कार करने से रोकता है।
|
|
13
|
-
|
|
14
|
-
[**12 stacks**](#supported-stacks) पर काम करता है (monorepos सहित) — एक `npx` command, कोई config नहीं, resume-safe, idempotent.
|
|
10
|
+
**एक ऐसा CLI tool जो आपके actual source code को पढ़कर `CLAUDE.md` और `.claude/rules/` खुद generate कर देता है। Node.js scanner, 4-pass Claude pipeline और 5 validators मिलकर काम करते हैं। 12 stacks और 10 भाषाएँ support हैं, और जो path code में नहीं है वो output में भी नहीं आएगा।**
|
|
15
11
|
|
|
16
12
|
```bash
|
|
17
13
|
npx claudeos-core init
|
|
18
14
|
```
|
|
19
15
|
|
|
16
|
+
[**12 stacks**](#supported-stacks) पर सीधे चलता है (monorepos भी)। एक command, कोई config नहीं, बीच में रुक जाए तो वहीं से resume होता है, और बार-बार चलाने पर भी safe है।
|
|
17
|
+
|
|
20
18
|
[🇺🇸 English](README.md) · [🇰🇷 한국어](README.ko.md) · [🇨🇳 中文](README.zh-CN.md) · [🇯🇵 日本語](README.ja.md) · [🇪🇸 Español](README.es.md) · [🇻🇳 Tiếng Việt](README.vi.md) · [🇷🇺 Русский](README.ru.md) · [🇫🇷 Français](README.fr.md) · [🇩🇪 Deutsch](README.de.md)
|
|
21
19
|
|
|
22
20
|
---
|
|
23
21
|
|
|
24
22
|
## यह क्या है?
|
|
25
23
|
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
- आपकी टीम **MyBatis** का उपयोग करती है, लेकिन Claude JPA repositories उत्पन्न करता है।
|
|
29
|
-
- आपका response wrapper `ApiResponse.ok()` है, लेकिन Claude `ResponseEntity.success()` लिखता है।
|
|
30
|
-
- आपके packages layer-first (`controller/order/`) हैं, लेकिन Claude domain-first (`order/controller/`) बनाता है।
|
|
31
|
-
- आपकी errors centralized middleware से जाती हैं, लेकिन Claude हर endpoint में `try/catch` बिखेर देता है।
|
|
24
|
+
Claude Code हर नए session पर framework के generic defaults पर वापस चला जाता है। आपकी team **MyBatis** use करती है, फिर भी Claude JPA का code लिख देता है। आपका response wrapper `ApiResponse.ok()` है, फिर भी Claude `ResponseEntity.success()` लिखता है। Packages आपने layer-first design किए हैं, मगर Claude domain-first structure बना देता है। हर repo के लिए `.claude/rules/` खुद से लिखकर रखना इसका एक हल है, लेकिन जैसे ही code evolve होता है आपके rules drift करने लगते हैं।
|
|
32
25
|
|
|
33
|
-
|
|
26
|
+
**ClaudeOS-Core यही काम deterministically करता है, सीधे आपके actual source code से।** पहले एक Node.js scanner project को पढ़ता है, यानी stack, ORM, package layout और file paths सब निकाल लेता है। उसके बाद 4-pass Claude pipeline पूरा set generate करती है। `CLAUDE.md`, auto-load होने वाले `.claude/rules/`, standards, skills — ये सब एक explicit path allowlist के अंदर ही बनते हैं, और LLM इस दायरे से बाहर नहीं जा सकता। आखिर में 5 validators output को ship होने से पहले verify कर लेते हैं।
|
|
34
27
|
|
|
35
|
-
|
|
28
|
+
नतीजा यह है कि same input के लिए हमेशा byte-identical output मिलता है, चाहे 10 भाषाओं में से कोई भी चुनी जाए, और कभी invented path नहीं आएगा। (विस्तार से नीचे [क्या इसे अलग बनाता है](#क्या-इसे-अलग-बनाता-है) में।)
|
|
36
29
|
|
|
37
|
-
|
|
38
|
-
- **`.claude/rules/`** — श्रेणी के अनुसार auto-loaded rules (`00.core` / `10.backend` / `20.frontend` / `30.security-db` / `40.infra` / `60.memory` / `70.domains` / `80.verification`)
|
|
39
|
-
- **`claudeos-core/standard/`** — reference docs (हर rule के पीछे का "क्यों")
|
|
40
|
-
- **`claudeos-core/skills/`** — पुनः-प्रयोग योग्य patterns (CRUD scaffolding, page templates)
|
|
41
|
-
- **`claudeos-core/memory/`** — decision log + failure patterns जो प्रोजेक्ट के साथ बढ़ते हैं
|
|
42
|
-
|
|
43
|
-
क्योंकि scanner Claude को एक स्पष्ट path allowlist देता है, LLM **आपके कोड में मौजूद न होने वाली फ़ाइलें या frameworks आविष्कार नहीं कर सकता**। पाँच post-generation validators (`claude-md-validator`, `content-validator`, `pass-json-validator`, `plan-validator`, `sync-checker`) ship से पहले output को सत्यापित करते हैं — language-invariant, इसलिए वही rules लागू होते हैं चाहे आप English, Korean, या अन्य 8 भाषाओं में से किसी में भी उत्पन्न करें।
|
|
44
|
-
|
|
45
|
-
```
|
|
46
|
-
पहले: आप → Claude Code → "generally good" कोड → हर बार मैन्युअल फ़िक्सिंग
|
|
47
|
-
बाद में: आप → Claude Code → आपके प्रोजेक्ट से मेल खाता कोड → सीधे ship
|
|
48
|
-
```
|
|
30
|
+
लंबे चलने वाले projects के लिए एक अलग [Memory Layer](#memory-layer-वैकल्पिक-दीर्घकालिक-प्रोजेक्ट्स-के-लिए) भी seed होता है।
|
|
49
31
|
|
|
50
32
|
---
|
|
51
33
|
|
|
52
|
-
##
|
|
34
|
+
## वास्तविक प्रोजेक्ट पर देखें
|
|
53
35
|
|
|
54
|
-
[`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) पर
|
|
36
|
+
[`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) पर इसे चलाकर देखा गया। Java 11, Spring Boot 2.6, MyBatis, SQLite, कुल 187 source files. Output: **75 generated files**, total time **53 मिनट**, और सभी validators ✅।
|
|
55
37
|
|
|
56
38
|
<p align="center">
|
|
57
39
|
<img src="docs/assets/spring-boot-realworld-demo.gif" alt="ClaudeOS-Core init running on spring-boot-realworld-example-app — stack detection, 4-pass pipeline, validators, completion summary" width="769">
|
|
58
40
|
</p>
|
|
59
41
|
|
|
60
42
|
<details>
|
|
61
|
-
<summary><strong
|
|
43
|
+
<summary><strong>Terminal output (text version, search और copy के लिए)</strong></summary>
|
|
62
44
|
|
|
63
45
|
```text
|
|
64
46
|
╔════════════════════════════════════════════════════╗
|
|
@@ -93,18 +75,18 @@ npx claudeos-core init
|
|
|
93
75
|
[██████████░░░░░░░░░░] 50% (2/4)
|
|
94
76
|
|
|
95
77
|
[6] Pass 3 — Generating all files...
|
|
96
|
-
|
|
78
|
+
Pass 3 split mode (3a → 3b → 3c → 3d-aux)
|
|
97
79
|
✅ 3a complete (2m 57s) — pass3a-facts.md (187-path allowlist)
|
|
98
80
|
✅ 3b complete (18m 49s) — CLAUDE.md + 19 standards + 20 rules
|
|
99
81
|
✅ 3c complete (12m 35s) — 13 skills + 9 guides
|
|
100
82
|
✅ 3d-aux complete (3m 18s) — database/ + mcp-guide/
|
|
101
|
-
|
|
83
|
+
Pass 3 split complete: 4/4 stages successful
|
|
102
84
|
[███████████████░░░░░] 75% (3/4)
|
|
103
85
|
|
|
104
86
|
[7] Pass 4 — Memory scaffolding...
|
|
105
|
-
|
|
87
|
+
Pass 4 staged-rules: 6 rule files moved to .claude/rules/
|
|
106
88
|
✅ Pass 4 complete (5m)
|
|
107
|
-
|
|
89
|
+
Gap-fill: all 12 expected files already present
|
|
108
90
|
[████████████████████] 100% (4/4)
|
|
109
91
|
|
|
110
92
|
╔═══════════════════════════════════════╗
|
|
@@ -133,7 +115,7 @@ npx claudeos-core init
|
|
|
133
115
|
</details>
|
|
134
116
|
|
|
135
117
|
<details>
|
|
136
|
-
<summary><strong
|
|
118
|
+
<summary><strong>असली <code>CLAUDE.md</code> में आखिर क्या लिखा जाता है (वास्तविक excerpt — Section 1 + 2)</strong></summary>
|
|
137
119
|
|
|
138
120
|
```markdown
|
|
139
121
|
# CLAUDE.md — spring-boot-realworld-example-app
|
|
@@ -142,7 +124,7 @@ npx claudeos-core init
|
|
|
142
124
|
> Java 11 + Spring Boot 2.6, exposing both REST and GraphQL endpoints
|
|
143
125
|
> over a hexagonal MyBatis persistence layer.
|
|
144
126
|
|
|
145
|
-
|
|
127
|
+
#### 1. Role Definition
|
|
146
128
|
|
|
147
129
|
As the senior developer for this repository, you are responsible for
|
|
148
130
|
writing, modifying, and reviewing code. Responses must be written in English.
|
|
@@ -150,7 +132,7 @@ A Java Spring Boot REST + GraphQL API server organized around a hexagonal
|
|
|
150
132
|
(ports & adapters) architecture, with a CQRS-lite read/write split inside
|
|
151
133
|
an XML-driven MyBatis persistence layer and JWT-based authentication.
|
|
152
134
|
|
|
153
|
-
|
|
135
|
+
#### 2. Project Overview
|
|
154
136
|
|
|
155
137
|
| Item | Value |
|
|
156
138
|
|---|---|
|
|
@@ -166,12 +148,12 @@ an XML-driven MyBatis persistence layer and JWT-based authentication.
|
|
|
166
148
|
| Test Stack | JUnit Jupiter 5, Mockito, AssertJ, rest-assured, spring-mock-mvc |
|
|
167
149
|
```
|
|
168
150
|
|
|
169
|
-
ऊपर
|
|
151
|
+
ऊपर table में जो भी value है — exact dependency coordinates, `dev.db` filename, `V1__create_tables.sql` migration नाम, "no JPA" तक — वो सब Claude के file लिखने से पहले scanner ने `build.gradle`, `application.properties` और source tree से सीधे निकाला है। एक भी value guess नहीं की गई।
|
|
170
152
|
|
|
171
153
|
</details>
|
|
172
154
|
|
|
173
155
|
<details>
|
|
174
|
-
<summary><strong
|
|
156
|
+
<summary><strong>एक असली auto-loaded rule (<code>.claude/rules/10.backend/01.controller-rules.md</code>)</strong></summary>
|
|
175
157
|
|
|
176
158
|
````markdown
|
|
177
159
|
---
|
|
@@ -179,9 +161,9 @@ paths:
|
|
|
179
161
|
- "**/*"
|
|
180
162
|
---
|
|
181
163
|
|
|
182
|
-
|
|
164
|
+
#### Controller Rules
|
|
183
165
|
|
|
184
|
-
|
|
166
|
+
##### REST (`io.spring.api.*`)
|
|
185
167
|
|
|
186
168
|
- Controllers are the SOLE response wrapper for HTTP — no aggregator/facade above them.
|
|
187
169
|
Return `ResponseEntity<?>` or a body Spring serializes via `JacksonCustomizations`.
|
|
@@ -194,13 +176,13 @@ paths:
|
|
|
194
176
|
- Let exceptions propagate to `io.spring.api.exception.CustomizeExceptionHandler`
|
|
195
177
|
(`@ControllerAdvice`). Do NOT `try/catch` business exceptions inside the controller.
|
|
196
178
|
|
|
197
|
-
|
|
179
|
+
##### GraphQL (`io.spring.graphql.*`)
|
|
198
180
|
|
|
199
181
|
- DGS components (`@DgsComponent`) are the sole GraphQL response wrappers.
|
|
200
182
|
Use `@DgsQuery` / `@DgsData` / `@DgsMutation`.
|
|
201
183
|
- Resolve the current user via `io.spring.graphql.SecurityUtil.getCurrentUser()`.
|
|
202
184
|
|
|
203
|
-
|
|
185
|
+
##### Examples
|
|
204
186
|
|
|
205
187
|
✅ Correct:
|
|
206
188
|
```java
|
|
@@ -228,15 +210,15 @@ public ResponseEntity<?> create(@RequestBody NewArticleParam p) {
|
|
|
228
210
|
```
|
|
229
211
|
````
|
|
230
212
|
|
|
231
|
-
`paths: ["**/*"]` glob का
|
|
213
|
+
`paths: ["**/*"]` glob का मतलब है कि project में जब भी कोई file edit हो, Claude Code इस rule को अपने आप load कर लेता है। Rule में जितने भी class names, package paths और exception handlers हैं, वो सब scanned source से सीधे आए हैं। यानी project का असली `CustomizeExceptionHandler` और `JacksonCustomizations` जैसा है, वैसा ही यहाँ झलकता है।
|
|
232
214
|
|
|
233
215
|
</details>
|
|
234
216
|
|
|
235
217
|
<details>
|
|
236
|
-
<summary><strong
|
|
218
|
+
<summary><strong>Auto-generated <code>decision-log.md</code> seed (वास्तविक excerpt)</strong></summary>
|
|
237
219
|
|
|
238
220
|
```markdown
|
|
239
|
-
|
|
221
|
+
#### 2026-04-26 — Hexagonal ports & adapters with MyBatis-only persistence
|
|
240
222
|
|
|
241
223
|
- **Context:** `io.spring.core.*` exposes `*Repository` ports (e.g.,
|
|
242
224
|
`io.spring.core.article.ArticleRepository`) implemented by
|
|
@@ -255,260 +237,276 @@ public ResponseEntity<?> create(@RequestBody NewArticleParam p) {
|
|
|
255
237
|
split the persistence model.
|
|
256
238
|
```
|
|
257
239
|
|
|
258
|
-
Pass 4 `pass2-merged.json` से
|
|
240
|
+
Pass 4 `pass2-merged.json` से निकले architectural decisions को `decision-log.md` में पहले से भर देता है। इसका फायदा यह है कि अगले sessions में codebase जैसा दिख रहा है उसका *क्या* ही नहीं, *क्यों* भी याद रहता है। हर option ("JPA/Hibernate", "MyBatis-Plus") और हर consequence असली `build.gradle` dependency block पर ही टिका हुआ है।
|
|
259
241
|
|
|
260
242
|
</details>
|
|
261
243
|
|
|
262
244
|
---
|
|
263
245
|
|
|
264
|
-
##
|
|
246
|
+
## परीक्षण किया गया
|
|
265
247
|
|
|
266
|
-
|
|
248
|
+
ClaudeOS-Core असली OSS projects पर लिए गए reference benchmarks के साथ ship होता है। अगर आपने इसे किसी public repo पर चलाया है, तो [issue खोल दीजिए](https://github.com/claudeos-core/claudeos-core/issues), हम इसे table में जोड़ देंगे।
|
|
249
|
+
|
|
250
|
+
| Project | Stack | Scanned → Generated | Status |
|
|
251
|
+
|---|---|---|---|
|
|
252
|
+
| [`spring-boot-realworld-example-app`](https://github.com/gothinkster/spring-boot-realworld-example-app) | Java 11 · Spring Boot 2.6 · MyBatis · SQLite | 187 → 75 files | ✅ सभी 5 validators pass |
|
|
253
|
+
|
|
254
|
+
---
|
|
255
|
+
|
|
256
|
+
## त्वरित शुरुआत
|
|
257
|
+
|
|
258
|
+
**Prerequisites:** Node.js 18+, और [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed व authenticated।
|
|
267
259
|
|
|
268
260
|
```bash
|
|
269
|
-
# 1. अपने
|
|
261
|
+
# 1. अपने project root पर जाएँ
|
|
270
262
|
cd my-spring-boot-project
|
|
271
263
|
|
|
272
|
-
# 2. init चलाएँ (यह
|
|
264
|
+
# 2. init चलाएँ (यह code analyze करता है और Claude से rules लिखवाता है)
|
|
273
265
|
npx claudeos-core init
|
|
274
266
|
|
|
275
|
-
# 3. हो गया। Claude Code
|
|
267
|
+
# 3. हो गया। Claude Code खोलिए और काम शुरू कीजिए — rules पहले से loaded हैं।
|
|
276
268
|
```
|
|
277
269
|
|
|
278
|
-
`init`
|
|
270
|
+
`init` खत्म होने के बाद structure कुछ ऐसा दिखेगा।
|
|
279
271
|
|
|
280
272
|
```
|
|
281
273
|
your-project/
|
|
282
274
|
├── .claude/
|
|
283
|
-
│ └── rules/ ← Claude Code
|
|
275
|
+
│ └── rules/ ← Claude Code इन्हें auto-load करता है
|
|
284
276
|
│ ├── 00.core/ (सामान्य rules — naming, architecture)
|
|
285
|
-
│ ├── 10.backend/ (backend stack rules,
|
|
286
|
-
│ ├── 20.frontend/ (frontend stack rules,
|
|
287
|
-
│ ├── 30.security-db/ (security
|
|
277
|
+
│ ├── 10.backend/ (backend stack rules, अगर हैं तो)
|
|
278
|
+
│ ├── 20.frontend/ (frontend stack rules, अगर हैं तो)
|
|
279
|
+
│ ├── 30.security-db/ (security और DB conventions)
|
|
288
280
|
│ ├── 40.infra/ (env, logging, CI/CD)
|
|
289
|
-
│ ├── 50.sync/ (doc-sync
|
|
290
|
-
│ ├── 60.memory/ (memory rules — Pass 4, rules
|
|
281
|
+
│ ├── 50.sync/ (doc-sync reminders — सिर्फ rules में)
|
|
282
|
+
│ ├── 60.memory/ (memory rules — Pass 4, सिर्फ rules में)
|
|
291
283
|
│ ├── 70.domains/{type}/ (per-domain rules, type = backend|frontend)
|
|
292
|
-
│ └── 80.verification/ (testing strategy
|
|
284
|
+
│ └── 80.verification/ (testing strategy और build verification reminders)
|
|
293
285
|
├── claudeos-core/
|
|
294
|
-
│ ├── standard/ ← Reference docs (
|
|
286
|
+
│ ├── standard/ ← Reference docs (वही category structure)
|
|
295
287
|
│ │ ├── 00.core/ (project overview, architecture, naming)
|
|
296
|
-
│ │ ├── 10.backend/ (backend reference — backend stack
|
|
297
|
-
│ │ ├── 20.frontend/ (frontend reference — frontend stack
|
|
298
|
-
│ │ ├── 30.security-db/ (security
|
|
288
|
+
│ │ ├── 10.backend/ (backend reference — backend stack हो तो)
|
|
289
|
+
│ │ ├── 20.frontend/ (frontend reference — frontend stack हो तो)
|
|
290
|
+
│ │ ├── 30.security-db/ (security और DB reference)
|
|
299
291
|
│ │ ├── 40.infra/ (env / logging / CI-CD reference)
|
|
300
292
|
│ │ ├── 70.domains/{type}/ (per-domain reference)
|
|
301
|
-
│ │ ├── 80.verification/ (build / startup / testing reference — standard
|
|
302
|
-
│ │ └── 90.optional/ (stack-specific extras — standard
|
|
303
|
-
│ ├── skills/ (
|
|
304
|
-
│ ├── guide/ (
|
|
305
|
-
│ ├── database/ (schema overview, migration
|
|
306
|
-
│ ├── mcp-guide/ (MCP integration
|
|
293
|
+
│ │ ├── 80.verification/ (build / startup / testing reference — सिर्फ standard में)
|
|
294
|
+
│ │ └── 90.optional/ (stack-specific extras — सिर्फ standard में)
|
|
295
|
+
│ ├── skills/ (reusable patterns जिन्हें Claude apply कर सकता है)
|
|
296
|
+
│ ├── guide/ (आम tasks के how-to guides)
|
|
297
|
+
│ ├── database/ (schema overview, migration guide)
|
|
298
|
+
│ ├── mcp-guide/ (MCP integration notes)
|
|
307
299
|
│ └── memory/ (decision log, failure patterns, compaction)
|
|
308
|
-
└── CLAUDE.md (
|
|
300
|
+
└── CLAUDE.md (Claude सबसे पहले इसी index को पढ़ता है)
|
|
309
301
|
```
|
|
310
302
|
|
|
311
|
-
`rules/` और `standard/`
|
|
303
|
+
जिन categories का number prefix `rules/` और `standard/` दोनों में same है, वो एक ही area की हैं (जैसे `10.backend` rules ↔ `10.backend` standards)। सिर्फ rules में रहने वाली categories हैं `50.sync` (doc sync reminders) और `60.memory` (Pass 4 memory)। सिर्फ standard में रहने वाली एक है `90.optional` (बिना enforcement के stack-specific extras)। बाकी सारे prefixes (`00`, `10`, `20`, `30`, `40`, `70`, `80`) दोनों जगह मौजूद हैं। अब Claude Code आपके project को जानता है।
|
|
312
304
|
|
|
313
305
|
---
|
|
314
306
|
|
|
315
307
|
## यह किसके लिए है?
|
|
316
308
|
|
|
317
|
-
| आप हैं... | यह pain
|
|
309
|
+
| आप कौन हैं... | यह जो pain हटाता है |
|
|
318
310
|
|---|---|
|
|
319
|
-
| **Claude Code
|
|
320
|
-
| **
|
|
321
|
-
|
|
|
322
|
-
|
|
|
323
|
-
|
|
|
324
|
-
| **
|
|
325
|
-
| **OSS में
|
|
311
|
+
| **Solo dev जो Claude Code से नया project शुरू कर रहा है** | "हर session में Claude को conventions फिर से सिखाओ" — यह झंझट खत्म। `CLAUDE.md` और 8-category `.claude/rules/` एक ही pass में बन जाते हैं। |
|
|
312
|
+
| **Team lead जो कई repos में shared standards maintain करता है** | जब लोग packages rename करते हैं, ORMs बदलते हैं, या response wrappers switch करते हैं, तब `.claude/rules/` drift करने लगते हैं। ClaudeOS-Core इन्हें deterministically फिर से sync कर देता है। Same input = byte-identical output, कोई diff noise नहीं। |
|
|
313
|
+
| **पहले से Claude Code use कर रहे हैं लेकिन generated code ठीक करते-करते थक चुके हैं** | गलत response wrapper, गलत package layout, MyBatis project में JPA code, centralized middleware के बावजूद बिखरा हुआ `try/catch` — यह सब scanner आपके असली conventions निकालकर रोकता है, और हर Claude pass एक explicit path allowlist पर ही चलता है। |
|
|
314
|
+
| **नए repo पर onboarding कर रहे हैं** (existing project, team join कर रहे हैं) | Repo पर `init` चलाइए, एक living architecture map मिल जाता है — CLAUDE.md में stack table, ✅/❌ examples के साथ per-layer rules, और बड़े decisions के पीछे "why" से seed किया हुआ decision log (JPA vs MyBatis, REST vs GraphQL, वगैरह)। 5 files पढ़ना 5,000 source files पढ़ने से कहीं तेज़ है। |
|
|
315
|
+
| **हिन्दी / कोरियाई / जापानी / चीनी समेत 7 अन्य भाषाओं में काम कर रहे हैं** | अधिकांश Claude Code rule generators सिर्फ English में लिखते हैं। ClaudeOS-Core पूरा set **10 भाषाओं** (`en/ko/ja/zh-CN/es/vi/hi/ru/fr/de`) में लिखता है, और structural validation **byte-identical** रहता है — output language कोई भी हो, `claude-md-validator` का verdict same रहता है। |
|
|
316
|
+
| **Monorepo पर काम कर रहे हैं** (Turborepo, pnpm/yarn workspaces, Lerna) | एक ही run में backend और frontend domains अलग-अलग prompts से analyze होते हैं। `apps/*/` और `packages/*/` खुद-ब-खुद walk हो जाते हैं, और per-stack rules `70.domains/{type}/` के नीचे emit होते हैं। |
|
|
317
|
+
| **OSS में contribute कर रहे हैं या experiment कर रहे हैं** | Output gitignore-friendly है। `claudeos-core/` आपकी local working dir है, और ship सिर्फ `CLAUDE.md` + `.claude/` को करना है। बीच में रुक जाए तो resume-safe, और re-runs पर idempotent — आपके manual edits बिना `--force` के बच जाते हैं। |
|
|
326
318
|
|
|
327
|
-
|
|
319
|
+
**यह आपके लिए सही नहीं है अगर:** आपको एक one-size-fits-all preset bundle चाहिए जो scan step के बिना day one से काम करे (कौन सा tool कहाँ fit होता है, यह [docs/hi/comparison.md](docs/hi/comparison.md) में है), या आपका project अभी [supported stacks](#supported-stacks) में से किसी में नहीं आता, या फिर आपको सिर्फ एक `CLAUDE.md` चाहिए। उस case में built-in `claude /init` ही काफी है, अलग tool install करने की जरूरत नहीं।
|
|
328
320
|
|
|
329
321
|
---
|
|
330
322
|
|
|
331
323
|
## यह कैसे काम करता है?
|
|
332
324
|
|
|
333
|
-
ClaudeOS-Core
|
|
325
|
+
ClaudeOS-Core typical Claude Code workflow को उल्टा करके चलाता है।
|
|
334
326
|
|
|
335
327
|
```
|
|
336
|
-
सामान्य:
|
|
337
|
-
यह:
|
|
328
|
+
सामान्य: आप project describe करते हैं → Claude आपके stack का अंदाज़ा लगाता है → Claude docs लिखता है
|
|
329
|
+
यह: Code आपके stack को पढ़ता है → Code confirmed facts Claude को देता है → Claude उन्हीं facts से docs लिखता है
|
|
338
330
|
```
|
|
339
331
|
|
|
340
|
-
|
|
332
|
+
Pipeline **तीन stages** में चलती है, और LLM call के दोनों तरफ code रहता है।
|
|
341
333
|
|
|
342
|
-
**1. Step A — Scanner (deterministic, कोई LLM नहीं)।** एक Node.js scanner
|
|
334
|
+
**1. Step A — Scanner (deterministic, कोई LLM नहीं)।** एक Node.js scanner project root को walk करता है, `package.json` / `build.gradle` / `pom.xml` / `pyproject.toml` पढ़ता है, `.env*` files parse करता है (`PASSWORD/SECRET/TOKEN/JWT_SECRET/...` जैसी sensitive variables को redact करते हुए), architecture pattern classify करता है (Java के 5 patterns A/B/C/D/E, Kotlin CQRS / multi-module, Next.js App vs Pages Router, FSD, components-pattern), domains discover करता है, और मौजूदा हर source file path का explicit allowlist बनाता है। इसका output है `project-analysis.json`, जो आगे की हर चीज़ के लिए single source of truth बन जाता है।
|
|
343
335
|
|
|
344
|
-
**2. Step B — 4-Pass Claude
|
|
345
|
-
- **Pass 1**
|
|
346
|
-
- **Pass 2**
|
|
347
|
-
- **Pass 3** `CLAUDE.md
|
|
348
|
-
- **Pass 4** L4 memory layer (`decision-log.md`, `failure-patterns.md`, `compaction.md`, `auto-rule-update.md`)
|
|
336
|
+
**2. Step B — 4-Pass Claude pipeline (Step A के facts के दायरे में)।**
|
|
337
|
+
- **Pass 1** हर domain group के representative files पढ़ता है और प्रति domain करीब 50–100 conventions निकालता है — response wrappers, logging libraries, error handling, naming conventions, test patterns वगैरह। यह domain group पर एक बार चलता है (`max 4 domains, 40 files per group`), इसलिए context कभी overflow नहीं होता।
|
|
338
|
+
- **Pass 2** सारे per-domain analysis को project-wide picture में merge कर देता है, और जहाँ disagreement हो वहाँ dominant convention चुन लेता है।
|
|
339
|
+
- **Pass 3** `CLAUDE.md`, `.claude/rules/`, `claudeos-core/standard/`, skills और guides लिखता है। यह stages में split होता है (`3a` facts → `3b-core/3b-N` rules+standards → `3c-core/3c-N` skills+guides → `3d-aux` database+mcp-guide), जिससे `pass2-merged.json` बड़ा होने पर भी हर stage का prompt LLM के context window में आ जाता है। 16 या उससे ज्यादा domains वाले projects के लिए 3b/3c को ≤15-domain batches में sub-divide कर दिया जाता है।
|
|
340
|
+
- **Pass 4** L4 memory layer को seed करता है (`decision-log.md`, `failure-patterns.md`, `compaction.md`, `auto-rule-update.md`) और कुछ universal scaffold rules जोड़ता है। Pass 4 को **`CLAUDE.md` modify करने की इजाज़त नहीं है** — Pass 3 का Section 8 ही authoritative है।
|
|
349
341
|
|
|
350
|
-
**3. Step C — Verification (deterministic, कोई LLM नहीं)।** पाँच validators output
|
|
351
|
-
- `claude-md-validator` — `CLAUDE.md` पर 25
|
|
352
|
-
- `content-validator` — 10 content checks
|
|
353
|
-
- `pass-json-validator` — Pass 1/2/3/4 JSON well-formedness
|
|
342
|
+
**3. Step C — Verification (deterministic, कोई LLM नहीं)।** पाँच validators output check करते हैं:
|
|
343
|
+
- `claude-md-validator` — `CLAUDE.md` पर 25 structural checks (8 sections, H3/H4 counts, memory file uniqueness, T1 canonical heading invariant)। यह language-invariant है, यानी `--lang` कोई भी हो, verdict same रहता है।
|
|
344
|
+
- `content-validator` — 10 content checks, जिनमें path-claim verification (`STALE_PATH` invented `src/...` references पकड़ता है) और MANIFEST drift detection शामिल हैं।
|
|
345
|
+
- `pass-json-validator` — Pass 1/2/3/4 की JSON well-formedness और stack-aware section count check।
|
|
354
346
|
- `plan-validator` — plan ↔ disk consistency (legacy, v2.1.0 के बाद से ज़्यादातर no-op)।
|
|
355
|
-
- `sync-checker` — 7 tracked dirs
|
|
347
|
+
- `sync-checker` — 7 tracked dirs पर disk ↔ `sync-map.json` registration consistency।
|
|
356
348
|
|
|
357
|
-
तीन severity tiers (`fail` / `warn` / `advisory`)
|
|
349
|
+
तीन severity tiers (`fail` / `warn` / `advisory`) रखे गए हैं, ताकि जिन LLM hallucinations को user खुद ठीक कर सकता है, उनकी वजह से CI deadlock न हो जाए।
|
|
358
350
|
|
|
359
|
-
|
|
351
|
+
पूरी चीज़ एक invariant पर टिकी है: **Claude वही paths cite कर सकता है जो आपके code में असल में मौजूद हैं**, क्योंकि Step A उसे एक finite allowlist देता है। फिर भी अगर LLM कुछ invent करने की कोशिश करे (कुछ खास seeds पर rare है, मगर होता है), तो Step C docs ship होने से पहले उसे पकड़ लेता है।
|
|
360
352
|
|
|
361
|
-
|
|
353
|
+
हर pass के internals, marker-based resume, Claude Code के `.claude/` sensitive-path block का staged-rules workaround और stack detection की अंदरूनी logic के लिए [docs/hi/architecture.md](docs/hi/architecture.md) देखें।
|
|
362
354
|
|
|
363
355
|
---
|
|
364
356
|
|
|
365
357
|
## Supported Stacks
|
|
366
358
|
|
|
367
|
-
12 stacks,
|
|
359
|
+
12 stacks, project files से auto-detected।
|
|
368
360
|
|
|
369
361
|
**Backend:** Java/Spring Boot · Kotlin/Spring Boot · Node/Express · Node/Fastify · Node/NestJS · Python/Django · Python/FastAPI · Python/Flask
|
|
370
362
|
|
|
371
363
|
**Frontend:** Node/Next.js · Node/Vite · Angular · Vue/Nuxt
|
|
372
364
|
|
|
373
|
-
|
|
365
|
+
Multi-stack projects (जैसे Spring Boot backend + Next.js frontend) भी out of the box चलते हैं।
|
|
374
366
|
|
|
375
|
-
|
|
367
|
+
Detection rules और हर scanner क्या निकालता है, यह [docs/hi/stacks.md](docs/hi/stacks.md) में है।
|
|
376
368
|
|
|
377
369
|
---
|
|
378
370
|
|
|
379
|
-
## दैनिक
|
|
371
|
+
## दैनिक वर्कफ़्लो
|
|
380
372
|
|
|
381
|
-
तीन commands ~95%
|
|
373
|
+
ये तीन commands ~95% use cases cover कर लेते हैं।
|
|
382
374
|
|
|
383
375
|
```bash
|
|
384
|
-
#
|
|
376
|
+
# Project पर पहली बार
|
|
385
377
|
npx claudeos-core init
|
|
386
378
|
|
|
387
|
-
#
|
|
379
|
+
# जब standards या rules manually edit किए हों
|
|
388
380
|
npx claudeos-core lint
|
|
389
381
|
|
|
390
|
-
#
|
|
382
|
+
# Health check (commit से पहले या CI में)
|
|
391
383
|
npx claudeos-core health
|
|
392
384
|
```
|
|
393
385
|
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
```bash
|
|
397
|
-
# failure-patterns लॉग का compaction (समय-समय पर चलाएँ)
|
|
398
|
-
npx claudeos-core memory compact
|
|
399
|
-
|
|
400
|
-
# बार-बार होने वाले failure patterns को proposed rules में बढ़ाएँ
|
|
401
|
-
npx claudeos-core memory propose-rules
|
|
402
|
-
```
|
|
403
|
-
|
|
404
|
-
प्रत्येक command के पूर्ण options के लिए, [docs/hi/commands.md](docs/hi/commands.md) देखें।
|
|
386
|
+
हर command के पूरे options [docs/hi/commands.md](docs/hi/commands.md) में हैं। Memory layer commands (`memory compact`, `memory propose-rules`) नीचे [Memory Layer](#memory-layer-वैकल्पिक-दीर्घकालिक-प्रोजेक्ट्स-के-लिए) section में documented हैं।
|
|
405
387
|
|
|
406
388
|
---
|
|
407
389
|
|
|
408
|
-
##
|
|
390
|
+
## क्या इसे अलग बनाता है
|
|
409
391
|
|
|
410
|
-
|
|
392
|
+
ज़्यादातर Claude Code documentation tools description से generate करते हैं — आप tool को बताते हैं, tool Claude को बताता है। ClaudeOS-Core इसके बजाय आपके actual source code से generate करता है। Tool खुद code पढ़ता है, फिर Claude को बताता है कि क्या confirmed है, और Claude सिर्फ उतना ही लिखता है।
|
|
411
393
|
|
|
412
|
-
तीन ठोस
|
|
394
|
+
इसके तीन ठोस नतीजे हैं।
|
|
413
395
|
|
|
414
|
-
1. **Deterministic stack detection.**
|
|
415
|
-
2. **No invented paths.** Pass 3 prompt हर
|
|
416
|
-
3. **Multi-stack aware.**
|
|
396
|
+
1. **Deterministic stack detection.** Same project + same code = same output। "इस बार Claude थोड़ा अलग roll हो गया" वाली बात नहीं होती।
|
|
397
|
+
2. **No invented paths.** Pass 3 prompt में हर allowed source path explicitly listed होता है, इसलिए Claude ऐसे paths cite ही नहीं कर सकता जो मौजूद नहीं हैं।
|
|
398
|
+
3. **Multi-stack aware.** एक ही run में backend और frontend domains अलग-अलग analysis prompts use करते हैं।
|
|
417
399
|
|
|
418
|
-
|
|
400
|
+
दूसरे tools के साथ side-by-side scope comparison के लिए [docs/hi/comparison.md](docs/hi/comparison.md) देखें। यह तुलना **हर tool क्या करता है** के बारे में है, **कौन सा बेहतर है** के बारे में नहीं — असल में ज़्यादातर एक-दूसरे के complementary हैं।
|
|
419
401
|
|
|
420
402
|
---
|
|
421
403
|
|
|
422
|
-
##
|
|
404
|
+
## सत्यापन (जनरेशन के बाद)
|
|
423
405
|
|
|
424
|
-
Claude
|
|
406
|
+
Claude docs लिख चुकने के बाद उन्हें code verify करता है। पाँच अलग-अलग validators।
|
|
425
407
|
|
|
426
|
-
| Validator |
|
|
408
|
+
| Validator | क्या check करता है | किसके through चलता है |
|
|
427
409
|
|---|---|---|
|
|
428
|
-
| `claude-md-validator` | CLAUDE.md
|
|
429
|
-
| `content-validator` | Path
|
|
430
|
-
| `pass-json-validator` | Pass 1 / 2 / 3 / 4
|
|
431
|
-
| `plan-validator` |
|
|
432
|
-
| `sync-checker` | Disk
|
|
410
|
+
| `claude-md-validator` | CLAUDE.md structural invariants (8 sections, language-invariant) | `claudeos-core lint` |
|
|
411
|
+
| `content-validator` | Path claims सच में मौजूद हैं या नहीं; manifest consistency | `health` (advisory) |
|
|
412
|
+
| `pass-json-validator` | Pass 1 / 2 / 3 / 4 outputs well-formed JSON हैं या नहीं | `health` (warn) |
|
|
413
|
+
| `plan-validator` | Saved plan disk से match करता है या नहीं | `health` (fail-on-error) |
|
|
414
|
+
| `sync-checker` | Disk files `sync-map.json` registrations से match करते हैं (orphaned/unregistered detection) | `health` (fail-on-error) |
|
|
433
415
|
|
|
434
|
-
`health-checker`
|
|
416
|
+
`health-checker` इन चारों runtime validators को three-tier severity (fail / warn / advisory) के साथ orchestrate करता है और CI के लिए सही exit code लौटाता है। `claude-md-validator` अलग से `lint` command से चलता है, क्योंकि structural drift सिर्फ soft warning नहीं, re-init का signal है। जब मन हो, चला लीजिए।
|
|
435
417
|
|
|
436
418
|
```bash
|
|
437
419
|
npx claudeos-core health
|
|
438
420
|
```
|
|
439
421
|
|
|
440
|
-
|
|
422
|
+
हर validator के individual checks [docs/hi/verification.md](docs/hi/verification.md) में detail से दिए हैं।
|
|
441
423
|
|
|
442
424
|
---
|
|
443
425
|
|
|
444
|
-
## Memory Layer (वैकल्पिक,
|
|
426
|
+
## Memory Layer (वैकल्पिक, दीर्घकालिक प्रोजेक्ट्स के लिए)
|
|
445
427
|
|
|
446
|
-
|
|
428
|
+
ऊपर वाली scaffolding pipeline के अलावा, ClaudeOS-Core उन projects के लिए एक `claudeos-core/memory/` folder भी seed करता है जिनका context एक session से ज़्यादा खिंचता है। यह वैकल्पिक है — अगर आपको सिर्फ `CLAUDE.md` और rules चाहिए तो इसे ignore कर सकते हैं।
|
|
447
429
|
|
|
448
|
-
|
|
449
|
-
- `failure-patterns.md` — frequency/importance स्कोर के साथ बार-बार होने वाली त्रुटियाँ
|
|
450
|
-
- `compaction.md` — समय के साथ memory को कैसे auto-compact किया जाता है
|
|
451
|
-
- `auto-rule-update.md` — पैटर्न जो नए rules बनने चाहिए
|
|
430
|
+
चार files हैं, और सब Pass 4 लिखता है।
|
|
452
431
|
|
|
453
|
-
|
|
432
|
+
- `decision-log.md` — append-only "हमने X की जगह Y क्यों चुना", `pass2-merged.json` से seed होता है
|
|
433
|
+
- `failure-patterns.md` — frequency / importance scores के साथ बार-बार आने वाली errors
|
|
434
|
+
- `compaction.md` — समय के साथ memory कैसे auto-compact होती है
|
|
435
|
+
- `auto-rule-update.md` — वो patterns जिन्हें नए rules बनना चाहिए
|
|
454
436
|
|
|
455
|
-
|
|
437
|
+
इस layer को समय के साथ maintain करने के लिए दो commands हैं।
|
|
438
|
+
|
|
439
|
+
```bash
|
|
440
|
+
# Failure-patterns log compact करें (समय-समय पर चलाएँ)
|
|
441
|
+
npx claudeos-core memory compact
|
|
442
|
+
|
|
443
|
+
# बार-बार आने वाले failure patterns को proposed rules में promote करें
|
|
444
|
+
npx claudeos-core memory propose-rules
|
|
445
|
+
```
|
|
446
|
+
|
|
447
|
+
Memory model और lifecycle की पूरी बात [docs/hi/memory-layer.md](docs/hi/memory-layer.md) में है।
|
|
456
448
|
|
|
457
449
|
---
|
|
458
450
|
|
|
459
451
|
## FAQ
|
|
460
452
|
|
|
461
|
-
**Q: क्या
|
|
462
|
-
A: नहीं। ClaudeOS-Core आपके
|
|
453
|
+
**Q: क्या Claude API key चाहिए?**
|
|
454
|
+
A: नहीं। ClaudeOS-Core आपके पहले से installed Claude Code को ही use करता है और आपकी machine पर `claude -p` को prompts pipe करता है। कोई extra account नहीं चाहिए।
|
|
463
455
|
|
|
464
|
-
**Q: क्या यह मेरी मौजूदा CLAUDE.md या `.claude/rules/`
|
|
465
|
-
A: नए
|
|
456
|
+
**Q: क्या यह मेरी मौजूदा CLAUDE.md या `.claude/rules/` overwrite कर देगा?**
|
|
457
|
+
A: नए project पर पहली run में यह इन्हें create करता है। `--force` के बिना दोबारा चलाने पर आपके edits बच जाते हैं, क्योंकि पिछली run के pass markers detect होकर वो passes skip हो जाते हैं। `--force` के साथ चलाने पर सब wipe होकर regenerate होता है, यानी edits भी चले जाते हैं — `--force` का मतलब ही यही है। ज़्यादा detail [docs/hi/safety.md](docs/hi/safety.md) में।
|
|
466
458
|
|
|
467
|
-
**Q: मेरा stack
|
|
468
|
-
A: हाँ। नए
|
|
459
|
+
**Q: मेरा stack supported नहीं है, क्या जोड़ सकते हैं?**
|
|
460
|
+
A: हाँ। नए stack के लिए करीब 3 prompt templates और एक domain scanner चाहिए। 8-step guide के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
|
|
469
461
|
|
|
470
|
-
**Q:
|
|
471
|
-
A: `npx claudeos-core init --lang ko
|
|
462
|
+
**Q: कोरियाई (या किसी और भाषा) में docs कैसे generate करूँ?**
|
|
463
|
+
A: `npx claudeos-core init --lang ko`। 10 भाषाएँ supported हैं: en, ko, ja, zh-CN, es, vi, hi, ru, fr, de।
|
|
472
464
|
|
|
473
465
|
**Q: क्या यह monorepos के साथ काम करता है?**
|
|
474
|
-
A:
|
|
466
|
+
A: हाँ। Turborepo (`turbo.json`), pnpm workspaces (`pnpm-workspace.yaml`), Lerna (`lerna.json`) और npm/yarn workspaces (`package.json#workspaces`) — इन्हें stack-detector पहचान लेता है, और हर app के लिए अलग analysis होता है। बाकी monorepo layouts (जैसे NX) explicitly detect नहीं होते, मगर generic `apps/*/` और `packages/*/` patterns per-stack scanners फिर भी pick कर लेते हैं।
|
|
467
|
+
|
|
468
|
+
**Q: अगर Claude Code ऐसे rules generate कर दे जिनसे मैं असहमत हूँ?**
|
|
469
|
+
A: सीधे edit कर दीजिए। उसके बाद `npx claudeos-core lint` चलाकर check कर लीजिए कि CLAUDE.md अभी भी structurally valid है या नहीं। आगे की `init` runs पर (बिना `--force` के) आपके edits बच जाते हैं, क्योंकि resume mechanism उन passes को skip करता है जिनके markers मौजूद हैं।
|
|
470
|
+
|
|
471
|
+
**Q: Bugs कहाँ report करूँ?**
|
|
472
|
+
A: [GitHub Issues](https://github.com/claudeos-core/claudeos-core/issues) पर। Security issues के लिए [SECURITY.md](SECURITY.md) देखें।
|
|
473
|
+
|
|
474
|
+
---
|
|
475
475
|
|
|
476
|
-
|
|
477
|
-
A: उन्हें सीधे संपादित करें। फिर यह पुष्टि करने के लिए `npx claudeos-core lint` चलाएँ कि CLAUDE.md अभी भी संरचनात्मक रूप से वैध है। आपके edits बाद की `init` runs पर सुरक्षित रहते हैं (`--force` के बिना) — resume तंत्र उन passes को छोड़ देता है जिनके markers मौजूद हैं।
|
|
476
|
+
## यदि इसने आपका समय बचाया
|
|
478
477
|
|
|
479
|
-
|
|
480
|
-
A: [GitHub Issues](https://github.com/claudeos-core/claudeos-core/issues)। सुरक्षा मुद्दों के लिए [SECURITY.md](SECURITY.md) देखें।
|
|
478
|
+
GitHub पर एक ⭐ project को visible रखता है और दूसरों को भी इसे ढूँढने में मदद करता है। Issues, PRs और stack template contributions — सबका स्वागत है। Detail के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
|
|
481
479
|
|
|
482
480
|
---
|
|
483
481
|
|
|
484
|
-
##
|
|
482
|
+
## दस्तावेज़ीकरण
|
|
485
483
|
|
|
486
484
|
| विषय | यह पढ़ें |
|
|
487
485
|
|---|---|
|
|
488
|
-
| 4-pass
|
|
489
|
-
| Architecture के
|
|
490
|
-
| Stack detection —
|
|
486
|
+
| 4-pass pipeline कैसे काम करती है (diagram से ज़्यादा गहराई से) | [docs/hi/architecture.md](docs/hi/architecture.md) |
|
|
487
|
+
| Architecture के visual diagrams (Mermaid) | [docs/hi/diagrams.md](docs/hi/diagrams.md) |
|
|
488
|
+
| Stack detection — हर scanner क्या देखता है | [docs/hi/stacks.md](docs/hi/stacks.md) |
|
|
491
489
|
| Memory layer — decision logs और failure patterns | [docs/hi/memory-layer.md](docs/hi/memory-layer.md) |
|
|
492
|
-
|
|
|
490
|
+
| पाँचों validators detail में | [docs/hi/verification.md](docs/hi/verification.md) |
|
|
493
491
|
| हर CLI command और option | [docs/hi/commands.md](docs/hi/commands.md) |
|
|
494
|
-
|
|
|
492
|
+
| Manual installation (बिना `npx` के) | [docs/hi/manual-installation.md](docs/hi/manual-installation.md) |
|
|
495
493
|
| Scanner overrides — `.claudeos-scan.json` | [docs/hi/advanced-config.md](docs/hi/advanced-config.md) |
|
|
496
|
-
|
|
|
497
|
-
|
|
|
498
|
-
|
|
|
494
|
+
| Safety: re-init पर क्या-क्या preserved रहता है | [docs/hi/safety.md](docs/hi/safety.md) |
|
|
495
|
+
| Similar tools के साथ तुलना (scope, quality नहीं) | [docs/hi/comparison.md](docs/hi/comparison.md) |
|
|
496
|
+
| Errors और recovery | [docs/hi/troubleshooting.md](docs/hi/troubleshooting.md) |
|
|
499
497
|
|
|
500
498
|
---
|
|
501
499
|
|
|
502
500
|
## योगदान
|
|
503
501
|
|
|
504
|
-
|
|
502
|
+
Contributions का स्वागत है — stack support जोड़ना, prompts सुधारना, bugs ठीक करना, सब कुछ। Detail के लिए [CONTRIBUTING.md](CONTRIBUTING.md) देखें।
|
|
505
503
|
|
|
506
|
-
Code of Conduct और
|
|
504
|
+
Code of Conduct और security policy [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) और [SECURITY.md](SECURITY.md) में हैं।
|
|
507
505
|
|
|
508
|
-
##
|
|
506
|
+
## लाइसेंस
|
|
509
507
|
|
|
510
|
-
[ISC](LICENSE)
|
|
508
|
+
[ISC License](LICENSE)। Commercial use सहित किसी भी काम के लिए free है। © 2025–2026 ClaudeOS-Core contributors।
|
|
511
509
|
|
|
512
510
|
---
|
|
513
511
|
|
|
514
|
-
<sub>[
|
|
512
|
+
<sub>[claudeos-core](https://github.com/claudeos-core) team द्वारा maintained। Issues और PRs <https://github.com/claudeos-core/claudeos-core> पर भेजें।</sub>
|