docs: updated docs for ctx generate command

Author: butschster

docs/advanced/development-process.md

@@ -52,52 +52,38 @@ Use the following instruction to create a context file with detailed description
 > help it understand the document structure.
 
 ```
-Your goal is to create a `context.yaml` configuration that:
-
-1. Organizes source code into logical, cohesive documents
-2. Provides detailed descriptions that explain each component's purpose and relationships
-3. Uses appropriate source types and filtering to capture relevant code
-4. Creates a structure that makes navigation and understanding intuitive
-
-## Configuration Structure
-
-Start by analyzing the codebase to identify major functional areas. For each area, create a document with:
-
-1. A clear, descriptive title that indicates the document's focus
-2. A detailed description explaining what functionality this area provides
-3. Sources that target the relevant files with appropriate filtering
-4. For each source, a comprehensive description of what those specific files contribute
-
-## Provide the following information:
-
-Please create a configuration that:
-
-1. Organizes the code by [functional areas/module types/etc.]
-2. Provides detailed descriptions explaining [what aspects you want explained]
-3. Uses [specific source types if relevant]
-4. Includes explanatory content using the text source type where helpful
-
-## Best Practices
-
-When creating configurations:
-
-1. **Use meaningful groupings**: Group related files together based on functionality rather than just directory
-   structure
-2. **Provide context in descriptions**: Explain not just what components do, but how they relate to the larger system
-3. **Use filtering effectively**: Apply path, pattern, and content filters to include only relevant files
-4. **Include architectural overviews**: Use text sources to provide high-level explanations where appropriate
-5. **Leverage tree visualizations**: For complex projects, include tree sources to visualize structure
-6. **Add directory context**: When using tree sources, add explanations via the dirContext property
-
-## Using Advanced Features
-
-Consider using these advanced features for more comprehensive configurations:
-
-1. **Modifier configurations**: Use php-content-filter or sanitizer modifiers to focus on relevant code parts
-2. **Combined sources**: Mix different source types (file, text, tree) in a document for richer context
-3. **Nested documents**: Create hierarchical document structures with overview and detail documents
-4. **Tag-based organization**: Use tags to create cross-cutting views of the codebase
-5. **GitDiff sources**: For evolving codebases, capture recent changes for focused documentation
+Your goal is to create a `context.yaml` file, using provided JSON schema for context generator. 
+Always use YAML syntax.
+
+Provide multiple configs. Split documents into small logical config files. Small configs is better that one big config.
+
+**Rules**
+1. **Organizes Code**
+    - Split your source code into clear, logical documents based on its functions or modules.
+    - Group related files together based on what they do, not just their folder structure.
+2. **Detailed Descriptions**
+    - Write a title and a short, clear description for each document.
+    - Explain the purpose of each component and how they connect to the rest of the project.
+3. **Relevant Sources and Filtering**
+    - Use the right source types (file, text, tree, etc.) to capture the needed code.
+    - Apply filters (by path, pattern, or content) to only include the important files.
+    - Do not try to use `contains` filter. Only by file path.
+4. **Output Paths**
+    - Make sure output paths start with the content/context type, like `project/` or `feature/`.
+5. **Content Limit**
+    - Ensure that each document does not exceed 50,000 characters.
+
+**Extra Tips:**
+- **Meaningful Groupings:** Focus on functionality. Group files that work together.
+- More small documents is better than one big document. 
+- **Use Visuals:** For bigger projects, include tree views or mermaid diagrams with extra notes.
+- Do not provide default values for properties
+- Do not use quotes if it unnecessary
+- Do not use arrays in format `[...]`
+- Advanced Features:
+    - Mix different source types for richer details.
+    - Consider nested documents or tag-based views for more complex projects.
+    - Use GitDiff sources if you need to show recent changes.
 ```
 
 ### Step 3: Explore Configuration and Entry Points

docs/advanced/smart-context-requesting.md

@@ -37,8 +37,35 @@ through executable commands. This creates a feedback loop that significantly enh
 Here's a complete workflow example showing how an LLM and the Context Generator can work together:
 
 1. **User Question**:
-   "I'm getting an error in our payment processing system when handling refunds. The error says 'Invalid transaction
-   state'. How can I fix this?"
+
+```
+I'm getting an error in our payment processing system when handling refunds. 
+The error says 'Invalid transactionstate'. How can I fix this?
+
+Here is my project structure:
+
+├── services/
+│   └── payment/
+│       └── app/
+│           └── src/
+│               └── Application/
+│                   ├── RefundService.php
+│                   ├── TransactionState.php
+│                   └── PaymentProcessor.php
+
+I attached JSON schema of Context generator. Use it to ask for the context you need to fix the issue in the following format:
+
+ctx --config='{
+  "documents": [{
+    "description": "Document description",
+    "outputPath": "context.md",
+    "sources": [{
+      "type": "file",
+      "sourcePaths": ["src"]
+    }]
+  }]
+}'
+```
 
 2. **LLM Initial Response**:
    "I'll help troubleshoot this issue. To understand what's happening, I need to see the payment processing code,

docs/getting-started/command-reference.md

@@ -19,12 +19,14 @@ ctx build
 
 ### Options
 
-| Option                 | Description                                                                                    |
-|------------------------|------------------------------------------------------------------------------------------------|
-| `--github-token`, `-t` | GitHub token for authentication (default: reads from `GITHUB_TOKEN` environment variable)      |
-| `--env`, `-e`          | Load environment variables from a file. If used without specifying a file, defaults to `.env`. |
+| Option                 | Description                                                                                                                |
+|------------------------|----------------------------------------------------------------------------------------------------------------------------|
+| `--github-token`, `-t` | GitHub token for authentication (default: reads from `GITHUB_TOKEN` environment variable)                                  |
+| `--env`, `-e`          | Load environment variables from a file. If used without specifying a file, defaults to `.env`.                             |
+| `--inline`, `-i`       | Inline JSON configuration string. If provided, file-based configuration will be ignored.                                   |
+| `--config-file`, `-c`  | Path to a specific configuration file or directory. If not provided, will look for standard config files in the root path. |
 
-Examples of using the `--env` option:
+**Examples of using the `--env` option:**
 
 ```bash
 # Load variables from a specific file
@@ -34,6 +36,19 @@ ctx --env=.env.local
 ctx
 ```
 
+**Examples of specifying configuration:**
+
+```bash
+# Use a specific configuration file
+ctx -c src/custom-config.yaml
+
+# Look for standard config files (context.json, context.yaml, etc.) in a specific directory
+ctx -c src/configs
+
+# Use inline JSON configuration
+ctx -i '{"documents":[{"description":"Quick Context","outputPath":"output.md","sources":[{"type":"text","content":"Sample content"}]}]}'
+```
+
 ## Initialize a Configuration File
 
 Creates a new configuration file in the current directory. The default filename is `context.yaml` if not specified.
@@ -118,9 +133,9 @@ ctx schema -d -o custom-name.json
 You can provide a JSON configuration directly on the command line without needing a config file:
 
 ```bash
-ctx --config='{"documents":[{"description":"Quick Context","outputPath":"output.md","sources":[{"type":"text","content":"Sample content"}]}]}'
+ctx --inline='{"documents":[{"description":"Quick Context","outputPath":"output.md","sources":[{"type":"text","content":"Sample content"}]}]}'
 # or
-ctx -c '{"documents":[{"description":"Quick Context","outputPath":"output.md","sources":[{"type":"text","content":"Sample content"}]}]}'
+ctx -i '{"documents":[{"description":"Quick Context","outputPath":"output.md","sources":[{"type":"text","content":"Sample content"}]}]}'
 ```
 
 **This is useful for:**
@@ -134,7 +149,7 @@ The JSON configuration structure follows the same schema as config files. For co
 consider using a heredoc in your shell scripts:
 
 ```bash
-ctx --config='
+ctx --inline='
 {
   "documents": [
     {