licenseguard-cli 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 rfxlamia
+github.com/rfxlamia/licenseguard
+
+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.

package/README.md

@@ -0,0 +1,258 @@
+# LicenseGuard
+
+[![npm version](https://badge.fury.io/js/licenseguard-cli.svg)](https://badge.fury.io/js/licenseguard-cli)
+[![Build Status](https://github.com/your-username/licenseguard/workflows/Test/badge.svg)](https://github.com/your-username/licenseguard/actions)
+[![Coverage Status](https://codecov.io/gh/your-username/licenseguard/branch/main/graph/badge.svg)](https://codecov.io/gh/your-username/licenseguard)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**License setup & compliance helper for developers**
+
+LicenseGuard is a CLI tool that helps you quickly set up open source licenses for your projects with automatic git hooks that notify your team about licensing requirements.
+
+## Quick Start
+
+```bash
+# Step 1: Run the interactive setup
+npx licenseguard-cli --init
+
+# Step 2: Answer the prompts (license type, owner name, year)
+
+# Step 3: Done! Your LICENSE file and git hooks are ready
+```
+
+That's it! Your project now has:
+- A properly formatted LICENSE file
+- A `.licenseguardrc` configuration file
+- Git hooks that display license reminders (optional)
+
+## Installation
+
+### Using npx (Recommended)
+```bash
+npx licenseguard-cli --init
+```
+
+### Global Installation
+```bash
+npm install -g licenseguard-cli
+licenseguard --init
+```
+
+### Local Installation
+```bash
+npm install --save-dev licenseguard-cli
+npx licenseguard-cli --init
+```
+
+## Usage
+
+### Interactive Setup (`--init`)
+
+```bash
+licenseguard --init
+```
+
+This command guides you through:
+1. Selecting a license type
+2. Entering your copyright owner name
+3. Setting the copyright year (defaults to current year)
+4. Adding a project URL (optional)
+5. Optionally initializing git if not already a repo
+6. Installing git hooks for license notifications
+
+**Example Output:**
+```
+📜 LicenseGuard - Interactive License Setup
+
+? Select license type: MIT License
+? Copyright owner name: Your Name
+? Copyright year: 2025
+? Project URL (optional): https://github.com/you/project
+
+✓ LICENSE file created
+✓ Configuration saved to .licenseguardrc
+✓ Git hooks installed
+
+📄 Your project is now licensed under MIT
+```
+
+### Fast Setup (`--init-fast`)
+
+```bash
+licenseguard --init-fast --license mit --owner "Your Name"
+```
+
+Non-interactive setup with flags. Perfect for CI/CD or scripting.
+
+**Available Flags:**
+- `--license <type>` (required) - License type to use
+- `--owner <name>` (optional) - Copyright owner (auto-detects from git config)
+- `--year <year>` (optional) - Copyright year (defaults to current year)
+- `--url <url>` (optional) - Project URL (auto-detects from git remote)
+
+**Examples:**
+```bash
+# Minimal (auto-detects owner from git config)
+licenseguard --init-fast --license mit
+
+# Full specification
+licenseguard --init-fast --license apache2_0 --owner "Apache Corp" --year 2025 --url "https://apache.org"
+
+# GPL license
+licenseguard --init-fast --license gpl3_0 --owner "Free Software Foundation"
+```
+
+### List Available Licenses (`--ls`)
+
+```bash
+licenseguard --ls
+```
+
+Displays all available license types:
+```
+Available License Templates:
+
+✓ MIT - MIT License (permissive, widely used)
+✓ Apache 2.0 - Apache License 2.0 (permissive with patent grant)
+✓ GPL 3.0 - GNU General Public License 3.0 (copyleft)
+✓ BSD 3-Clause - BSD 3-Clause License (permissive with attribution)
+✓ ISC - ISC License (simpler MIT alternative)
+✓ WTFPL - Do What The F*ck You Want To Public License (ultra-permissive)
+```
+
+## Available Licenses
+
+| License Key | Display Name | Description |
+|-------------|--------------|-------------|
+| `mit` | MIT | MIT License (permissive, widely used) |
+| `apache2_0` | Apache 2.0 | Apache License 2.0 (permissive with patent grant) |
+| `gpl3_0` | GPL 3.0 | GNU General Public License 3.0 (copyleft) |
+| `bsd3clause` | BSD 3-Clause | BSD 3-Clause License (permissive with attribution) |
+| `isc` | ISC | ISC License (simpler MIT alternative) |
+| `wtdpl` | WTFPL | Do What The F*ck You Want To Public License (ultra-permissive) |
+
+Not sure which license to choose? Visit [choosealicense.com](https://choosealicense.com) for guidance.
+
+## Configuration
+
+LicenseGuard creates a `.licenseguardrc` file in your project root:
+
+```json
+{
+  "license": "mit",
+  "owner": "Your Name",
+  "year": "2025",
+  "url": "https://github.com/you/project"
+}
+```
+
+This configuration is used by the git hooks to display license information.
+
+## Git Hooks
+
+LicenseGuard installs two informational git hooks:
+
+### Post-Checkout Hook
+Displays a notification after `git clone` or `git checkout`:
+```
+📜 This project uses MIT License by Your Name
+```
+
+### Pre-Commit Hook
+Displays a reminder before each commit:
+```
+ℹ️ Reminder: This project is licensed under MIT
+```
+
+**Important:**
+- Hooks are **educational only** - they never block git operations
+- Hooks always exit with code 0 (success)
+- If `.licenseguardrc` is missing, hooks silently exit
+
+### Existing Hooks
+
+If you already have git hooks, LicenseGuard will NOT overwrite them. Instead, it creates variants:
+- `.git/hooks/licenseguard-pre-commit`
+- `.git/hooks/licenseguard-post-checkout`
+
+You can manually merge these with your existing hooks if desired.
+
+### Without Git
+
+If your project is not a git repository:
+- Interactive mode (`--init`) will offer to run `git init`
+- Fast mode (`--init-fast`) will skip hooks and warn you
+- LICENSE file is always created regardless of git status
+
+## FAQ
+
+### Does this work offline?
+Yes! LicenseGuard is completely offline. All license templates are bundled with the package.
+
+### Can I use custom licenses?
+Currently, LicenseGuard supports the 6 most common open source licenses. Custom license support may be added in future versions.
+
+### Does it work on Windows?
+Yes! LicenseGuard is fully cross-platform and works on Linux, macOS, and Windows.
+
+### What if I already have a LICENSE file?
+Interactive mode will ask if you want to overwrite it. Fast mode will overwrite without asking.
+
+### How do I update my license?
+Run `licenseguard --init` again and it will regenerate your LICENSE file.
+
+### Can I disable the git hooks?
+The hooks are informational only and don't block anything. If you don't want them, simply delete the hook files from `.git/hooks/`.
+
+### What Node.js versions are supported?
+LicenseGuard requires Node.js 18.x or 20.x (LTS versions).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/your-username/licenseguard.git
+cd licenseguard
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run test:coverage
+
+# Lint code
+npm run lint
+
+# Format code
+npm run format
+
+# Test locally
+npm link
+cd /tmp && mkdir test-project && cd test-project
+licenseguard --init
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+**Links:**
+- [Choose a License](https://choosealicense.com) - Help choosing the right license
+- [Open Source Initiative](https://opensource.org/licenses) - OSI-approved licenses
+- [GitHub Repository](https://github.com/your-username/licenseguard) - Source code
+- [npm Package](https://www.npmjs.com/package/licenseguard-cli) - npm registry

package/bin/licenseguard.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+const { program } = require('commander')
+const { runList } = require('../lib/commands/list')
+const { runInit } = require('../lib/commands/init')
+const { runInitFast } = require('../lib/commands/init-fast')
+
+program
+  .version('1.0.0')
+  .description('License setup & compliance helper for developers')
+
+program
+  .option('--init', 'Interactive license setup wizard')
+  .option('--init-fast', 'Non-interactive fast setup')
+  .option('--license <type>', 'License type (for --init-fast)')
+  .option('--owner <name>', 'Copyright owner name (for --init-fast)')
+  .option('--year <year>', 'Copyright year (for --init-fast)')
+  .option('--url <url>', 'Project URL (for --init-fast)')
+  .option('--ls', 'List available license templates')
+  .parse(process.argv)
+
+const options = program.opts()
+
+if (options.init) {
+  runInit().catch((err) => {
+    console.error('Error:', err.message)
+    process.exit(1)
+  })
+} else if (options.initFast) {
+  runInitFast(options).catch((err) => {
+    console.error('Error:', err.message)
+    process.exit(1)
+  })
+} else if (options.ls) {
+  runList().catch((err) => {
+    console.error('Error:', err.message)
+    process.exit(1)
+  })
+} else {
+  program.help()
+}

package/lib/commands/init-fast.js

@@ -0,0 +1,104 @@
+const { execSync } = require('child_process')
+const os = require('os')
+const fs = require('fs')
+const chalk = require('chalk')
+const { generateLicense, LICENSE_TEMPLATES } = require('../templates')
+const { writeConfig } = require('../utils/file-ops')
+const { isGitRepo, installHooks } = require('../utils/git-helpers')
+
+function getGitConfig(key) {
+  try {
+    const value = execSync(`git config ${key}`, { encoding: 'utf8' })
+    return value.trim()
+  } catch (error) {
+    return null
+  }
+}
+
+async function runInitFast(options) {
+  try {
+    const flags = {
+      license: options.license,
+      owner: options.owner,
+      year: options.year,
+      url: options.url,
+    }
+
+    // Validate required flag: license
+    if (!flags.license) {
+      console.error(chalk.red('✗ Error: --license flag is required'))
+      console.log(
+        chalk.blue('Usage: licenseguard --init-fast --license TYPE [options]')
+      )
+      console.log(
+        chalk.blue(
+          `Available licenses: ${Object.keys(LICENSE_TEMPLATES).join(', ')}`
+        )
+      )
+      process.exit(1)
+    }
+
+    // Validate license type
+    const validLicenses = Object.keys(LICENSE_TEMPLATES)
+    if (!validLicenses.includes(flags.license)) {
+      console.error(
+        chalk.red(`✗ Error: Invalid license type: ${flags.license}`)
+      )
+      console.log(
+        chalk.blue(`ℹ️  Available licenses: ${validLicenses.join(', ')}`)
+      )
+      process.exit(1)
+    }
+
+    // Auto-detect values if not provided
+    const year = flags.year || new Date().getFullYear().toString()
+    const owner =
+      flags.owner || getGitConfig('user.name') || os.userInfo().username
+    const url = flags.url || getGitConfig('--get remote.origin.url') || ''
+
+    console.log(chalk.blue('📜 LicenseGuard - Fast License Setup\n'))
+    console.log(chalk.gray(`License: ${flags.license}`))
+    console.log(chalk.gray(`Owner: ${owner}`))
+    console.log(chalk.gray(`Year: ${year}`))
+    if (url) console.log(chalk.gray(`URL: ${url}`))
+    console.log()
+
+    // Generate license text
+    const licenseContent = generateLicense(flags.license, owner, year, url)
+
+    // Write LICENSE file directly (no prompt in fast mode)
+    fs.writeFileSync('LICENSE', licenseContent, 'utf8')
+
+    // Write config file
+    writeConfig({
+      license: flags.license,
+      owner: owner,
+      year: year,
+      url: url,
+    })
+
+    // Success messages
+    console.log(chalk.green('✓ LICENSE file created'))
+    console.log(chalk.green('✓ Configuration saved to .licenseguardrc'))
+
+    // Git hooks installation (no prompts in fast mode)
+    if (isGitRepo()) {
+      installHooks()
+    } else {
+      console.log(chalk.yellow('⚠️  Skipping git hooks (not a git repo)'))
+    }
+
+    console.log(
+      chalk.blue(
+        `\n📄 Your project is now licensed under ${flags.license.toUpperCase()}`
+      )
+    )
+
+    process.exit(0)
+  } catch (error) {
+    console.error(chalk.red('\n✗ Error during fast setup:'), error.message)
+    process.exit(1)
+  }
+}
+
+module.exports = { runInitFast }

package/lib/commands/init.js

@@ -0,0 +1,120 @@
+const inquirer = require('inquirer')
+const chalk = require('chalk')
+const { generateLicense } = require('../templates')
+const { writeLicenseFile, writeConfig } = require('../utils/file-ops')
+const { isGitRepo, initGitRepo, installHooks } = require('../utils/git-helpers')
+
+async function runInit() {
+  try {
+    console.log(chalk.blue('📜 LicenseGuard - Interactive License Setup\n'))
+
+    // Prompt for license type
+    const answers = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'license',
+        message: 'Select license type:',
+        choices: [
+          { name: 'MIT License', value: 'mit' },
+          { name: 'Apache License 2.0', value: 'apache2_0' },
+          { name: 'GNU GPL 3.0', value: 'gpl3_0' },
+          { name: 'BSD 3-Clause License', value: 'bsd3clause' },
+          { name: 'ISC License', value: 'isc' },
+          { name: 'WTDPL', value: 'wtdpl' },
+        ],
+      },
+      {
+        type: 'input',
+        name: 'owner',
+        message: 'Copyright owner name:',
+        validate: (input) => {
+          if (!input || input.trim() === '') {
+            return 'Owner name is required'
+          }
+          return true
+        },
+      },
+      {
+        type: 'input',
+        name: 'year',
+        message: 'Copyright year:',
+        default: new Date().getFullYear().toString(),
+      },
+      {
+        type: 'input',
+        name: 'url',
+        message: 'Project URL (optional):',
+        default: '',
+      },
+    ])
+
+    // Generate license text
+    const licenseContent = generateLicense(
+      answers.license,
+      answers.owner,
+      answers.year,
+      answers.url
+    )
+
+    // Write LICENSE file
+    const licenseWritten = await writeLicenseFile(licenseContent)
+
+    if (!licenseWritten) {
+      // User cancelled overwrite
+      process.exit(0)
+    }
+
+    // Write config file
+    writeConfig({
+      license: answers.license,
+      owner: answers.owner,
+      year: answers.year,
+      url: answers.url,
+    })
+
+    // Success messages
+    console.log(chalk.green('\n✓ LICENSE file created'))
+    console.log(chalk.green('✓ Configuration saved to .licenseguardrc'))
+
+    // Git hooks installation
+    let skipHooks = false
+
+    if (!isGitRepo()) {
+      const gitAnswer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'initGit',
+          message: 'Not a git repository. Initialize git?',
+          default: true,
+        },
+      ])
+
+      if (gitAnswer.initGit) {
+        const gitInitSuccess = initGitRepo()
+        if (!gitInitSuccess) {
+          skipHooks = true
+        }
+      } else {
+        console.log(chalk.yellow('⚠️  Skipping git hooks (not a git repo)'))
+        skipHooks = true
+      }
+    }
+
+    if (!skipHooks && isGitRepo()) {
+      installHooks()
+    }
+
+    console.log(
+      chalk.blue(
+        `\n📄 Your project is now licensed under ${answers.license.toUpperCase()}`
+      )
+    )
+
+    process.exit(0)
+  } catch (error) {
+    console.error(chalk.red('\n✗ Error during initialization:'), error.message)
+    process.exit(1)
+  }
+}
+
+module.exports = { runInit }

package/lib/commands/list.js

@@ -0,0 +1,49 @@
+const licenses = [
+  {
+    name: 'MIT',
+    description: 'MIT License (permissive, widely used)',
+  },
+  {
+    name: 'Apache 2.0',
+    description: 'Apache License 2.0 (permissive with patent grant)',
+  },
+  {
+    name: 'GPL 3.0',
+    description: 'GNU General Public License 3.0 (copyleft)',
+  },
+  {
+    name: 'BSD 3-Clause',
+    description: 'BSD 3-Clause License (permissive with attribution)',
+  },
+  {
+    name: 'ISC',
+    description: 'ISC License (simpler MIT alternative)',
+  },
+  {
+    name: 'WTFPL',
+    description:
+      'Do What The F*ck You Want To Public License (ultra-permissive)',
+  },
+]
+
+async function runList() {
+  // Dynamic import for chalk v5 (ESM-only)
+  const chalk = (await import('chalk')).default
+
+  console.log(chalk.bold('\nAvailable License Templates:\n'))
+
+  licenses.forEach((license) => {
+    console.log(
+      chalk.green('✓') +
+        ' ' +
+        chalk.bold(license.name) +
+        ' - ' +
+        license.description
+    )
+  })
+
+  console.log('')
+  process.exit(0)
+}
+
+module.exports = { runList }

package/lib/templates.js

@@ -0,0 +1,336 @@
+const LICENSE_TEMPLATES = {
+  mit: `MIT License
+
+Copyright (c) {{year}} {{owner}}
+{{url}}
+
+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.`,
+
+  apache2_0: `                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {{year}} {{owner}}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.`,
+
+  gpl3_0: `GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) {{year}} {{owner}}
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+[Note: Full GPL 3.0 text would go here - abbreviated for brevity in this implementation]
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.`,
+
+  bsd3clause: `BSD 3-Clause License
+
+Copyright (c) {{year}}, {{owner}}
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`,
+
+  isc: `Copyright (c) {{year}} {{owner}}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.`,
+
+  wtdpl: `DO WHAT THE HECK YOU WANT TO PUBLIC LICENSE
+Version 2, December 2004
+
+Copyright (C) {{year}} {{owner}}
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+DO WHAT THE HECK YOU WANT TO PUBLIC LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE HECK YOU WANT TO.`,
+}
+
+function generateLicense(type, owner, year, url) {
+  const template = LICENSE_TEMPLATES[type]
+  if (!template) {
+    const availableLicenses = Object.keys(LICENSE_TEMPLATES).join(', ')
+    throw new Error(
+      `Unknown license type: ${type}. Available licenses: ${availableLicenses}`
+    )
+  }
+
+  let result = template
+    .replace(/\{\{owner\}\}/g, owner)
+    .replace(/\{\{year\}\}/g, year)
+
+  // URL is optional - remove placeholder if not provided
+  if (url) {
+    result = result.replace(/\{\{url\}\}/g, url)
+  } else {
+    result = result.replace(/\{\{url\}\}/g, '')
+  }
+
+  return result
+}
+
+module.exports = { LICENSE_TEMPLATES, generateLicense }

package/lib/utils/file-ops.js

@@ -0,0 +1,46 @@
+const fs = require('fs')
+const inquirer = require('inquirer')
+const chalk = require('chalk')
+
+async function writeLicenseFile(content) {
+  // Check if LICENSE file already exists
+  if (fs.existsSync('LICENSE')) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: chalk.yellow('LICENSE file already exists. Overwrite?'),
+        default: false,
+      },
+    ])
+
+    if (!overwrite) {
+      console.log(
+        chalk.blue('ℹ️  Keeping existing LICENSE file. Operation cancelled.')
+      )
+      return false
+    }
+  }
+
+  // Write LICENSE file
+  try {
+    fs.writeFileSync('LICENSE', content, 'utf8')
+    return true
+  } catch (error) {
+    console.error(chalk.red('✗ Error writing LICENSE file:'), error.message)
+    throw error
+  }
+}
+
+function writeConfig(config) {
+  try {
+    const configContent = JSON.stringify(config, null, 2)
+    fs.writeFileSync('.licenseguardrc', configContent, 'utf8')
+    return true
+  } catch (error) {
+    console.error(chalk.red('✗ Error writing .licenseguardrc:'), error.message)
+    throw error
+  }
+}
+
+module.exports = { writeLicenseFile, writeConfig }

package/lib/utils/git-helpers.js

@@ -0,0 +1,174 @@
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+const chalk = require('chalk')
+
+/**
+ * Check if current directory is a git repository
+ * @returns {boolean} true if .git directory exists
+ */
+function isGitRepo() {
+  try {
+    return fs.existsSync('.git')
+  } catch (error) {
+    return false
+  }
+}
+
+/**
+ * Initialize a git repository in the current directory
+ * @returns {boolean} true if git init succeeded
+ */
+function initGitRepo() {
+  try {
+    execSync('git init', { stdio: 'inherit' })
+    return true
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to initialize git repository'))
+    return false
+  }
+}
+
+/**
+ * Install git hooks for license notifications
+ * @returns {boolean} true if hooks were installed successfully
+ */
+function installHooks() {
+  try {
+    const hooksDir = path.join('.git', 'hooks')
+
+    // Ensure hooks directory exists
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true })
+    }
+
+    const hooks = [
+      { name: 'post-checkout', script: generatePostCheckoutScript() },
+      { name: 'pre-commit', script: generatePreCommitScript() },
+    ]
+
+    let hasConflicts = false
+
+    for (const hook of hooks) {
+      const hookPath = path.join(hooksDir, hook.name)
+
+      if (fs.existsSync(hookPath)) {
+        // Existing hook detected - create variant
+        const variantPath = path.join(hooksDir, `licenseguard-${hook.name}`)
+        fs.writeFileSync(variantPath, hook.script, 'utf8')
+        makeExecutable(variantPath)
+
+        console.log(chalk.yellow(`⚠️  Existing ${hook.name} hook detected.`))
+        console.log(chalk.blue(`📝 Installed as: licenseguard-${hook.name}`))
+        console.log(
+          chalk.gray(
+            '💡 To use: merge with your existing hook or rename.'
+          )
+        )
+        hasConflicts = true
+      } else {
+        // No conflict - install directly
+        fs.writeFileSync(hookPath, hook.script, 'utf8')
+        makeExecutable(hookPath)
+      }
+    }
+
+    if (!hasConflicts) {
+      console.log(chalk.green('✓ Git hooks installed'))
+    }
+
+    return true
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to install git hooks:'), error.message)
+    return false
+  }
+}
+
+/**
+ * Make a file executable (Unix only)
+ * @param {string} filePath - Path to the file
+ */
+function makeExecutable(filePath) {
+  try {
+    // chmod 755 on Unix systems
+    fs.chmodSync(filePath, 0o755)
+  } catch (error) {
+    // Ignore errors on Windows where chmod is not supported
+  }
+}
+
+/**
+ * Generate post-checkout hook script
+ * @returns {string} Hook script content
+ */
+function generatePostCheckoutScript() {
+  return `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+
+try {
+  // Read .licenseguardrc from project root (relative to .git/hooks/)
+  const configPath = path.resolve(__dirname, '..', '..', '.licenseguardrc')
+
+  if (!fs.existsSync(configPath)) {
+    // No config file, silently exit
+    process.exit(0)
+  }
+
+  const configContent = fs.readFileSync(configPath, 'utf8')
+  const config = JSON.parse(configContent)
+
+  // Display license notification with color
+  const blue = '\\x1b[34m'
+  const reset = '\\x1b[0m'
+
+  console.log(\`\${blue}📜 This project uses \${config.license.toUpperCase()} License by \${config.owner}\${reset}\`)
+
+  process.exit(0)
+} catch (error) {
+  // Errors should not block git operations
+  process.exit(0)
+}
+`
+}
+
+/**
+ * Generate pre-commit hook script
+ * @returns {string} Hook script content
+ */
+function generatePreCommitScript() {
+  return `#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+
+try {
+  // Read .licenseguardrc from project root (relative to .git/hooks/)
+  const configPath = path.resolve(__dirname, '..', '..', '.licenseguardrc')
+
+  if (!fs.existsSync(configPath)) {
+    // No config file, silently exit
+    process.exit(0)
+  }
+
+  const configContent = fs.readFileSync(configPath, 'utf8')
+  const config = JSON.parse(configContent)
+
+  // Display license reminder with color
+  const blue = '\\x1b[34m'
+  const reset = '\\x1b[0m'
+
+  console.log(\`\${blue}ℹ️  Reminder: This project is licensed under \${config.license.toUpperCase()}\${reset}\`)
+
+  process.exit(0)
+} catch (error) {
+  // Errors should not block git operations
+  process.exit(0)
+}
+`
+}
+
+module.exports = {
+  isGitRepo,
+  initGitRepo,
+  installHooks,
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "licenseguard-cli",
+  "version": "1.0.0",
+  "description": "License setup & compliance helper for developers",
+  "bin": {
+    "licenseguard": "./bin/licenseguard.js"
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint .",
+    "format": "prettier --write ."
+  },
+  "keywords": [
+    "license",
+    "compliance",
+    "MIT",
+    "Apache",
+    "GPL",
+    "developer-tools"
+  ],
+  "author": "v",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.5"
+  },
+  "devDependencies": {
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "mock-fs": "^5.2.0",
+    "prettier": "^3.1.0"
+  }
+}