open-index/open-npm huggingface dataset:
npm package: @fnet/gitlab-push-existing-folder
Description: The primary purpose of the @fnet/gitlab-push-existing-folder project is to automate the process of initializing a Git repository within an existing directory, setting up the correct remote URL, and pushing the initial commit. The source code contains func
Latest version: 0.2.4

# @fnet/gitlab-push-existing-folder

The primary purpose of the @fnet/gitlab-push-existing-folder project is to automate the process of initializing a Git repository within an existing directory, setting up the correct remote URL, and pushing the initial commit. The source code contains functionality for reading and parsing YAML files, executing shell commands, and interactive prompts for user confirmation.

## Main Functionality

The main function in this project is an asynchronous function named `index` which takes an object parameter `args`. This object could contain `repo_url`, a string indicating the repository URL; and `verbose`, a boolean value used to control the level of detail in command output.

### Initializing Git Repository and Committing

If the existing directory is not a Git repository, this software will initialize it as one. After that, it adds the repository as the remote origin and makes an initial commit. All these operations occur only after the user confirms their intent through an interactive prompt.

### Existing Git Repositories

In cases where the directory is already a Git repository, the software checks for and handles three specific scenarios:

1. **Same Remote URL:** If the existing remote URL is the same as the supplied one, the software lets the user know that the repository is already initialized with the same URL.
2. **Different Remote URL:** If the repository has a different remote URL than the provided one, the user is asked whether they want to update the remote URL to the new one.
3. **No Remote URL:** If the repository has no remote origin, the software prompts the user to confirm if they want to add the provided repository URL as the remote origin.

There are also several helper functions for running shell commands, verifying if the directory is a Git repository, retrieving the current remote URL, and loading and parsing a YAML file. 

## Error Handling

The software continuously checks whether each operation is successful. If a function fails, the software throws an error and halts its operation, ensuring that the user is always informed of any issues during setup. In every case, the user has the power to cancel any operation if they choose, making this tool robust and flexible in managing Git repositories. 

This project makes setting up and maintaining Git repositories easier and more straightforward, particularly in automated environments or for users unfamiliar with Git.
npm package: @fnet/load-script-url
Description: The "@flownet/lib-load-browser-script-url" project is essentially a JavaScript library aimed to dynamically load external scripts into a browser environment.
Latest version: 0.2.3

# @flownet/lib-load-browser-script-url

The "@flownet/lib-load-browser-script-url" project is essentially a JavaScript library aimed to dynamically load external scripts into a browser environment. 

This piece of code provides a mechanism for loading and managing JavaScript resources in an HTML-based application dynamically. It generates a promise-based function, which allows asynchronous handling and offers a pipeline for error or success events.

## Functionality

### Dynamic Script Loading
The essence of this project's functionality is the ability to **dynamically load a script from a provided URL**. This might be useful in cases where applications might need to load scripts based on certain actions or conditions that arise during the runtime.

### Script Tag Management
Another central aspect is the **script tag management** functionality. The function checks whether a script with a given ID already exists in a document and creates a new script tag if it doesn't. This efficiently avoids unnecessary duplications of the same script.

### Error Handling
The script also includes **robust error handling** capabilities. It validates the input parameters and provides user-friendly error messages if invalid inputs are given. Also, it listens for error events that occur while loading the script. If such an event occurs, the function rejects the promise with the reason for the error.

### Event Handling
The project has built-in event handling abilities. When a script is successfully loaded, an 'onload' event is dispatched, and the promise is resolved. The original 'onload' event is retained and fired alongside the newly attached event. 

### Script Tag Attribute Management
The function also facilitates **script tag attribute management**, allowing the end-user to determine whether the script should be executed asynchronously with the 'async' attribute or deferred until the page has finished parsing with the 'defer' attribute. It also allows the addition of arbitrary attributes to the script tag. 

### Script Source Assignment & Append
After all the setup, the function then assigns the script source and appends the script tag to the document head. This allows the browser to load and execute the script in the context of the currently loaded document.
npm package: @fnet/location-js
Description: The Opus-Location codebase is a significant convergence of scripts aiming to handle intensive website and page navigation tracking. The main purpose of these scripts is to gather and process critical window-specific data related to the current website's s
Latest version: 0.1.1

# Opus-Location

The Opus-Location codebase is a significant convergence of scripts aiming to handle intensive website and page navigation tracking. The main purpose of these scripts is to gather and process critical window-specific data related to the current website's structure and URL chain hierarchy. 

## Core Functionality

Primarily, this project calculates a page's depth within a website and its top domain. Understanding a site's structure and the depth of an individual page within that structure could provide valuable insights on a website's user flow, site navigation, bounce rate, and more.

### Page Depth Calculation

**The getPageDepth function** is crucial in identifying the site hierarchy by tallying the number of parent windows to the current window. This acts like a counter that increments every time it locates a parent window until it reaches the top of the site hierarchy. It handles potential errors, such as possible security breaches, by returning the depth value reached before the error occurred.

### Top Domain Discovery

The logic also includes a comprehensive mechanism to identify the top domain, particularly focusing on the parent page or the origin of an iframe. **This is significant in managing iframes, nested pages, and multiple domain intricacies**. It extensively uses different methods such as:

- **tryAncestorOrigins:** Fetches the topmost domain from the ancestorOrigins object if it exists.
- **tryZeroDepthLocation:** Utilizes the window's location host name if the window is at depth level zero.
- **tryFirstDepthDocumentReferrer:** Identifying the topmost domain from the document's referrer information provided the depth is one.
- **tryHighestAccessibleLocation:** Commences checking the depth of each window until the topmost window to get the hostname.
 
If after all these attempts, the top domain is still not determined, an error message stating "Unable to determine top domain" is returned.

In conclusion, the Opus-Location code set is a smart navigator which actively measures, analyzes, and catches errors efficiently, while working with complicated website structures and URL chains. It is a vital tool for intensive web navigation, event tracking, and data logging purposes.
npm package: @fnet/pick-version
Description: The **@fnet/pick-version** project focuses on offering a versatile and efficient solution for scanning a given set of software versions, finding matches based on a specified version pattern, and selecting the most recent version that aligns with the given
Latest version: 0.1.3

# @fnet/pick-version

The **@fnet/pick-version** project focuses on offering a versatile and efficient solution for scanning a given set of software versions, finding matches based on a specified version pattern, and selecting the most recent version that aligns with the given pattern.

## Key Features 

1. **Selection of Most Recent Version**: By providing a list of versions and an optional pattern, the project's central functionality allows it to sift through all the available versions and pick the most recent version that fits the supplied pattern. In the absence of a pattern, it selects the latest available version from the list.

2. **Pattern Matching**: This application utilizes the power of SemVer versioning to match the given pattern effectively. The user can provide version constraints like '^1.0.0' or '~2.1.2' to finely filter the versions. 

3. **Error Handling**: In situations where incorrect inputs are supplied, the project is designed to return specific, understandable error messages. This might occur when the versions are not provided in an array of strings format or if the provided pattern is not a string.

4. **Sorting and Filtering**: It performs sort and filter operations on the versions list to ensure the end result is always the most recent matching version, it still provides a response (null) even when no matching versions are found.

In summary, @fnet/pick-version is a user-focused project, designed to help end-users effectively sift through versions, according to specific patterns with the resulting output being the latest version matching the pattern or null if no matches are found.
npm package: @fnet/print
Description: The "@fnet/print" project provides a means for users to output or log processed arguments, mainly strings and objects, to the console of a JavaScript application. It utilizes the `chalk` module to color the output for better readability and differentiatio
Latest version: 0.1.7

# @fnet/print

The "@fnet/print" project provides a means for users to output or log processed arguments, mainly strings and objects, to the console of a JavaScript application. It utilizes the `chalk` module to color the output for better readability and differentiation. The code is highly versatile, able to handle various types of data input, thus making it a useful tool in any debugging or testing environment.

## Significant Features

The primary function of this code serves to output processed arguments to the system console, with a key focus on string and object datatypes. It offers the following vital features:

### Argument Processing
The module processes the inputs or arguments (can be a single argument or an array of arguments) intelligently before logging them. This processing includes handling different data types: strings are logged directly, objects are analyzed for properties for color-coding, and all other types are converted into strings.

### Color Coding with Chalk
One very salient feature of this module is its incorporation of the `chalk` module from Node.js to color code outputs. If an object has a property that starts with a dot, the code assumes the rest of that property's name to be a color code from the `chalk` module. It then applies that color to the string value of the property before outputting it to the console. This feature makes it easier for end users to differentiate between different segments of the output.

### Versatility
This module can handle any arbitrary or unexpected data types without breaking. In situations where the input is neither a string nor an object, or when it doesn't know how to color the object, it has a default behavior to safely convert the input into a string and print it out as-is, or leave the object's color unaltered. This ensures the reliability and robustness of the module across different situations. 

In summary, the "@fnet/print" project is intended to provide a reliable, flexible, and aesthetic solution for logging information to the console in JavaScript applications. Its elegant treatment of different data types and incorporation of `chalk` for color-coded output differentiate it from a standard console.log function.
npm package: @fnet/react-app
Description: The `@fnet/react-app` project is a simple and straightforward React component designed to help you manage and display dynamic forms within a web application. By facilitating easy integration of visual elements like forms and backgrounds, this tool streaml
Latest version: 0.1.21

# @fnet/react-app

The `@fnet/react-app` project is a simple and straightforward React component designed to help you manage and display dynamic forms within a web application. By facilitating easy integration of visual elements like forms and backgrounds, this tool streamlines the process of building interactive user interfaces.

## How It Works

At its core, the project provides a mechanism to render and manage a form-based interface dynamically. When initialized, it sets up essential styles and resources, such as fonts and icons, needed for a consistent and polished user experience. The dynamically changing forms are supported by React's state management to ensure any update to the forms is efficiently reflected in the UI.

## Key Features

- **Dynamic Form Management**: Easily switch between different active forms, which will dynamically render based on the application's requirements.
  
- **Styling Support**: Automatically integrates popular fonts and icon sets to provide a visually appealing interface.

- **Customizable Appearance**: Allows setting background images and colors to align with your application's design needs.

- **Resource Cleanup**: Provides methods to clean up allocated resources and various UI elements when they are no longer needed.

## Conclusion

`@fnet/react-app` is a practical utility for developers looking to manage dynamic forms within their React apps. By handling forms and visual elements effectively, it allows for a streamlined, organized approach to user interface development.
npm package: @fnet/react-layout-asya
Description: The **@fnet/react-layout-asya** library provides a straightforward solution for managing responsive layout components in your React applications. The library focuses on handling the layout's adaptability based on window size changes, making it easier to c
Latest version: 0.1.20

# @fnet/react-layout-asya

The **@fnet/react-layout-asya** library provides a straightforward solution for managing responsive layout components in your React applications. The library focuses on handling the layout's adaptability based on window size changes, making it easier to create user interfaces that are responsive and visually organized across different devices.

## How It Works

The library uses a custom hook called `useLayout` that calculates and adjusts the layout parameters such as width, height, and aspect ratio of a reference container. It then determines and sets the layout type as horizontal, vertical, or square, based on the proportions. This automatically optimizes the position and size of the elements within the layout, such as titles, descriptions, progress bars, and customizable controls.

## Key Features

- **Dynamic Resizing**: Automatically adjusts layout properties when the window size changes, ensuring your interface always looks well organized.
- **Structured Layout**: Divides the layout into several key sections (title, description, progress, content, and controls) with customizable alignment and positioning.
- **Customization Options**: Offers flexibility with properties like `contentAlignSelf`, `contentFlexGrow`, `containerJustifyContent`, and more, allowing for a high level of customization.
- **Responsive Design**: Supports different layout types (horizontal, vertical, square) depending on the viewport's aspect ratio, enabling a responsive design approach.

## Conclusion

The **@fnet/react-layout-asya** library is a useful tool for developers needing a simple yet effective method to handle responsive layouts in React applications. It provides customizable and adaptive interface components that adjust effortlessly to varying display sizes, enhancing user experience without requiring extensive manual adjustments.
npm package: @fnet/react-layout-router-tabs-16
Description: This project provides a simple way to manage navigation in a React web application using tabs. It is particularly helpful for developers who wish to implement a tab-based navigation structure, offering a clear and intuitive interface for users to switch b
Latest version: 0.2.5

# @fnet/react-layout-router-tabs-16

This project provides a simple way to manage navigation in a React web application using tabs. It is particularly helpful for developers who wish to implement a tab-based navigation structure, offering a clear and intuitive interface for users to switch between different views within a single page application.

## How It Works

The project utilizes key components from React and other libraries to offer tab-based routing. Using `HashRouter`, it listens for route changes and updates the currently active tab accordingly. If no specific tab is selected, it defaults to the first child tab in the arrangement. This makes navigation seamless by displaying different components based on the selected tab, without needing full-page reloads.

## Key Features

- **Tab-Based Navigation**: Allows users to switch between different sections of your app using tabs.
- **Auto-routing**: Default routing to the first tab if no path is specified, ensuring smooth user experience.
- **Integrated with React Router**: Utilizes `react-router-dom` for handling routes, making it easy to integrate with existing React applications.
- **Customizable**: Easily customize the tabs as per your application requirements.

## Conclusion

This project provides an efficient solution for implementing tab-based navigation within React applications. Its ability to handle routes seamlessly through tabs enhances user experience by making navigation intuitive and straightforward.
npm package: @fnet/shader-toy-in-space
Description: The `@fnet/shader-toy-in-space` project is a computer graphics creation aiming at generating an animated visual representation of space, providing users with a realistic and immersive viewing experience. It uses the GLSL (OpenGL Shading Language) to compi
Latest version: 0.1.6

# @fnet/shader-toy-in-space

The `@fnet/shader-toy-in-space` project is a computer graphics creation aiming at generating an animated visual representation of space, providing users with a realistic and immersive viewing experience. It uses the GLSL (OpenGL Shading Language) to compile and execute high-performance graphics rendering.

## Functionality

The code is divided into two parts. The first part declares the `fshader`, a fragment shader which describes the rules for rendering space and establishes how the pixels' colors should be computed. It uses complex mathematical computations, noise generation, rotations, and transformations to generate the celestial animations. This includes stars, galaxies, and other space phenomena. The shader achieves this with techniques such as Perlin Noise for procedural texture generation, polar coordinate system transformations, and computations for color variations based on time. The code also accounts for the differentiated visual effects to manipulate color intensities and transparency levels.

The second part of the code is the `index` function which utilizes the ShaderToy library. This function wraps around the fragment shader and offers additional settings, such as the canvas's background color and enabling statistics. It initiates the rendering of the space imagery on a canvas using the WebGL API, bringing the space animation to life.

**Importantly**, the visualization adapts to the canvas size, making the created graphic responsive and mobile-friendly. Users can explore the fascinating, visual experience of travelling through space, right from their devices.

The generated space visualization can be used for various purposes, including creating video backgrounds, real-time screen savers, live wallpapers, or enhancing the UI/UX design of an application or a website with a vibrant and dynamic display of space voyage. The performance statistics enabled by the ShaderToy library can assist developers in diagnosing or optimizing rendering performance on different devices.

In conclusion, `@fnet/shader-toy-in-space` serves as a sophisticated implementation of computer graphics, providing an appealing, realistic, and responsive representation of the cosmos.
npm package: @fnet/xcode-provision-inspector
Description: The project @fnet/xcode-provision-inspector is designed to **inspectand manage provisioning profiles installed in an Xcode development environment**. Primarily, the system interacts with the provisioning profiles located in the user's library within their
Latest version: 0.1.6

# @fnet/xcode-provision-inspector

The project @fnet/xcode-provision-inspector is designed to **inspectand manage provisioning profiles installed in an Xcode development environment**. Primarily, the system interacts with the provisioning profiles located in the user's library within their MobileDevice/Provisioning Profiles directory.

## Functionality

The software retrieves all installed provisioning profiles, listing the files within the aforementioned directory and then parsing the contents of each file. Key details of each provisioning profile are extracted, such as the profile's UUID, app ID name, team name, and identifier. The provisioning profile's creation date and expiration date are also noted, with the system able to determine whether a given profile is expired or not.

Moreover, the code handles developer certificates enclosed in provisioning profiles. It's capable of **extracting, decoding, and detailing developer certificates** within those profiles. Specific certificate details that are parsed include the subject, issuer, and validity period. 

The end-result of these processes is that the user is provided an array of objects, each representing a provisioning profile with its associated details and status information.

## Error Handling

A suited error handling setup is in place to assure user experience, as the system will throw an error with a specific message whenever a failure occurs, such as when there's an issue retrieving or parsing the provisioning profiles.

## Importance

This project offers a crucial utility for developers who frequently work with Xcode and provision iOS applications. It enables a streamlined process to **manage and review the status of the provisioning profiles and development certificates**, which are vital for a correct app administration, deployment, and distribution.
npm package: @fnlb-project/fnbr
Description: A library to interact with Epic Games' Fortnite HTTP and XMPP services
Author: This Nils
Latest version: 4.1.102

<a href="https://fnbr.js.org"><img align="left" src="https://fnbr.js.org/static/logo-square.png" height=128 width=128 /></a>

[![CI Status](https://github.com/fnbrjs/fnbr.js/actions/workflows/ci.yml/badge.svg)](https://github.com/fnbrjs/fnbr.js/actions/workflows/ci.yml)
[![NPM Version](https://img.shields.io/npm/v/fnbr.svg)](https://npmjs.com/package/fnbr)
[![NPM Downloads](https://img.shields.io/npm/dm/fnbr.svg)](https://npmjs.com/package/fnbr)
[![MIT License](https://img.shields.io/npm/l/fnbr.svg)](https://github.com/fnbrjs/fnbr.js/blob/master/LICENSE)
[![Discord Server](https://discord.com/api/guilds/522121965952303105/widget.png)](https://discord.gg/j5xZ54RJvR)

An object-oriented, stable, fast and actively maintained library to interact with Epic Games' Fortnite HTTP and XMPP services. Inspired by [discord.js](https://github.com/discordjs/discord.js), [fortnitepy](https://github.com/Terbau/fortnitepy) and [epicgames-fortnite-client](https://github.com/SzymonLisowiec/node-epicgames-fortnite-client).

<br />
<hr />

<h2>Installation</h2>

```
npm install fnbr
```

<h2>Usage example</h2>
 
```javascript
const { Client } = require('fnbr');

const client = new Client();

client.on('friend:message', (message) => {
  console.log(`Message from ${message.author.displayName}: ${message.content}`);
  if (message.content.toLowerCase().startsWith('ping')) {
    message.reply('Pong!');
  }
});

client.on('ready', () => {
  console.log(`Logged in as ${client.user.self.displayName}`);
});

client.login();
```

<h2>Links</h2>

- [NPM](https://npmjs.com/package/fnbr)
- [Docs](https://fnbr.js.org)
- [Discord](https://discord.gg/j5xZ54RJvR)

<h2>License</h2>
MIT License

Copyright (c) 2020-2025 Nils S.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @fnndk/parallax-vue
Description: A Vue.js wrapper for Parallax.js
Author: Fernando Resende Klumpp
Latest version: 1.0.0

# parallax-vue

> A Vue.js wrapper for Parallax.js

## Install

``` bash
# install package
npm install https://github.com/FnnDK/parallax-vue --save

# Register the component

import Vue from 'vue'
import Parallax from 'parallax-vue'
Vue.component('parallax', Parallax)

# In HTML
<parallax>
	<img data-depth="0.4" src="bg.png"/>
	<img data-depth="0.2" src="secondElement.png"/>
	<img data-depth="0.1" src="firstElement.png"/>
</parallax>

```
npm package: @fnndsc/chrisapi
Description: JavaScript6 client for the ChRIS API
Latest version: 1.23.1

# ChRIS API
[![Build Status](https://app.travis-ci.com/FNNDSC/fnndsc.svg?branch=master)](https://app.travis-ci.com/FNNDSC/fnndsc)

JavaScript 6 client for the ChRIS API.

## Installation

``` bash
npm i @fnndsc/chrisapi
```

## API Documentation

If you have a ChRIS server up and running (eg. as explained below) then you can test the API in your Javascript code.

For more information visit the [API documentation](https://fnndsc.github.io/fnndsc/chrisdoc/index.html)


## Development and testing

### ChRIS server preconditions

These preconditions are only necessary to be able to test the client against an actual
instance of a ChRIS server both during development and for the automated tests.

#### Install latest Docker

Currently tested platforms:
* ``Docker Engine v25.0.0+``

#### On a Linux machine make sure to add your computer user to the ``docker group``


#### Install latest [`just`](https://just.systems) command runner.


#### Fire up the full set of ChRIS services:

Open a terminal and run the following commands in any working directory:

``` bash
$> git clone https://github.com/FNNDSC/ChRIS_ultron_backEnd.git
$> cd ChRIS_ultron_backEnd
$> just
```

Check that all the services are up:

``` bash
$> docker ps -a
```

#### Create test data:

Run the following shell script on the directory of this README file.
NOTE: The script depends on the popular `curl` and `jq` command line tools.

```bash
$> ./pre_test.sh
```

#### Tear down the full set of ChRIS services:

You can later remove all the backend containers and release storage volumes with:

```bash
$ cd ChRIS_ultron_backEnd
$ just nuke
```

### JavaScript package manager prerequisite

* yarn

Open a terminal in the directory of this README file

### Commands

Install dependencies

``` bash
$> yarn install
```

Start tests in watch mode (used for developing)

``` bash
$> yarn start
```

Start test in single run mode (used by `Travis CI`)

``` bash
$> yarn test
```

Compile library to standalone bundle

``` bash
$> yarn build
```

Generate source code documentation

``` bash
$> yarn docs
```
npm package: @fnnm/pi-iflow-connector
Description: iFlow.cn provider extension for pi-coding-agent
Author: Fnnm
Latest version: 1.0.2

# iFlow Provider Connector

iFlow.cn provider connector for pi-coding-agent.

## Features

- OAuth2 authentication with PKCE via iflow CLI
- 6 official iFlow models:
  - qwen3-coder-plus
  - qwen3-235b
  - deepseek-v3.2
  - deepseek-v3
  - kimi-k2
  - glm-4.6
- Free access to all models
- 128,000 token context window

## Installation

### Global Installation

```bash
npm install -g @fnnm/pi-iflow-connector
```

### Local Installation

```bash
npm install @fnnm/pi-iflow-connector
```

### Manual Installation

Clone this repository and link it:

```bash
git clone https://github.com/elsin/pi-iflow-connector.git
npm run build 
npm run postinstall
pi -e .
```

## Usage

### Using iflow CLI Credentials

1. Install iflow CLI and login:

```bash
npm install -g iflow-cli
iflow login
```

2. Start pi with connector:

```bash
pi -e ./packages/iflow-extension
```

3. Login to iFlow:

```bash
/login iflow
```

4. Use iFlow models:

```bash
pi -m iflow/qwen3-coder-plus
```

### Using API Key

Set `IFLOW_API_KEY` environment variable:

```bash
export IFLOW_API_KEY=your-api-key
pi -m iflow/qwen3-coder-plus
```

## Models

| Model ID | Name | Context Window | Max Tokens |
|----------|------|----------------|------------|
| qwen3-coder-plus | Qwen3 Coder Plus | 128,000 | 65,536 |
| qwen3-235b | Qwen3 235B | 128,000 | 65,536 |
| deepseek-v3.2 | DeepSeek V3.2 | 128,000 | 65,536 |
| deepseek-v3 | DeepSeek V3 | 128,000 | 65,536 |
| kimi-k2 | Kimi K2 | 128,000 | 65,536 |
| glm-4.6 | GLM 4.6 | 128,000 | 65,536 |

## Authentication

### OAuth2 with iflow CLI

The extension uses OAuth2 authentication via iflow CLI:

1. Run `iflow login` to authenticate with iFlow
2. The extension reads credentials from `~/.iflow/oauth_creds.json`
3. The extension uses the access token directly as the API key
4. Tokens are automatically refreshed when expired via the OAuth refresh flow

### API Key

Alternatively, you can set `IFLOW_API_KEY` environment variable:

```bash
export IFLOW_API_KEY=your-api-key
```

## Development

### Build

```bash
npm run build
```

### Watch Mode

```bash
npm run dev
```

### Test

```bash
npm test
```

### Type Check

```bash
npm run check
```

## Troubleshooting

### "No iflow CLI credentials found"

Make sure you have run `iflow login` and that `~/.iflow/oauth_creds.json` exists.

### "Failed to fetch user info"

Check your internet connection and ensure iflow CLI credentials are valid.

### "No API key found in user info response"

Your iflow account may not have API access. Contact iFlow support.

## License

MIT

## Support

- GitHub Issues: https://github.com/badlogic/pi-mono/issues
- iFlow Documentation: https://iflow.cn
npm package: @fnnm/pi-raw-paste
Description: One-shot raw paste support for Pi (/paste).
Author: fnnm
Latest version: 0.1.2

# Raw Paste Extension

/paste to arm a one-shot raw paste so large clipboard content stays fully editable in the editor (no paste markers).
Useful for template prompts that need slight edits or when you need to refer to the text you pasted.

## Without /paste -> the text is condensed
<img width="1487" height="104" alt="Screenshot 2026-01-09 at 17 38 31" src="https://github.com/user-attachments/assets/d6a0793e-3ef3-4c3b-83c8-f6ca10f0db51" />

## With /paste -> you can see raw text
<img width="1487" height="387" alt="Screenshot 2026-01-09 at 17 39 35" src="https://github.com/user-attachments/assets/292c059a-8b06-40c2-abdd-795c0699336a" />


## Install

```bash
pi install npm:@fnnm/pi-raw-paste
```

```bash
pi install git:github.com/fnnm/pi-raw-paste
```

Then filter to just this extension in `~/.pi/agent/settings.json`:

```json
{
  "packages": [
    {
      "source": "git:github.com/fnnm/pi-raw-paste",
      "extensions": ["raw-paste/index.ts"]
    }
  ]
}
```

## Usage

- Command: `/paste`
- No default keybinding

After arming, paste normally (for example `Cmd+V` on macOS).

Optional: add your own keybinding in `raw-paste/index.ts` if your terminal supports it.

## Notes

- Terminal.app and Warp intercept `Cmd+V` and `Cmd+Shift+V`, so the extension cannot see those keys.
- Use `/paste` before pasting in those terminals.

## Changelog

See `CHANGELOG.md`.
npm package: @fnnm/pi-session-breakdown
Description: Interactive TUI for Pi session analysis (usage, cost, models).
Author: fnnm
Latest version: 0.1.0

# Session Breakdown Extension

Interactive TUI that analyzes `~/.pi/agent/sessions` and shows usage over last 7/30/90 days: sessions, messages, tokens, cost by model.
Includes a GitHub-contributions-style calendar graph.

## Install

```bash
pi install npm:@fnnm/pi-session-breakdown
```

```bash
pi install git:github.com/fnnm/pi-session-breakdown
```

## Usage

- Command: `/session-breakdown`
- No default keybinding

Run the command to open the interactive TUI. Use arrow keys to navigate ranges and measurement modes.

## Credits

Forked from: [mitsuhiko/agent-stuff](https://github.com/mitsuhiko/agent-stuff/blob/main/pi-extensions/session-breakdown.ts)
Original author: Armin Ronacher (mitsuhiko)

## License

MIT
npm package: @fnobi/axis-psd
Description: export psd data positions.
Author: Fujisawa Shin
Latest version: 1.0.2-0

axis-psd
==============

export psd data positions.

## install

### from npm

```
npm install axis-psd
```

### from github

```
git clone git://github.com/fnobi/axis-psd.git
```

## usage

### export with format

```
$ axis-psd sample.psd
[{"name":"baloon2-1.png","width":289,"height":313,"top":841,"left":439,"right":728,"bottom":1154},{"name":"baloon1-2.png","width":314,"height":337,"top":378,"left":418,"right":732,"bottom":715},{"name":"koma2.png","width":718,"height":428,"top":625,"left":4,"right":722,"bottom":1053},{"name":"koma1.png","width":693,"height":478,"top":119,"left":28,"right":721,"bottom":597}]
```

```
$ axis-psd --format css sample.psd
.layer[data-layer="koma1"] {
    left: 28px;
    top: 119px;
    width: 693px;
    height: 478px;
    background-image: url("koma1.png");
}
.layer[data-layer="koma2"] {
    left: 4px;
    top: 625px;
    width: 718px;
    height: 428px;
    background-image: url("koma2.png");
}
.layer[data-layer="baloon1-2"] {
    left: 418px;
    top: 378px;
    width: 314px;
    height: 337px;
    background-image: url("baloon1-2.png");
}
.layer[data-layer="baloon2-1"] {
    left: 439px;
    top: 841px;
    width: 289px;
    height: 313px;
    background-image: url("baloon2-1.png");
}
```

```
$ axis-psd --format pug sample.psd
.layer(data-layer="koma1")
.layer(data-layer="koma2")
.layer(data-layer="baloon1-2")
.layer(data-layer="baloon2-1")
```

### customize for css

```
$ axis-psd --ratio 0.5 --format css --image-dir assets/ --sass-image-function image-url --base-selector '&'
&[data-layer="koma1"] {
    left: 14px;
    top: 59.5px;
    width: 346.5px;
    height: 239px;
    background-image: image-url("assets/koma1.png");
}
&[data-layer="koma2"] {
    left: 2px;
    top: 312.5px;
    width: 359px;
    height: 214px;
    background-image: image-url("assets/koma2.png");
}
&[data-layer="baloon1-2"] {
    left: 209px;
    top: 189px;
    width: 157px;
    height: 168.5px;
    background-image: image-url("assets/baloon1-2.png");
}
&[data-layer="baloon2-1"] {
    left: 219.5px;
    top: 420.5px;
    width: 144.5px;
    height: 156.5px;
    background-image: image-url("assets/baloon2-1.png");
}
```
npm package: @fnpen/effector-devtools
Description: Devtools for Effector
Latest version: 0.4.0

# @fnpen/effector-devtools - Effector DevTools

![Demo](https://user-images.githubusercontent.com/31767378/211662670-8ebd091b-1773-4b16-946a-0284c0a875ea.png)

## Installation

Install DevTools package:

```bash
npm add --dev @fnpen/effector-devtools
```

Choose the way of opening DevTools UI:

### Option #0 – Browser extension

1. Install Rempl extension [for Chromium](https://chrome.google.com/webstore/detail/rempl/hcikjlholajopgbgfmmlbmifdfbkijdj) based browser or [for Firefox](https://addons.mozilla.org/en-US/firefox/addon/rempl/)

2. Open your Effector app, then open browser's DevTools and find Rempl tab here. Click it. That's it.

> NOTE: If your Effector application and browser's DevTools were opened before Rempl extension is installed, you need to close and open browser's DevTools as well as reload the page with React application.

### Option #1 – In the page

```js
import { setupLogger } from "@fnpen/effector-devtools";
setupLogger({ inPage: true });
```

## Usage

### Attach some units to DevTools manually

```js
import { attachLogger } from "@fnpen/effector-devtools";
attachLogger(domain);
attachLogger($store);
attachLogger(event);
attachLogger(effectFx);
```

### Attach all available units using Babel plugin

Add plugin `"@fnpen/effector-devtools/babel-plugin"` to your `.babelrc` file:

```json
{
  "plugins": [
    ["effector/babel-plugin", { "addLoc": true, "addNames": true }]
    "@fnpen/effector-devtools/babel-plugin"
  ]
}
```

### Log any data using special methods

```js
import { logDiff, logName, log } from "@fnpen/effector-devtools";

log(["1", "2"]); // Simple logging.

logName("Name of Message", ["1", "2"]); // Send message with name.

logDiff("Name", ["2"]);
logDiff("Name", ["22", "3"]); // Outputs diff with previous call with same name.
```

### Hotkeys

- Option+O/P - Zooming
- Arrow Up/Down - Change selection
- Esc - Close details
- Left/Right - Change tabs.

### Acknowledgments

Thanks to Roman Dvornov (@lahmatiy) for developing [Rempl](https://github.com/rempl/rempl) and Effector community.