diff --git a/docs/commit-commands.md b/docs/commit-commands.md
new file mode 100644
index 0000000..5eab520
--- /dev/null
+++ b/docs/commit-commands.md
@@ -0,0 +1,161 @@
+# Penify CLI - Commit Commands
+
+The `commit` command allows you to generate smart, AI-powered commit messages for your Git changes. This document explains all available options and combinations.
+
+## Basic Usage
+
+```bash
+penifycli commit
+```
+
+By default, this command:
+- Analyzes your staged Git changes
+- Generates a concise commit title only
+- Uses local LLM if configured, or falls back to Penify API
+
+## Command Options
+
+### `-m, --message`
+
+Provide context for the commit message generation:
+
+```bash
+penifycli commit -m "Fix login flow"
+```
+
+This hint helps the AI understand your intention and improves the quality of the generated message.
+
+### `-e, --terminal`
+
+Open an editor to review and edit the generated commit message before committing:
+
+```bash
+penifycli commit -e
+```
+
+This opens your default Git editor with the generated message for review.
+
+### `-d, --description`
+
+Generate a detailed commit message with both title and description:
+
+```bash
+penifycli commit -d
+```
+
+Without this flag, only the commit title is generated.
+
+## Option Combinations
+
+You can combine these options for different workflows:
+
+### Generate Title Only with Context
+
+```bash
+penifycli commit -m "Update login UI"
+```
+
+### Generate Title and Description with Context
+
+```bash
+penifycli commit -m "Update login UI" -d
+```
+
+### Generate and Edit Full Commit Message
+
+```bash
+penifycli commit -d -e
+```
+
+### Generate, Edit, and Provide Context
+
+```bash
+penifycli commit -m "Refactor authentication" -d -e
+```
+
+## LLM and JIRA Integration
+
+### Using Local LLM
+
+If you've configured a local LLM using `penifycli config llm`, the commit command will automatically use it for message generation.
+
+Benefits:
+- Privacy: your code changes don't leave your machine
+- Speed: no network latency
+- Works offline
+
+### JIRA Enhancement
+
+If you've configured JIRA integration using `penifycli config jira`, the commit command will:
+
+1. Detect JIRA issue references in your changes
+2. Fetch issue details from your JIRA instance
+3. Include issue information in the commit message
+4. Format the commit message according to JIRA's smart commit format
+
+Example output:
+```
+PROJ-123: Fix authentication bug in login flow
+
+- Updated OAuth token validation
+- Fixed session timeout handling
+- Added unit tests for edge cases
+
+[PROJ-123]
+```
+
+## Configuration Requirements
+
+For the `commit` command to work:
+
+1. You must have configured either:
+   - Local LLM via `penifycli config llm`, OR
+   - Logged in via `penifycli login`
+   
+2. For JIRA enhancement (optional):
+   - Configure JIRA via `penifycli config jira`
+
+## Examples
+
+### Basic Commit with Default Settings
+
+```bash
+# Stage your changes
+git add .
+
+# Generate commit message
+penifycli commit
+
+# Commit with the generated message
+git commit -m "Generated message here"
+```
+
+### Full Workflow with All Features
+
+```bash
+# Stage your changes
+git add .
+
+# Generate detailed commit message with JIRA integration, 
+# provide context, and open editor for review
+penifycli commit -m "Fix login issue" -d -e
+
+# The commit is automatically completed after you save and exit the editor
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"No LLM model or API token provided"**
+   - Run `penifycli config llm` to configure a local LLM, or
+   - Run `penifycli login` to authenticate with Penify
+
+2. **"Failed to connect to JIRA"**
+   - Check your JIRA configuration with `cat ~/.penify`
+   - Verify your network connection
+   - Ensure your JIRA credentials are valid
+
+3. **"Error initializing LLM client"**
+   - Verify your LLM configuration settings
+   - Ensure the LLM API is accessible
diff --git a/docs/config-commands.md b/docs/config-commands.md
new file mode 100644
index 0000000..2174ced
--- /dev/null
+++ b/docs/config-commands.md
@@ -0,0 +1,166 @@
+# Penify CLI - Configuration Commands
+
+The `config` command allows you to set up and manage configuration settings for Penify CLI. This document explains all available configuration options and how to use them.
+
+## Configuration Overview
+
+Penify CLI stores configuration in a JSON file at `~/.penify/config.json`. The configuration includes:
+
+- LLM (Large Language Model) settings for local commit message generation
+- JIRA integration settings for enhanced commit messages
+- API tokens and other credentials
+
+## Basic Usage
+
+```bash
+# Configure LLM settings
+penifycli config llm
+
+# Configure JIRA integration
+penifycli config jira
+```
+
+## LLM Configuration
+
+### Web Interface
+
+Running `penifycli config llm` opens a web interface in your browser where you can configure:
+
+1. **Model**: The LLM model to use (e.g., `gpt-3.5-turbo`)
+2. **API Base URL**: The endpoint URL for your LLM API (e.g., `https://api.openai.com/v1`)
+3. **API Key**: Your authentication key for the LLM API
+
+### Supported LLMs
+
+Penify CLI supports various LLM providers:
+
+#### OpenAI
+- Model: `gpt-3.5-turbo` or `gpt-4`
+- API Base: `https://api.openai.com/v1`
+- API Key: Your OpenAI API key
+
+#### Anthropic
+- Model: `claude-instant-1` or `claude-2`
+- API Base: `https://api.anthropic.com/v1`
+- API Key: Your Anthropic API key
+
+#### Ollama (Local)
+- Model: `llama2` or any model you have installed
+- API Base: `http://localhost:11434`
+- API Key: (leave blank)
+
+#### Azure OpenAI
+- Model: Your deployed model name
+- API Base: Your Azure endpoint
+- API Key: Your Azure API key
+
+### Configuration File Structure
+
+After configuration, your `~/.penify/config.json` will contain:
+
+```json
+{
+  "llm": {
+    "model": "gpt-3.5-turbo",
+    "api_base": "https://api.openai.com/v1",
+    "api_key": "sk-..."
+  }
+}
+```
+
+## JIRA Configuration
+
+### Web Interface
+
+Running `penifycli config jira` opens a web interface where you can configure:
+
+1. **JIRA URL**: Your JIRA instance URL (e.g., `https://yourcompany.atlassian.net`)
+2. **Username**: Your JIRA username (typically your email)
+3. **API Token**: Your JIRA API token
+
+### Creating a JIRA API Token
+
+1. Log in to [https://id.atlassian.com/manage-profile/security/api-tokens](https://id.atlassian.com/manage-profile/security/api-tokens)
+2. Click "Create API token"
+3. Give it a name (e.g., "Penify CLI")
+4. Copy the generated token and paste it into the configuration
+
+### Configuration File Structure
+
+After configuration, your `~/.penify/config.json` will contain:
+
+```json
+{
+  "jira": {
+    "url": "https://yourcompany.atlassian.net",
+    "username": "your.email@example.com",
+    "api_token": "your-jira-api-token"
+  }
+}
+```
+
+## Configuration Locations
+
+Penify CLI looks for configuration in multiple locations:
+
+1. Project-specific: `.penify/config.json` in the Git repository root
+2. User-specific: `~/.penify/config.json` in your home directory
+
+The project-specific configuration takes precedence if both exist.
+
+## Environment Variables
+
+You can override configuration settings using environment variables:
+
+- `PENIFY_API_TOKEN`: Override the stored API token
+- `PENIFY_LLM_MODEL`: Override the configured LLM model
+- `PENIFY_LLM_API_BASE`: Override the configured LLM API base URL
+- `PENIFY_LLM_API_KEY`: Override the configured LLM API key
+- `PENIFY_JIRA_URL`: Override the configured JIRA URL
+- `PENIFY_JIRA_USER`: Override the configured JIRA username
+- `PENIFY_JIRA_TOKEN`: Override the configured JIRA API token
+
+Example:
+```bash
+export PENIFY_LLM_MODEL="gpt-4"
+penifycli commit
+```
+
+## Command-Line Configuration
+
+For advanced users or scripting, you can directly edit the configuration file:
+
+```bash
+# View current configuration
+cat ~/.penify/config.json
+
+# Edit configuration with your preferred editor
+nano ~/.penify/config.json
+```
+
+## Sharing Configuration
+
+You can share configuration between machines by copying the `.penify/config.json` file. However, be cautious with API keys and credentials.
+
+For team settings, consider:
+1. Using a project-specific `.penify/config.json` with shared settings
+2. Excluding API keys from shared configuration
+3. Using environment variables for sensitive credentials
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Error reading configuration file"**
+   - Check if the file exists: `ls -la ~/.penify`
+   - Ensure it contains valid JSON: `cat ~/.penify/config.json`
+
+2. **"Failed to connect to LLM API"**
+   - Verify API base URL and API key
+   - Check network connectivity to the API endpoint
+   - Ensure your account has access to the specified model
+
+3. **"Failed to connect to JIRA"**
+   - Check JIRA URL format (should include `https://`)
+   - Verify username and API token
+   - Ensure your JIRA account has API access permissions
diff --git a/docs/detailed-usage.md b/docs/detailed-usage.md
new file mode 100644
index 0000000..70cd6d9
--- /dev/null
+++ b/docs/detailed-usage.md
@@ -0,0 +1,160 @@
+# Penify CLI - Detailed Usage Guide
+
+This document provides in-depth information about all features and capabilities of the Penify CLI tool.
+
+## Table of Contents
+
+- [Penify CLI - Detailed Usage Guide](#penify-cli---detailed-usage-guide)
+  - [Table of Contents](#table-of-contents)
+  - [Authentication](#authentication)
+    - [Login Process](#login-process)
+    - [API Token Storage](#api-token-storage)
+    - [Token Precedence](#token-precedence)
+  - [Command Overview](#command-overview)
+  - [Commit Message Generation](#commit-message-generation)
+  - [Code Documentation Generation](#code-documentation-generation)
+    - [Use Cases](#use-cases)
+    - [Authentication Requirement](#authentication-requirement)
+  - [Configuration Settings](#configuration-settings)
+  - [Git Hooks](#git-hooks)
+    - [Post-Commit Hook](#post-commit-hook)
+    - [Custom Hook Location](#custom-hook-location)
+  - [Advanced Use Cases](#advanced-use-cases)
+    - [CI/CD Integration](#cicd-integration)
+    - [Remote Repository Documentation](#remote-repository-documentation)
+  - [Troubleshooting](#troubleshooting)
+    - [Common Issues](#common-issues)
+    - [Logs](#logs)
+    - [Support](#support)
+
+## Authentication
+
+### Login Process
+
+When you run `penifycli login`, the tool:
+
+1. Opens your default web browser
+2. Redirects you to Penify's login page
+3. Captures the authentication token after successful login
+4. Saves the token in `~/.penify` file
+
+### API Token Storage
+
+API tokens are stored in your home directory in the `.penify` file. This JSON file contains:
+
+```json
+{
+  "api_keys": "your-api-token",
+  "llm": { "model": "...", "api_base": "...", "api_key": "..." },
+  "jira": { "url": "...", "username": "...", "api_token": "..." }
+}
+```
+
+### Token Precedence
+
+1. Environment variable `PENIFY_API_TOKEN` (highest priority)
+2. Token in `~/.penify` file
+
+## Command Overview
+
+```
+penifycli
+├── commit        Generate smart commit messages
+├── config        Configure local LLM and JIRA
+│   ├── llm       Configure local LLM settings
+│   └── jira      Configure JIRA integration
+├── login         Log in to Penify account
+└── docgen        Generate code documentation
+    ├── install-hook     Install Git post-commit hook
+    └── uninstall-hook   Remove Git post-commit hook
+```
+
+## Commit Message Generation
+
+The `commit` command analyzes your staged changes and generates meaningful commit messages. It can:
+
+- Use a local LLM if configured
+- Enhance messages with JIRA issue details
+- Provide both title and description
+
+For specific options and examples, see [docs/commit-commands.md](commit-commands.md).
+
+## Code Documentation Generation
+
+The `docgen` command generates documentation for your code:
+
+### Use Cases
+
+1. **Current Git Diff**: Default behavior, documents only changed files
+2. **Specific File**: Pass a file path with `-l path/to/file.py`
+3. **Entire Folder**: Pass a folder path with `-l path/to/folder`
+
+### Authentication Requirement
+
+This feature requires authentication with a Penify account. Run `penifycli login` before using documentation features.
+
+## Configuration Settings
+
+Configure local settings using the `config` command:
+
+- **LLM Settings**: Configure a local LLM for commit message generation
+- **JIRA Settings**: Set up JIRA integration for enhanced commit messages
+
+For detailed configuration options, see [docs/config-commands.md](config-commands.md).
+
+## Git Hooks
+
+Penify can install Git hooks to automate documentation generation:
+
+### Post-Commit Hook
+
+- **Install**: `penifycli docgen install-hook`
+- **What it does**: Automatically generates documentation for changed files after each commit
+- **Uninstall**: `penifycli docgen uninstall-hook`
+
+### Custom Hook Location
+
+You can specify a custom location for Git hooks:
+
+```bash
+penifycli docgen install-hook -l /path/to/git/repo
+```
+
+## Advanced Use Cases
+
+### CI/CD Integration
+
+For CI/CD pipelines:
+
+1. Set `PENIFY_API_TOKEN` as an environment variable
+2. Run commands without requiring interactive login
+
+### Remote Repository Documentation
+
+Generate documentation for an entire repository:
+
+```bash
+git clone https://github.com/user/repo
+cd repo
+penifycli docgen -l .
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**: Ensure you've run `penifycli login` or set `PENIFY_API_TOKEN`
+2. **LLM Configuration**: Check your LLM settings with `cat ~/.penify`
+3. **JIRA Integration**: Verify JIRA credentials in your configuration
+
+### Logs
+
+For more detailed logs, you can set the environment variable:
+
+```bash
+export PENIFY_DEBUG=1
+```
+
+### Support
+
+For additional help, visit [https://docs.penify.dev/](https://docs.penify.dev/) or contact support@penify.dev
diff --git a/docs/doc_commands.md b/docs/doc_commands.md
new file mode 100644
index 0000000..9d8c633
--- /dev/null
+++ b/docs/doc_commands.md
@@ -0,0 +1,327 @@
+# Penify CLI - Documentation Generation Commands
+
+This document provides a detailed guide to all permutations and combinations of the `docgen` command, including extensive information about Git hook commands for automating documentation generation.
+
+## Table of Contents
+
+- [Basic Usage](#basic-usage)
+- [Command Options](#command-options)
+- [Option Combinations](#option-combinations)
+- [Git Hook Commands](#git-hook-commands)
+  - [Hook Installation](#hook-installation)
+  - [Hook Customization](#hook-customization)
+  - [Hook Uninstallation](#hook-uninstallation)
+- [Advanced Use Cases](#advanced-use-cases)
+- [Troubleshooting](#troubleshooting)
+
+## Basic Usage
+
+```bash
+penifycli docgen
+```
+
+By default, this command:
+- Analyzes the current Git diff (changes since last commit)
+- Generates documentation for changed files only
+- Requires authentication via `penifycli login`
+
+## Command Options
+
+### `-l, --location`
+
+Specify a target for documentation generation:
+
+```bash
+# Generate documentation for a specific file
+penifycli docgen -l path/to/file.py
+
+# Generate documentation for a specific folder
+penifycli docgen -l path/to/folder
+```
+
+Without this flag, Penify analyzes only Git-tracked modified files.
+
+### Subcommands
+
+#### `install-hook`
+
+Install a Git post-commit hook to automatically generate documentation:
+
+```bash
+penifycli docgen install-hook
+```
+
+#### `uninstall-hook`
+
+Remove the Git post-commit hook:
+
+```bash
+penifycli docgen uninstall-hook
+```
+
+## Option Combinations
+
+### Generate Documentation for Current Git Diff
+
+```bash
+# Basic usage - current Git diff
+penifycli docgen
+```
+
+### Generate Documentation for a Specific File
+
+```bash
+# Single file documentation
+penifycli docgen -l src/main.py
+```
+
+### Generate Documentation for a Folder
+
+```bash
+# Folder documentation
+penifycli docgen -l src/models/
+```
+
+### Install Hook in Current Repository
+
+```bash
+# Install hook in current Git repository
+penifycli docgen install-hook
+```
+
+### Install Hook in Specific Repository
+
+```bash
+# Install hook in a specific Git repository
+penifycli docgen install-hook -l /path/to/repo
+```
+
+### Uninstall Hook from Current Repository
+
+```bash
+# Uninstall hook from current Git repository
+penifycli docgen uninstall-hook
+```
+
+### Uninstall Hook from Specific Repository
+
+```bash
+# Uninstall hook from a specific Git repository
+penifycli docgen uninstall-hook -l /path/to/repo
+```
+
+## Git Hook Commands
+
+Penify provides Git hook commands to automate documentation generation as part of your Git workflow.
+
+### Hook Installation
+
+#### How Hooks Work
+
+When you install a Git hook with `penifycli docgen install-hook`, Penify:
+
+1. Creates a post-commit hook script in the `.git/hooks` directory
+2. Makes the script executable
+3. Configures the hook to run `penifycli docgen` after each commit
+
+#### Hook Script Content
+
+The generated post-commit hook contains:
+
+```bash
+#!/bin/sh
+# This is a post-commit hook generated by penifycli.
+# Automatically generates documentation for changed files after each commit.
+
+penifycli docgen -gf /path/to/git/repository -t your_api_token
+```
+
+#### Installation Location
+
+By default, hooks are installed in the current Git repository. You can specify a different location:
+
+```bash
+penifycli docgen install-hook -l /path/to/repo
+```
+
+#### Installation Requirements
+
+To install hooks, you need:
+- A valid Penify API token (login first with `penifycli login`)
+- Write permissions to the `.git/hooks` directory
+
+#### Verifying Installation
+
+After installation, you can verify that the hook is installed:
+
+```bash
+cat .git/hooks/post-commit
+```
+
+### Hook Customization
+
+You can customize the post-commit hook after installation:
+
+#### Modifying Hook Behavior
+
+1. Edit the `.git/hooks/post-commit` file
+2. Add additional options to the `penifycli docgen` command
+3. Add other commands to run after commit
+
+Example of a customized hook:
+
+```bash
+#!/bin/sh
+# This is a post-commit hook generated by penifycli.
+# Automatically generates documentation for changed files after each commit.
+
+# Generate documentation
+penifycli docgen -gf /path/to/git/repository -t your_api_token
+
+# Additional custom commands
+echo "Documentation generation complete!"
+```
+
+#### Advanced Hook Scenarios
+
+**Conditional Documentation Generation**:
+
+```bash
+#!/bin/sh
+# Only generate documentation for commits to the main branch
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+if [ "$BRANCH" = "main" ]; then
+  penifycli docgen -gf /path/to/git/repository -t your_api_token
+fi
+```
+
+**Documenting Specific Files/Folders**:
+
+```bash
+#!/bin/sh
+# Only document Python files in the src directory
+penifycli docgen -l src/ -gf /path/to/git/repository -t your_api_token
+```
+
+### Hook Uninstallation
+
+#### Standard Uninstallation
+
+To remove a hook from the current repository:
+
+```bash
+penifycli docgen uninstall-hook
+```
+
+#### Specific Repository Uninstallation
+
+To remove a hook from a specific repository:
+
+```bash
+penifycli docgen uninstall-hook -l /path/to/repo
+```
+
+#### Manual Hook Removal
+
+If needed, you can manually remove the hook:
+
+```bash
+rm .git/hooks/post-commit
+```
+
+#### Verifying Uninstallation
+
+Check that the hook was successfully removed:
+
+```bash
+ls -la .git/hooks/post-commit  # Should return "No such file or directory"
+```
+
+## Advanced Use Cases
+
+### Continuous Integration
+
+Run documentation generation in CI pipelines:
+
+```bash
+# In your CI script
+export PENIFY_API_TOKEN=your_api_token
+penifycli docgen -l src/
+```
+
+### Batch Documentation
+
+Generate documentation for multiple repositories:
+
+```bash
+# Bash script for batch documentation
+for repo in repo1 repo2 repo3; do
+  cd /path/to/$repo
+  penifycli docgen -l .
+done
+```
+
+### Custom Git Hook Integration
+
+Integrate with other Git hooks:
+
+```bash
+# In .git/hooks/pre-push
+penifycli docgen -l src/
+```
+
+### Documenting Release Tags
+
+Generate documentation when creating a release tag:
+
+```bash
+# Document everything when creating a tag
+git tag -a v1.0.0
+penifycli docgen -l .  # Document entire codebase
+git commit --amend -m "Release v1.0.0 with updated documentation"
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"Authentication required"**
+   - Run `penifycli login` before using documentation features
+   - Check your API token with `cat ~/.penify`
+
+2. **"Permission denied when installing hook"**
+   - Check Git repository permissions
+   - Try running with sudo (if appropriate for your environment)
+   - Ensure the `.git/hooks` directory exists
+
+3. **"Hook installed but not running"**
+   - Check if the hook is executable: `ls -la .git/hooks/post-commit`
+   - Make it executable if needed: `chmod +x .git/hooks/post-commit`
+   - Check for syntax errors in the hook script
+
+4. **"File or directory not found"**
+   - Verify the path provided to the `-l` option
+   - Ensure you're running the command from the correct directory
+
+5. **"Hook uninstallation failed"**
+   - Check permissions on the `.git/hooks` directory
+   - Try manual removal: `rm .git/hooks/post-commit`
+
+### Debugging
+
+For detailed output when running documentation commands:
+
+```bash
+export PENIFY_DEBUG=1
+penifycli docgen -l src/
+```
+
+### Getting Help
+
+For command-specific help:
+
+```bash
+penifycli docgen --help
+penifycli docgen install-hook --help
+penifycli docgen uninstall-hook --help
+```
diff --git a/docs/example-workflows.md b/docs/example-workflows.md
new file mode 100644
index 0000000..cc2a872
--- /dev/null
+++ b/docs/example-workflows.md
@@ -0,0 +1,143 @@
+# Penify CLI Example Workflows
+
+This document demonstrates how to use Penify CLI in real-world development workflows to improve your productivity.
+
+## Workflow 1: Efficient Git Commits with AI
+
+### Setup
+
+First, configure your local LLM for offline operation:
+
+```bash
+penifycli config llm
+```
+
+Configure your JIRA integration for enhanced commit messages:
+
+```bash
+penifycli config jira
+```
+
+### Daily Workflow
+
+1. Make your code changes as usual
+2. When ready to commit, use Penify to generate a smart commit message:
+
+```bash
+penifycli commit
+```
+
+3. Review and confirm the generated commit message
+4. Git commit and push as usual
+
+### Benefits
+
+- Consistent and descriptive commit messages
+- Automatic inclusion of relevant JIRA ticket information
+- Time saved from writing detailed commit messages
+
+## Workflow 2: Documentation Generation Pipeline
+
+### Setup
+
+Login to Penify to access advanced documentation features:
+
+```bash
+penifycli login
+```
+
+Install the Git hook for automatic documentation generation:
+
+```bash
+penifycli docgen install-hook
+```
+
+### Daily Workflow
+
+1. Make your code changes as usual
+2. Commit your changes
+3. Documentation is automatically generated for changed files
+4. Review the generated documentation
+
+### Manual Documentation
+
+For specific files or folders:
+
+```bash
+penifycli docgen -l src/components/authentication
+```
+
+### Benefits
+
+- Always up-to-date documentation
+- Consistent documentation style
+- Time saved from writing detailed documentation
+
+## Workflow 3: Code Review Enhancement
+
+### Setup
+
+Ensure you're logged into Penify:
+
+```bash
+penifycli login
+```
+
+### Workflow
+
+1. Before submitting a PR, generate documentation for changed files:
+
+```bash
+penifycli docgen
+```
+
+2. Include the generated documentation in your PR
+3. Reviewers can better understand your changes with the AI-generated explanations
+
+### Benefits
+
+- Improved PR quality
+- Faster code reviews
+- Better team understanding of code changes
+
+## Workflow 4: Onboarding New Team Members
+
+### For Team Leads
+
+Generate comprehensive documentation for the entire codebase:
+
+```bash
+penifycli docgen -l .
+```
+
+### For New Team Members
+
+Generate focused documentation for components you're working on:
+
+```bash
+penifycli docgen -l src/components/my-feature
+```
+
+### Benefits
+
+- Faster onboarding
+- Better understanding of code structure
+- Reduced questions to senior team members
+
+## Workflow 5: Legacy Code Understanding
+
+When working with unfamiliar legacy code:
+
+```bash
+# Document a specific complex file
+penifycli docgen -l src/legacy/complex_module.py
+
+# Document an entire legacy component
+penifycli docgen -l src/legacy/old_component
+```
+
+### Benefits
+
+- Quickly understand complex legacy systems
+- Reduce time spent deciphering undocumented code
+- Make safer changes to legacy systems
diff --git a/docs/penify-cli-documentation.md b/docs/penify-cli-documentation.md
new file mode 100644
index 0000000..1a22b77
--- /dev/null
+++ b/docs/penify-cli-documentation.md
@@ -0,0 +1,207 @@
+---
+layout: doc
+title: Streamline Git Commits and Code Documentation with Penify-CLI's Automated Generation
+description: Discover how Penify-CLI automates both Git commit messages and code documentation, with Jira integration and flexible options. Save time, improve repository clarity, and boost productivity with this detailed guide to usage and best practices.
+keywords: Penify-CLI, Git commit messages, code documentation, Jira integration, automated documentation, version control, repository management, developer productivity
+author: Suman Sauarbh
+---
+# Penify CLI Documentation
+
+Penify CLI is a powerful tool for enhancing your development workflow with AI-powered features like commit message generation, code documentation, and JIRA integration.
+
+## Installation
+
+```bash
+pip install penifycli
+```
+
+## Getting Started
+
+After installation, you can check the version of Penify CLI:
+
+```bash
+penifycli --version
+```
+
+## Commands Overview
+
+- `commit`: Generate smart commit messages using local-LLM
+- `config`: Configure local-LLM and JIRA settings
+- `login`: Log in to Penify to use advanced features
+- `docgen`: Generate code documentation for Git diffs, files, or folders
+
+## Detailed Command Documentation
+
+### Commit Command
+
+The `commit` command generates intelligent commit messages using local LLM models or Penify services.
+
+#### Usage:
+
+```bash
+penifycli commit [options]
+```
+
+#### Options:
+
+- `-m, --message TEXT`: Provide context for the commit message generation
+- `-e, --terminal`: Open an editor to modify the generated commit message before applying it
+- `-d, --description`: Generate a detailed commit message with both title and description
+
+#### Examples:
+
+**Basic usage:**
+```bash
+penifycli commit
+```
+
+**Provide context for better results:**
+```bash
+penifycli commit -m "Fixed the login button"
+```
+
+**Generate a detailed commit message and open editor:**
+```bash
+penifycli commit -e -d
+```
+
+#### Requirements:
+
+- Either a local LLM configuration (via `penifycli config llm`) or Penify login
+- For JIRA integration, configure JIRA settings (via `penifycli config jira`)
+
+---
+
+### Config Command
+
+The `config` command helps you configure local LLM settings and JIRA integration for enhanced commit messages.
+
+#### Usage:
+
+```bash
+penifycli config [subcommand]
+```
+
+#### Subcommands:
+
+- `llm`: Configure local Large Language Model settings
+- `jira`: Configure JIRA integration settings
+
+#### Examples:
+
+**Configure local LLM:**
+```bash
+penifycli config llm
+```
+This opens a web interface to configure:
+- Model name (e.g., gpt-3.5-turbo, llama2)
+- API base URL (e.g., https://api.openai.com/v1)
+- API key
+
+**Configure JIRA integration:**
+```bash
+penifycli config jira
+```
+This opens a web interface to configure:
+- JIRA URL (e.g., https://your-domain.atlassian.net)
+- Username (typically your email)
+- API token
+
+---
+
+### Login Command
+
+The `login` command authenticates you with Penify for advanced features like code documentation generation.
+
+#### Usage:
+
+```bash
+penifycli login
+```
+
+#### What happens:
+1. A browser window opens to the Penify login page
+2. After successful login, your API key is automatically saved
+3. The tool is now authorized to use Penify's advanced features
+
+#### Example:
+
+```bash
+penifycli login
+```
+
+---
+
+### Docgen Command
+
+The `docgen` command generates documentation for your code using Penify's AI services.
+
+#### Usage:
+
+```bash
+penifycli docgen [options] [subcommand]
+```
+
+#### Options:
+
+- `-l, --location PATH`: Path to a specific file or folder to document (default: current working directory)
+
+#### Subcommands:
+
+- `install-hook`: Install a Git post-commit hook to automatically generate documentation
+- `uninstall-hook`: Remove the Git post-commit hook
+
+#### Examples:
+
+**Document current Git diff:**
+```bash
+penifycli docgen
+```
+
+**Document a specific file:**
+```bash
+penifycli docgen -l src/main.py
+```
+
+**Document an entire folder:**
+```bash
+penifycli docgen -l src/components
+```
+
+**Install the Git hook for automatic documentation:**
+```bash
+penifycli docgen install-hook
+```
+
+**Uninstall the Git hook:**
+```bash
+penifycli docgen uninstall-hook
+```
+
+#### Requirements:
+
+- Requires login to Penify (`penifycli login`)
+
+## Configuration Files
+
+Penify CLI stores configuration in the following locations:
+
+- Global configuration: `~/.penify`
+- Project-specific configuration: `.penify` in your Git repository root
+
+## Environment Variables
+
+- `PENIFY_API_TOKEN`: Can be used to provide the API token instead of logging in
+
+## Troubleshooting
+
+If you encounter issues:
+
+1. Check your configuration with `cat ~/.penify`
+2. Verify network connectivity to API endpoints
+3. Ensure your API keys and tokens are valid
+4. For JIRA integration issues, verify your JIRA credentials
+
+## Additional Resources
+
+For more information, visit the [Penify Documentation](https://docs.penify.dev/).