RequireJS is the ultimate solution for all your needs.

For assistance with this inquiry, check out my response.

For instance:

Structure of Client App Project:

sampleapp
    |___ main.js
    |___ cs.js
    |___ require.js

main.js serves as the hub for initializing and configuring RequireJS for your client application:

require.config({
    baseUrl: "/sampleapp",
    paths: {
        jquery: "libs/jquery", // Local
        underscore: "http://underscorejs.org/underscore-min.js", // Remote
        backbone: "https://github.com/documentcloud/backbone/blob/master/backbone-min.js" // Remote on GitHub
    },
    shim: {
        backbone: {
            deps: ["underscore", "jquery"] // Backbone relies on jQuery and Underscore.js
        }
    }
});

require(["cs!someCoffeescriptFile", "jquery", "backbone", "underscore"], function (SomeCoffeescriptFile, $, Backbone, _) {
    // Loading dependencies...
    // Executing code
});

Utilize the cs plugin to handle dependencies that are prepended by "cs!". This plugin compiles CoffeeScript files.

During production, you can precompile your entire project using r.js.

node ./node_modules/requirejs/bin/r.js -o buildclientconfig.js

Your specifications include:

• Managing client-side dependencies in a format similar to npm's package.json or Bower's component.json file. Different but equally effective!

• Flexibility to reference Git repositories or actual JavaScript files (web-based or local) in the dependency.json file for lesser-known libraries (similar to npm's feature). Absolutely possible.

• Minification and namespacing of all libraries into a single file like Ender, streamlining the need for just one JavaScript file within the script tag on the client side. Possible with r.js.

• Built-in support for CoffeeScript akin to Box. Definitely available.

• Option to utilize either require style or headjs in the browser. Fully supported.

Need help with RequireJS? Click here!

According to Guillaume86, the best option would be using Hem to manage your client-side JavaScript dependencies.

In Hem, you can handle dependencies by utilizing npm and Hem together. Use npm to install all external dependencies explicitly for your projects. Hem can then be used to specify which dependencies (both external and local) should be combined for your client-side operations.

I have a demonstration project set up to showcase how this process works. You can view it at Client-side Hem.

Implementing Dependencies

To add a specific dependency, search for it using npm and update the package.json file to track the dependency. Then, specify the dependency in your application's slug.json.

For instance, if you want to include CoffeeScript as a dependency, simply use npm to install it and save it in your package.json file:

1. npm --save install coffee-script
2. Manually edit the slug.json file to add "coffee-script" under "dependencies".

If you wish to add your own 'bloomfilters' module which is not available on the npm registry, you can do so like this:

1. npm --save install https://github.com/dsummersl/bloomfilters/tarball/master

2. Update the slug.json file manually to include "bloomfilters" under "dependencies".

Local Modules

To include your own CoffeeScript or JavaScript code, place the files in the app/ folder. Remember to make your script a CommonJS module to expose it with the 'require' method. This process is straightforward—refer to the Hem documentation.

Local Files

If you need to include non-CommonJS or non-'require' code, reference your custom JavaScript or CoffeeScript code in the 'libs' list within the slug.json file.

CSS

Hem also handles stitching together CSS files if needed. Additional details can be found in the Hem documentation.

Building Process

After listing your dependencies, utilize hem to combine them into a cohesive package.

# Ensure all dependencies are installed:
npm install .

# Generate public/application.js
hem build

# View your minified JS in public/application.js

Additional Information

While Hem was originally developed for the Spine.js project, it can be adapted for other purposes as well. Feel free to disregard any references to spine in the documentation if necessary...

Another tool to consider is Browserify.

1. It follows the package.json format
2. Utilizes npm as a foundation, allowing for the use of GitHub (or any Git) repositories as package sources
3. Minimizes and combines all dependencies into one file.
4. Incorporates CoffeeScript if added to your dependencies
5. Consistent require style throughout
6. Includes support for source maps

I believe that the Hem framework may be a good fit for what you're looking for (I have customized it with extra compilers like Jade and Stylus. It's simple to tailor to your specific requirements). Hem utilizes npm for dependency management.

If you're looking for a way to streamline your web development process, check out Yeoman. It incorporates various techniques to assist you with your project requirements.

Our workflow consists of three essential tools for enhancing productivity and satisfaction while creating a web app: Yo (the scaffolding tool), Grunt (the build tool), and Bower (for package management).

Yeoman provides built-in support for CoffeeScript, Compass, and more. It seamlessly integrates with r.js (RequireJS), unit testing, and other features.

Addressing your specific requirements:

1. Bower is utilized for dependency management
2. Bower supports local files, git://, http://, and more
3. Includes built-in capabilities for minification, concatenation (even for images)
4. Provides automatic compilation of CoffeeScript and Compass (with LiveReload)
5. Utilizes r.js in the build process for AMD module optimization

Highlighted features include:

Rapid scaffolding — Create new projects easily with customizable templates like HTML5 Boilerplate, Twitter Bootstrap, RequireJS, and others.

Efficient build process — Besides minification and concatenation, Yeoman optimizes image files, compiles CoffeeScript and Compass files, and streamlines AMD modules through r.js.

Automatic CoffeeScript & Compass compilation — LiveReload feature automatically compiles source files and refreshes the browser upon changes.

Script linting automation — JSHint ensures script adherence to best practices.

Built-in preview server — Instantly launch an HTTP Server with a single command.

Image Optimization — OptiPNG and JPEGTran optimize images for faster user experience.

Effective package management — Easily search, install, and update dependencies via command-line interface without leaving the development environment.

PhantomJS Unit Testing — Conduct unit tests in headless WebKit using PhantomJS and receive test scaffolding for new applications.

If you're looking for a package manager, consider using Bower as it may meet your needs (1). Additionally, (2) you can utilize RequireJS for other requirements.

According to the information provided in the README documentation:

Bower serves as a helpful package manager specifically designed for web projects. It simplifies the process of installing assets like images, CSS, and JavaScript files while handling dependencies on your behalf.

To install a package, follow these steps:

bower install jquery
bower install git://github.com/maccman/package-jquery.git
bower install http://code.jquery.com/jquery-1.7.2.js
bower install ./repos/jquery

Recently stumbled upon inject.js

Here are some of the highlighted features on the official website:

Inject (Apache Software License 2.0) presents a fresh and innovative approach to managing dependencies in a Library Agnostic manner. Key features include:

• Compliance with CommonJS standards in the Browser (exports.*)
• Detailed view of CommonJS Support Matrix available
• Ease of cross domain file retrieval (using easyXDM)
• Efficient use of localStorage for loading modules once

Check out the Jam package manager. Here is an excerpt from its official website:

If you're a front-end developer looking for organized assets, Jam is a JavaScript package manager that prioritizes the browser experience above all else.

Its functionality may remind you of npm in certain aspects.

To install a package, simply type:

jam install backbone

Ensure your packages are always updated by running:

jam upgrade
jam upgrade {package}

You can optimize packages for production purposes with:

jam compile compiled.min.js

Add Jam dependencies to your package.json file.

For detailed instructions, refer to the Jam documentation.

Here are a few solutions you can explore:

• Browserify enables module importing
• RequireJS tackles the same issue
• A promising option currently in active development is JoinJS

Component might catch your interest as well. It doesn't handle dependencies directly, but allows usage of trimmed down versions of large libraries.

Here is an innovative solution that offers a different approach: bundling all modules into a JSON object and using file content to require modules without additional requests.

Experience the demo on the client side:

https://github.com/STRd6/require/blob/master/main.coffee.md

STRd6/require relies on a JSON package available at runtime, generating a require function for that package. This packaged approach eliminates the need for further HTTP requests by including all dependencies within it. It's a method closely resembling Node.js style requires for clients.

The structure of the package is outlined as:

entryPoint: "main"
distribution:
  main:
    content:"alert(\"It worked!\")"
  ...
dependencies:
  <name>: <a package>

Unlike Node.js, a package in this system does not rely on external names, leaving naming up to the including package. This provides full encapsulation.

Incorporating the setup, here is a function that loads a file from within a package:

loadModule = (pkg, path) ->
  unless (file = pkg.distribution[path])
    throw "Could not find file at #{path} in #{pkg.name}"

  program = file.content
  dirname = path.split(fileSeparator)[0...-1].join(fileSeparator)

  module =
    path: dirname
    exports: {}

  context =
    require: generateRequireFn(pkg, module)
    global: global
    module: module
    exports: module.exports
    PACKAGE: pkg
    __filename: path
    __dirname: dirname

  args = Object.keys(context)
  values = args.map (name) -> context[name]

  Function(args..., program).apply(module, values)

  return module

This external context equips modules with accessible variables.

A require function extends to modules, allowing them to require other modules.

Alongside, additional properties like references to the global object and metadata are also shared.

Eventually, the program executes within the module given the established context.

This technique caters primarily to those seeking a synchronous, Node.js-style require statement within browsers, bypassing interest in remote script loading options.

My preferred tool for development is Hem, which I use alongside npm. I've discovered some additional benefits of using Hem that haven't been widely discussed.

• Hem includes a self-contained web server (Strata) that allows you to develop code without the need to recompile constantly. Personally, I only use hem build when preparing to publish an application.
• You don't necessarily need Spine.js to utilize Hem. With the correct setup in your file slug.json, you can compile any CoffeeScript packages. For example, I have a package called TurkServer that is auto-compiled with cakefile.
• Another great feature of Hem is its ability to link local dependencies seamlessly with an npm link, even when using the Strata server. You can directly link to CoffeeScript from dependent projects without relying on the cake method mentioned earlier.
• Hem supports eco for views and Stylus for CSS, compiling everything, including your CoffeeScript code, into one JavaScript file and one CSS file.

If you're looking to set up a Spine.js, Hem, and CoffeeScript application, here's a basic guide. Feel free to skip the Spine.js parts if needed. Sometimes, I use spine app to structure a directory for non-Spine.js applications and then tweak file slug.json accordingly.

1. To get started, install NPM by running

   curl http://npmjs.org/install.sh | sh

   on a Unix-like system.

2. Next, globally install Hem using npm install -g hem. Consider getting it directly from GitHub if there have been recent developments, checking out a branch, and installing it using npm install -g ..

3. By running npm install -g spine.app, you can make spine a global command.

4. Create a Spine project named app within a folder by typing spine app folder, generating the necessary directory structure and initial files.

5. Edit the file dependencies.json in the folder to specify required libraries. These should also be added to slug.json for Hem's reference.

6. Optionally, use npm link to connect local packages to the node_modules directory in the folder, adding them to slug.json for Hem.

7. Run npm install . to download all specified dependencies.

8. Adjust the default spine configuration found in app/lib/setup.coffee to include the necessary libraries from your dependencies.

9. In the index.coffee file, require lib/setup and load the main controller for your application along with other classes in different controllers.

10. Modify the generated index.html file as needed to suit your application requirements.

11. Edit your stylus files located in the css folder to customize your styles.

12. Leverage hem server from the folder to launch a Hem server and access your application at localhost:9294. This makes debugging hassle-free.

13. Follow MVC principles to build the rest of your application, utilizing stylus for CSS and eco for views. Hem works flawlessly with CoffeeScript and npm, even outside of Spine.js projects.

Lastly, remember that while hem server updates automatically during development, running hem build will compile your application into minified versions. Use this command only when preparing for deployment.

For more information, check out Spine.js and Hem: Getting started

If you're working with Node.js or Express.js on the backend, be sure to take a look at Cartero.

If you're looking for a solution that fits most of your needs, I recommend exploring the Dojo Toolkit. The one aspect I'm uncertain about is its compatibility with CoffeeScript.

Dojo operates using modules in the Asynchronous Module Definition (AMD) format. It offers a build system with the option to bundle packages into single or multiple files known as layers. It appears to support Git repositories, and additional information on the build process can be found in Creating Builds.

Just a heads up, v1.9 beta is expected to be released next month.

Using dependency injection alongside asynchronous loading and Browserify can be a great alternative to RequireJS.

Exploring asynchronous frontend dependency management without AMD