semvec/pypi-packages huggingface dataset:
dotprompt-cli 0.0.4
Generate files from AI prompts
License: MIT
Requires Python: <4.0,>=3.8

# DotPrompt

DotPrompt is a revolutionary approach to programming that explores the idea of code being 100% produced by AI, with humans only editing the prompts used to generate the code. This project, authored by Dmitry Degtyarev, introduces a new paradigm in software development where the source code is generated from ".prompt" files.

## Overview

In traditional programming, code is built through a series of iterations, either by humans or AI. The resulting code doesn't reveal which prompts were used to build it, making it difficult to alter these prompts later. DotPrompt addresses this limitation by introducing a system where:

1. Code is entirely produced by AI.
2. Humans focus on editing the prompts used by AI to generate the code.
3. ".prompt" files contain the prompts used to produce actual code files.
4. A simple script executes these .prompt files to build the code.

## Key Features

- **Self-generation**: The builder script itself can be generated from a .prompt file, allowing the generator to generate itself.
- **Multi-level abstraction**: .prompt files can be built from other .prompt files, enabling higher-level idea representation.
- **Reverse engineering**: Potential for reverse engineering prompt files from existing source code.

## Future Enhancements

- Ability to produce multiple files from a single prompt (e.g., code and unit tests).
- Automated error correction based on unit test results and error messages.

## Installation

To install DotPrompt, use the following pip command:

```
pip3 install dotprompt-cli
```

## Usage

The DotPrompt CLI supports the following parameters:

```
Usage: dotprompt [OPTIONS] INPUT_FILE

  CLI application to process prompt files and generate code.

  This application takes a prompt file stored in the local filesystem and produces a raw code file,
  stored along with the prompt. The prompt files have a ".prompt" suffix.

Options:
  --recursive      Process included files recursively
  --from-scratch   Generate code from scratch, ignoring existing output file
  --provider TEXT  LLM provider (bedrock or anthropic)
  --model TEXT     LLM model to use
  --help           Show this message and exit.
```

### Parameters

- `INPUT_FILE`: Path to the input .prompt file (required)
- `--recursive`: Flag to recursively process included files
- `--from-scratch`: Flag to generate code from scratch, ignoring existing output file
- `--provider`: LLM provider (bedrock or anthropic, default is 'bedrock')
- `--model`: LLM model to use (default is 'anthropic.claude-3-5-sonnet-20240620-v1:0')

## License

This project is licensed under the MIT License.

## Contact

For more information or to get in touch with the author, visit [https://twitter.com/Mitek99](https://twitter.com/Mitek99).
yacs-cli 0.1.0
Run a local credential store.
License: MIT
Requires Python: >3.7
Keywords: cli, developer tools, productivity, tools, secretsmanager

# yacs
Yet another credential store 🔐

`yacs`is a command-line tool that allows you to securely store, manage, and retrieve secrets locally in an encrypted JSON file. This tool uses AES encryption with a master password to ensure your secrets are kept safe.

## Features

Initialization: Set up a new credential store with a master password and a hint.
Adding Secrets: Add secrets with descriptions, supporting both string and binary types.
Retrieving Secrets: Retrieve secrets by their key.
Viewing Keys and Descriptions: List all keys and their descriptions.
Resetting: Delete the credential store and start from scratch.


## Encryption and Decryption

`yacs` securely encrypts and decrypts your secrets using AES encryption with a key derived from your master password. When you initialize the credential store, a strong encryption key is generated from your master password using PBKDF2 (Password-Based Key Derivation Function 2) with a unique salt. This key, combined with a randomly generated Initialization Vector (IV), encrypts your secrets, ensuring each encryption is unique and secure. The encrypted data is then encoded in base64 format for safe storage. For added security, the tool prompts you to re-enter your master password after initialization to verify that the data can be successfully decrypted, ensuring the integrity and accessibility of your secrets.

## Security
The Local Secrets Manager uses AES encryption with a key derived from your master password using PBKDF2 (Password-Based Key Derivation Function 2) with a unique salt. This ensures that your secrets are securely encrypted and can only be decrypted with the correct master password.


## Usage
Install the command line interface via the cli.

    ```
    pip install yacs-cli
    ```

After installing you should be able to see the below when you run `yacs`.
    ```
    @raiyanyahya ➜ /workspaces/yacs (master) $ yacs
    Usage: yacs [OPTIONS] COMMAND [ARGS]...

    A cli to provision and manage local developer environments.

    Options:
    --version  Show the version and exit.
    --help     Show this message and exit.

    Commands:
    get    Get a secret from the credential store.
    init   Initialize an empty local credstore.
    put    Add a secret to the credential store.
    reset  Delete the credstore and start from scratch.
    view   View all keys and their descriptions.
    ```
### Initialize the store

    ```
    yacs init
    ```

### Add a secret

    ```
    yacs put /mykey "description" mysecretstring
    ```

### Get a secret

    ```
    yacs get /mykey
    ```
### View all keyand descriptions

    ```
    yacs view
    ```

## License
This project is licensed under the MIT License. See the LICENSE file for details.

## Contributing
Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.