dax911 / grit

GRIT

Work in progress

Welcome to GRIT: Git Reimagined in Rust Interface Tool

I am building this GIT alternative in Rust as a practice exercise in learning Rust and backend things

Eventually I hope to make it more feature rich and perhaps something akin to an open source version of the tools and features we know and love in Github.

To Do

• Version Control
• Built in Commit conventions
• A templating system for commits
• Server stuff
• Git Interoperatability
• Pull Requests

grit's Issues

Interactive Task Management in Gromit Commits

Interactive Task Management in Gromit Commits

Overview

This feature introduces an interactive task management system integrated directly into the grit gromit command. When a user commits changes using grit gromit, the system will fetch associated tasks from the pull request linked to the current branch, allowing the user to update the status of each task interactively. This feature aims to streamline the development workflow by consolidating task management and version control into a single step.

Goals

• Fetch associated tasks from the pull request linked to the current branch during the grit gromit process.
• Provide an interactive interface to update the status of each task (e.g., null, in progress, done, blocked).
• Store the status of tasks within the gromit commit metadata.
• Reflect the overall status of features and tasks in the associated pull request and branch based on the latest gromit commit.

Non-Goals

• Replacing comprehensive project management tools. This feature aims to provide a lightweight task management solution integrated with version control.

Features

• Feature Flag: Introduce a feature flag in the Grit configuration to enable or disable this interactive task management feature.
• Task Fetching: Automatically fetch tasks from the associated pull request when running grit gromit.
• Interactive Task Management: Provide a command-line interface to interactively update the status of each task.
• Task Status in Gromit Metadata: Store the updated status of tasks in the gromit commit metadata.
• Status Reflection in Pull Request and Branch: Automatically update the status of features and tasks in the associated pull request and branch based on the latest gromit commit.

Command-Line Interface

• grit gromit: If the feature flag is enabled, fetch associated tasks and provide an interactive interface to update task statuses.

Interactive Interface

• List all tasks fetched from the associated pull request.
• Allow the user to navigate through the list and update the status of each task.
• Provide a summary of changes before finalizing the gromit commit.

Configuration

• Add a feature flag in the Grit configuration file to enable or disable this feature.

Error Handling

• Handle cases where the pull request or associated tasks cannot be fetched.
• Provide informative error messages and fallback options if the interactive task management process fails.

Documentation

• Document the feature, including how to enable/disable it, how to use it, and its limitations.
• Provide examples and use cases in the documentation.

Testing

• Unit tests for the task fetching and status update logic.
• Integration tests to ensure the feature works seamlessly with the grit gromit command and reflects statuses correctly in pull requests and branches.

Future Considerations

• Integration with external project management tools for more comprehensive task management.
• Enhancements to the interactive interface for a smoother user experience.

By integrating task management directly into the grit gromit process, this feature aims to streamline the development workflow, making it easier for developers to manage tasks and commits in one place.

Grit Config

Spec Sheet for Grit Configuration File

Overview

The Grit configuration file is a crucial component of the Grit system, storing project-specific settings, author information, repository data, commit templates, and other configurations. This spec sheet outlines the structure, content, and purpose of the Grit configuration file.

Goals

• Define a clear and extensible structure for the Grit configuration file.
• Store essential project metadata, author information, and repository data.
• Provide customizable commit templates for Gromit, Grit's commit system.
• Include settings for future features and enhancements.

Non-Goals

• Overcomplicating the configuration file with too many settings.
• Making the configuration file backward incompatible with future versions of Grit.

Features

• TOML Format: The configuration file will be written in TOML format for readability and ease of use.
• Project Metadata: Store basic information about the project, such as name, description, initialization date, and version.
• Author Information: Save the local author's name, email, and the date when the author data was added.
• Repository Data: Include information about the Grit store, such as the path to the repository, current branch, last commit hash, and date of the last commit.
• Gromit Commit Templates: Define customizable templates for Gromit commits, including type, associated emoji, and description.
• Future Settings: Reserve space for future settings to ensure backward compatibility and ease of integration for new features.
• Linting and Validation: Ensure that the configuration file adheres to the defined structure and contains valid data.

Configuration File Structure

[project]
name = "example_project"
description = "An example Grit project"
init_date = "2023-11-01T12:00:00Z"
version = "0.1.0"

[author]
name = "John Doe"
email = "[email protected]"
date = "2023-11-01T12:00:00Z"

[store]
repository_path = "./.grit"
branch = "main"
last_commit_hash = "abc123"
last_commit_date = "2023-11-01T12:00:00Z"

[gromit]
default_template = "feature"
linting = true

[gromit.templates]
feature = '''
type = "feature"
emoji = "✨"
description = "A new feature for the user or a particular improvement to existing functionalities."
'''
bugfix = '''
type = "bugfix"
emoji = "🐛"
description = "A bug fix for the user."
'''
documentation = '''
type = "documentation"
emoji = "📚"
description = "Documentation related changes."
'''

[future_settings]
experimental_features = false
backup_on_init = true
auto_sync = false

Tasks

• Implement the configuration file parser.
• Define and document the structure of the configuration file.
• Implement validation and linting for the configuration file.
• Ensure backward compatibility and extensibility for future settings.
• Create unit tests to validate the configuration file's structure and content.
• Update the Grit documentation to include information about the configuration file.

Future Considerations

• Adding more templates and customization options for Gromit commit messages.
• Introducing project-specific settings that can override global Grit settings.
• Implementing a system for migrating old configuration files to new versions of Grit.

Documentation

• Provide detailed documentation on the structure and purpose of each section in the configuration file.
• Include examples of valid configuration files.
• Document how to customize Gromit commit templates and add new templates.

Testing

• Ensure comprehensive unit tests cover all aspects of the configuration file, including parsing, validation, and linting.
• Include integration tests to ensure the configuration file works seamlessly with other Grit components.

By following this spec sheet, we aim to create a robust and user-friendly configuration system for Grit, enhancing the user experience and providing a solid foundation for future developments.

Initialize Project

Spec Sheet for grit init Command

Overview

The grit init command initializes a new Grit project in the current directory or in a specified directory, creating the necessary configuration files and directory structure.

Goals

• Initialize a new Grit project with minimal setup.
• Create standard configuration files and directory structure.
• Align behavior with git init for familiarity.

Non-Goals

• Extensive configuration options during initialization.

Features

• Current Directory Initialization: By default, initialize the Grit project in the current working directory.
• Specified Directory Initialization: Allow users to specify a different directory for initialization.
• Interactive Mode: Prompt the user for necessary information if not provided through command-line options.
• Non-Interactive Mode: Support command-line arguments for all necessary information.
• Help Information: Provide detailed usage information with grit init --help.
• Author Information: Prompt for or accept command-line options for author information.
• Versioning: Initialize the project with a default version.

Command-Line Interface

• grit init: Initializes in the current directory.
• grit init <directory>: Initializes in the specified directory.
• grit init --name <project_name>: Specifies the project name.
• grit init --author <author_name>: Specifies the author name.
• grit init --email <author_email>: Specifies the author email.
• grit init --version <version>: Specifies the initial version (default to "0.1.0").
• grit init --help: Displays help information.

Interactive Prompts

• Project Name: If not provided via command-line.
• Author Name: If not provided via command-line.
• Author Email: If not provided via command-line.
• Initial Version: If not provided via command-line (default to "0.1.0").

Output

• Confirmation message with summary of actions taken.
• List of created files and directories.
• Next steps or tips for using Grit.

Error Handling

• Error if the directory already contains a Grit project.
• Error if insufficient permissions to create files/directories.
• Generic error message for any unexpected issues.

Documentation

• Clear documentation on grit init usage and examples.
• Explanation of default values and how to override them.

Testing

• Unit tests for different scenarios and command-line options.
• Integration tests for real-world usage validation.

Future Considerations

• Support for project templates.
• Option to specify a configuration file for initialization.

By focusing on aligning the behavior with git init and including author information and versioning in the initialization process, this updated spec sheet should provide a solid foundation for the grit init command.

Create Gromits

Spec Sheet for grit gromit Command

Overview

The grit gromit command is designed to capture a snapshot of the changes in the working directory, similar to git commit. This command will create a new "gromit" in the Grit project history.

Goals

• Provide a familiar and intuitive interface for users transitioning from Git.
• Ensure reliable and efficient capturing of project snapshots.
• Allow for detailed logging of changes with messages and metadata.

Non-Goals

• Introducing complex new features not present in git commit.

Features

• Commit Message: Allow users to provide a commit message describing the changes.
• Staging Area: Only commit changes that have been added to the staging area.
• Author Information: Automatically include author information in the gromit.
• Timestamp: Include the current date and time in the gromit.
• Unique Identifier: Generate a unique identifier (hash) for each gromit.

Command-Line Interface

• grit gromit: Commits the changes in the staging area with a generated message.
• grit gromit -m "message": Commits the changes with the specified message.
• grit gromit --amend: Amend the previous gromit with the current staging area changes.
• grit gromit --help: Displays help information about the grit gromit command.

Output

• Confirmation message indicating that the gromit has been successfully created.
• Summary of changes included in the gromit.
• Unique identifier (hash) of the new gromit.

Error Handling

• Error if there are no changes in the staging area.
• Error if no commit message is provided (unless using a default message).
• Generic error message for any unexpected issues.

Documentation

• Provide clear and concise documentation on how to use grit gromit, including examples.
• Document the differences and similarities between grit gromit and git commit.

Testing

• Unit tests to cover different gromit scenarios and command-line options.
• Integration tests to ensure that the command works as expected in a real-world scenario.

Future Considerations

• Interactive mode for building commit messages.
• Integration with external tools for commit message linting.

Head Canon

The term "gromit" is a playful nod to the beloved animated character Gromit from Wallace and Gromit. Just as Gromit is the reliable and silent partner who helps Wallace navigate through adventures and fixes mishaps, grit gromit aims to be the reliable tool that captures and safeguards the progress of your project. Additionally, the physical grommet is a device used to reinforce holes in fabric, providing stability and protection. Similarly, grit gromit reinforces the stability of your project by securely capturing snapshots of your progress, ensuring that nothing is lost and everything is held together securely.