open-index/open-npm huggingface dataset:
npm package: @irenleinades/gitupdater
Description: A tool to update multiple Git repositories at once
Author: José Ñeri
Latest version: 1.0.3

# GitUpdater

A command-line tool to update multiple Git repositories at once. GitUpdater finds all Git repositories in a directory and its subdirectories, then updates them using your credentials.

## Features

- 🔍 Automatically finds all Git repositories in a directory
- 🔐 Secure credential handling
- 🌐 Works on Windows, Linux, and macOS
- 🔄 Updates all repositories with a single command
- 🛡️ Cleans up credentials after use
- 📦 Optional automatic stashing of local changes with `--stashlocal`

## Installation

### Using npm (Recommended)

```bash
npm install -g @irenleinades/gitupdater
```

### Manual Installation

1. Clone the repository:
```bash
git clone https://github.com/irenleinades/gitupdater.git
cd gitupdater
```

2. Install dependencies:
```bash
npm install
```

3. Link the package:
```bash
npm link
```

## Usage

1. Navigate to a directory containing Git repositories:
```bash
cd /path/to/your/projects
```

2. Run the updater:

### Basic Usage
```bash
gitupdater
```

### With Automatic Stashing
```bash
gitupdater --stashlocal
```

3. Enter your Git credentials when prompted:
   - Username
   - Personal Access Token (PAT)

The tool will:
- Find all Git repositories in the current directory and subdirectories
- Update each repository using your credentials
- Show success/failure status for each repository
- Clean up credentials after use

### Command Line Options

- `--stashlocal`: Automatically stash local changes before pulling updates. This prevents conflicts with local modifications and ensures a clean update process.

## Windows Notes

If you encounter a PowerShell execution policy error, you can:

1. Run PowerShell as Administrator
2. Execute: `Set-ExecutionPolicy RemoteSigned`
3. Or run the tool using: `node $(which gitupdater)`

## Requirements

- Node.js (v14 or higher)
- Git
- npm (for installation)

## Security

- Credentials are only stored in memory during execution
- Temporary credential files are automatically cleaned up
- No credentials are stored permanently
- Uses secure password input (masked)

## License

MIT License - See [LICENSE](LICENSE) file for details

## Author

José Ñeri

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
npm package: @iresine/core
Description: @iresine/core is a library for normalize and notify about updates.
Latest version: 1.0.14

# @iresine/core

@iresine/core is a library for normalize and notify about updates.

99% of the time, you shouldn't use @ iresine/core directly. At the moment, I
recommend using @iresine/core with
[@iresine/react-query](https://github.com/utftufutukgyftryidytftuv/iresine/tree/master/packages/react-query)

## Install

```
npm i @iresine/core
```

## API

##### type Entity = any

Entity that has an identifier

##### types EntityId = string

for this entity

```js
{
  id: '0',
  type: 'user'
}
```

entityId is

```js
'user:0';

```

##### type Template = Array<Array<string, any>>

Array of arrays where the first value contains the path, and the second value
contains the value

```js
const iresine = new Iresine();
const data = {
  deep: {
    level: {
      0: 'hello',
    },
  },
};

const {template} = iresine.parse(data);

// templte now have structure
// [
//  [[], {}], first array is structure of base
//  [['deep', 'level', '0'], 'hello']
// ]
```

##### type Refs = Map<Array<string>, EntityId>

Map, there keys are paths to the place where the link to another entity is
located. Values are the identifier of the entity we are referring to.

```js
const iresine = new Iresine();
const data = {
  deep: {
    level: {
      0: {
        id: 0,
        type: 'comment',
      },
    },
  },
};

const {refs} = iresine.parse(data);

// refs now have structure
// new Map([
//  [['deep', 'level', '0'], 'user:0']
// ])
```

##### parse(entity: Entity): {template: Template, refs: Refs}

The main function that parses data and stores it in storage. Upon completion, it
notifies all required subscribers.

##### get(EntityId: EntityId): Entity

Get an entity by its identifier

```js
const iresine = new Iresine();
const user = {
  id: '0',
  user: 'user',
};

iresine.parse(user);
iresine.get('user:0') === user; // true
```

##### join(EntityId: EntityId): Entity

Get an entity by its identifier. Unlike .get() creates a new entity when called.
The new entity is stored in the store.

```js
const iresine = new Iresine();
const user = {
  id: '0',
  user: 'user',
};

iresine.parse(user);
iresine.get('user:0') === user; // false, but have same structure
```

##### joinRefs(template: Template, refs: Refs)

Concatenates values from template, substituting entities from refs

```js
const iresine = new Iresine();
const data = {
  deep: {
    level: {
      0: {
        id: 0,
        type: 'comment',
      },
    },
  },
};

const {template, refs} = iresine.parse(data);
const joined = iresine.joinRefs(template, refs);
joined === data; // false, but have same structure
```

##### subscribe(EntityIds: []EntityId, listener)

Subscribes to changes.

##### unsubscribe(EntityIds: []EntityId, listener)

Unsubscribes to changes.
npm package: @iresine/react-query
Description: @iresine/react-query is the layer between [@iresine/core](https://github.com/utftufutukgyftryidytftuv/iresine/tree/master/packages/core) and [react-query](https://github.com/tannerlinsley/react-query).
Latest version: 1.0.14

# @iresine/react-query

@iresine/react-query is the layer between
[@iresine/core](https://github.com/utftufutukgyftryidytftuv/iresine/tree/master/packages/core)
and [react-query](https://github.com/tannerlinsley/react-query).

@iresine/react-query must be used along with
[@iresine/core](https://github.com/utftufutukgyftryidytftuv/iresine/tree/master/packages/core).

## Install

```
npm i @iresine/react-query
```

## Example

```js
import IresineStore from '@iresine/core';
import IresineReactQuery from '@iresone/react-query';
import {QueryClient} from 'react-query';

const iresine = new Iresine();
const queryClient = new QueryClient();
new IresineReactQuery(iresineStore, queryClient);
```
npm package: @iresine/react-query-wrapper
Description: `@iresine/react-query-wrapper` is the layer between `@iresine/core` and `react-query`.
Latest version: 1.0.3

# @iresine/react-query-wrapper

`@iresine/react-query-wrapper` is the layer between `@iresine/core` and `react-query`.

## Install

```console
npm i @iresine/react-query-wrapper
```

## How use `@iresine/react-query-wrapper`?

`@iresine/react-query-wrapper` constructor waits instance of `@iresine/core` and instance `react-query` and then if the data has special fields for normalization, magic happens

### Example

```js
import IresineStore from 'packages/core/src/index';
import IresineReactQueryWrapper from '@iresone/react-query-wrapper';
import {QueryClient} from 'react-query';

const iresineStore = new IresineStore();
const queryClient = new QueryClient();
new IresineReactQueryWrapper(iresineStore, queryClient);
// now any updates in react-query will be consumbe by @iresine/core
```

if you now how `mobx` work, @iresine/core is like mobx and @iresone/react-query-wrapper like react-mobx
npm package: @iress/middy-http-path-router
Description: Routing middleware for Middy that provides path parameters in the event.
Author: Rodney Marsh
Latest version: 0.2.0

# iress-middy-http-path-router
`@iress/middy-http-path-router` is middleware for [Middy](https://middy.js.org/) 
that routes API Gateway events to handlers based on static and dynamic paths.
For dynamic paths it will include the parameters within the `event.pathParameters`.

## Install
```shell
npm install @iress/middy-http-path-router
# or
yarn add @iress/middy-http-path-router
```

## Usage
```typescript
import { httpPathRouteHandler, Route } from '@iress/middy-http-path-router';

const routes: Route[] = [{
  method: 'GET',
  path: '/api/hello/:name',
  handler: (event: APIGatewayProxyEvent): APIGatewayProxyResult => {
    return {
      statusCode: 200,
      body: event.pathParameters?.name ?? 'anonymous'
    }
  }
}];

const handler = middy()
  .handler(httpPathRouteHandler(routes));
```

## More about routing
The responsibility for recognising routes and parameters is handled by 
[route-recognizer](https://github.com/tildeio/route-recognizer).