open-index/open-npm huggingface dataset:
npm package: @javanut13/grunt-lisp.js
Description: Transpile lisp to JS
Author: Will Richardson
Latest version: 0.0.2

# grunt-lisp.js

> Transpile lisp to JS

## Getting Started
This plugin requires Grunt `~0.4.5`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-lisp.js --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-lisp.js');
```

## The "lisp_js" task

### Overview
In your project's Gruntfile, add a section named `lisp_js` to the data object passed into `grunt.initConfig()`.

```js
grunt.initConfig({
  lisp_js: {
    options: {
      // Task-specific options go here.
    },
    your_target: {
      // Target-specific file lists and/or options go here.
    },
  },
});
```

### Options

#### options.separator
Type: `String`
Default value: `',  '`

A string value that is used to do something with whatever.

#### options.punctuation
Type: `String`
Default value: `'.'`

A string value that is used to do something else with whatever else.

### Usage Examples

#### Default Options
In this example, the default options are used to do something with whatever. So if the `testing` file has the content `Testing` and the `123` file had the content `1 2 3`, the generated result would be `Testing, 1 2 3.`

```js
grunt.initConfig({
  lisp_js: {
    options: {},
    files: {
      'dest/default_options': ['src/testing', 'src/123'],
    },
  },
});
```

#### Custom Options
In this example, custom options are used to do something else with whatever else. So if the `testing` file has the content `Testing` and the `123` file had the content `1 2 3`, the generated result in this case would be `Testing: 1 2 3 !!!`

```js
grunt.initConfig({
  lisp_js: {
    options: {
      separator: ': ',
      punctuation: ' !!!',
    },
    files: {
      'dest/default_options': ['src/testing', 'src/123'],
    },
  },
});
```

## Contributing
In lieu of a formal styleguide, take care to maintain the existing coding style. Add unit tests for any new or changed functionality. Lint and test your code using [Grunt](http://gruntjs.com/).

## Release History
_(Nothing yet)_
npm package: @javanut13/lisp.js
Description: Lisp to JavaScript transpiler
Latest version: 0.1.1

# Lisp.js

Install for CLI:

```bash
npm install @javanut13/lisp.js -g
```

Run it from the command line:

```bash
lispjs -x my_lisp_file # execute the file
lispjs -c my_lisp_file # print the JS version of the file
lispjs -c my_lisp_file -o transpiled.js # Write the transpiled file
```

Include it in a webpage:

```html
<script src="lisp-web.min.js"></script>
```
```javascript
'(console.log "Hello world")'.evalLisp();
'(console.log "Hello world")'.toJS();
```

### Syntax

```lisp
(:length my_array) ; get the length (or another property) from an object
(.substring "Foobar" 3) ; call a method on an object
(defn func [a b] (console.log (+ a b))) ; create a function
```

The syntax is mostly Clojure-esque.
npm package: @javaperf/cli
Description: JavaPerf CLI — Analyze Java projects locally without uploading your code
Author: JavaPerf
Latest version: 1.0.2

# @javaperf/cli

JavaPerf CLI — Analyze Java & Spring projects for performance issues locally.

**Your code never leaves your machine.** The CLI analyzes files locally, zips only the `.java` source files, sends them to the JavaPerf API, then deletes the ZIP. Only the results (issues and score) are stored in your dashboard.

## Installation

```bash
npm install -g @javaperf/cli
```

## Quick Start

```bash
# 1. Authenticate with your API key (from javaperf.com/dashboard/settings/keys)
javaperf auth jp_live_your_key_here

# 2. Analyze your project
cd my-java-project
javaperf analyze .

# 3. View your reports
javaperf reports
```

## Commands

### `javaperf auth <apiKey>`
Save your API key locally.
```bash
javaperf auth jp_live_4f8a9b2c1d3e5f6a7b8c
```

### `javaperf analyze [path]`
Analyze a Java project.
```bash
# Analyze current directory
javaperf analyze .

# Analyze specific path
javaperf analyze ./src/main/java

# Output as JSON
javaperf analyze . --format json

# Minimal output (CI-friendly)
javaperf analyze . --format minimal

# Fail CI if critical issues found
javaperf analyze . --fail-on critical

# Fail CI if any warning or critical
javaperf analyze . --fail-on warning

# Exclude patterns
javaperf analyze . --exclude "test/**,generated/**"
```

### `javaperf reports`
List your recent analyses.
```bash
javaperf reports
javaperf reports --limit 20
```

### `javaperf whoami`
Show current authentication status.

## CI/CD Integration

### GitHub Actions
```yaml
name: JavaPerf Analysis
on: [push, pull_request]

jobs:
  javaperf:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install JavaPerf CLI
        run: npm install -g @javaperf/cli
      
      - name: Analyze Java project
        run: javaperf analyze . --format minimal --fail-on critical
        env:
          JAVAPERF_KEY: ${{ secrets.JAVAPERF_KEY }}
```

### GitLab CI
```yaml
javaperf:
  image: node:18
  script:
    - npm install -g @javaperf/cli
    - javaperf auth $JAVAPERF_KEY
    - javaperf analyze . --fail-on critical
```

### Jenkins
```groovy
stage('JavaPerf Analysis') {
  steps {
    sh 'npm install -g @javaperf/cli'
    sh 'javaperf auth $JAVAPERF_KEY'
    sh 'javaperf analyze . --format minimal --fail-on critical'
  }
}
```

## What gets analyzed

- N+1 queries and Hibernate anti-patterns
- DB writes in loops
- EAGER collection fetches
- Missing @Transactional
- HTTP calls inside transactions
- String concatenation in loops
- Thread creation in loops
- Large allocations in loops
- Synchronous I/O in loops
- Missing indexes and @Version
- And 20+ more rules

## Privacy

- Only `.java` files are included in the ZIP
- `target/`, `build/`, `.git/`, `node_modules/` are automatically excluded
- The ZIP is deleted from the server immediately after analysis
- Only results (file names, line numbers, issue descriptions) are stored

## License

MIT