aman-intelligence 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Intelligence
+
+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,116 @@
+# Aman Intelligence
+
+![Aman Intelligence](./images/ai-cli-v1.png)
+
+Aman is the package manager for AI workflow assets.
+
+Most developers have skills, prompts, and MCP configurations scattered across GitHub repositories, local folders, and notes. Aman gives you one place to install, organize, sync, and share them — the same way npm manages packages.
+
+## What Aman manages
+
+| Kind | What it is |
+|------|------------|
+| **Skills** | Reusable agent instructions (`SKILL.md`) |
+| **Prompts** | System and task prompts (`PROMPT.md`) |
+| **MCPs** | Model Context Protocol server configs (`mcp.json`) |
+| **Packs** | Bundles of assets you can share as `.amanpack` files |
+| **Stacks** | Named workflows that combine skills, prompts, and MCPs |
+
+## Quick install
+
+After the package is [published to npm](https://www.npmjs.com/package/aman-cli) as `aman-cli`:
+
+```bash
+npx aman-cli
+```
+
+Running `npx aman-cli` with no arguments installs Aman globally. To run without installing, pass a subcommand:
+
+```bash
+npx aman-cli doctor
+```
+
+Then use the CLI from anywhere:
+
+```bash
+aman --version
+aman init --local
+```
+
+**Other install paths:**
+
+```bash
+npm install -g aman-cli
+aman doctor
+```
+
+The CLI ships with **no default assets**. Install skills, prompts, and MCPs from the registry, import, or your own directories.
+
+## Three commands that show the value
+
+```bash
+# 1. Set up your environment (local or GitHub-backed)
+aman init --local
+
+# 2. Install an asset (registry example — publish or use a known slug@version)
+aman install "@your-scope/your-asset@1.0.0" --global
+
+# 3. Verify everything is healthy
+aman doctor
+```
+
+Or import from a folder, GitHub repository, another AI tool, or an Aman environment:
+
+```bash
+aman import                    # interactive wizard (TTY)
+aman import cursor --global    # shorthand syntax for Cursor rules/MCPs
+aman import antigravity --global # shorthand syntax for Antigravity rules/MCPs
+aman import ./my-assets --global
+aman import owner/repo --global
+```
+
+See [docs/IMPORT-GUIDE.md](./docs/IMPORT-GUIDE.md) for the full import guide covering Claude Code, Cursor, Windsurf, Continue.dev, VS Code, Copilot, Codex, Antigravity, and Aman Environment imports.
+
+## Documentation (GitHub)
+
+| Document | Audience |
+|----------|----------|
+| [QUICK-START.md](./QUICK-START.md) | New users — zero to first asset in minutes |
+| [docs/IMPORT-GUIDE.md](./docs/IMPORT-GUIDE.md) | Import from Claude Code, VS Code, Copilot, Codex, and local folders |
+| [docs/ASSET-SPEC.md](./docs/ASSET-SPEC.md) | Publishers — canonical asset format |
+| [docs/REGISTRY-SPEC.md](./docs/REGISTRY-SPEC.md) | Contributors — registry contract |
+| [docs/LOCKFILE-SPEC.md](./docs/LOCKFILE-SPEC.md) | Developers — reproducible installs |
+| [CONTRIBUTING.md](./CONTRIBUTING.md) | Contributors — code, assets, and PRs |
+| [SECURITY.md](./SECURITY.md) | Security model and reporting |
+| [RELEASE-NOTES.md](./RELEASE-NOTES.md) | Release history |
+| [AMAN_CONSTITUTION.md](./AMAN_CONSTITUTION.md) | Permanent architectural principles |
+| [PUBLISHING.md](./PUBLISHING.md) | Maintainers — npm pack and publish |
+
+Normative specs: [docs/specs/](./docs/specs/) (`AMAN-ASSET-SPEC-V1.md`, `AMAN-REGISTRY-SPEC-V1.md`, `AMAN-LOCKFILE-SPEC-V1.md`, and related).
+
+## Configuration
+
+### `AMAN_REGISTRY_BACKEND`
+
+| Value | Adapter | Storage |
+|-------|---------|---------|
+| `local` (default) | Local filesystem | `~/.aman/registry/` |
+| `github` | GitHub mirror | `~/.aman/repositories/{repo}/registry/` |
+
+```bash
+export AMAN_REGISTRY_BACKEND=github
+```
+
+## Requirements
+
+- Node.js 18+
+- Git (for import and GitHub sync)
+- GitHub CLI (`gh`) optional — for `aman init --github` and `aman sync`
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/bin/aman.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/aman.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import meow from 'meow';
+import { CLI_VERSION } from '../cli/version.js';
+import { printHelpText } from '../cli/help-text.js';
+import { isAmanCliEntrypoint, runGlobalInstall } from '../cli/global-install.js';
+import { ensureGlobalDirs } from '../config/paths.js';
+import { dashboardCommand } from '../commands/dashboard.js';
+import { browseCommand } from '../commands/browse.js';
+import { searchCommand } from '../commands/search.js';
+import { installCommand } from '../commands/install.js';
+import { removeCommand } from '../commands/remove.js';
+import { updateCommand } from '../commands/update.js';
+import { importCommand } from '../commands/import.js';
+import { exportCommand } from '../commands/export.js';
+import { packCommand } from '../commands/pack.js';
+import { stackCommand } from '../commands/stack.js';
+import { backupCommand } from '../commands/backup.js';
+import { doctorCommand } from '../commands/doctor.js';
+import { configCommand } from '../commands/config.js';
+import { helpCommand } from '../commands/help.js';
+import { initCommand } from '../commands/init.js';
+import { syncCommand } from '../commands/sync.js';
+import { infoCommand } from '../commands/info.js';
+import { registryCommand } from '../commands/registry.js';
+import { cacheCommand } from '../commands/cache.js';
+const preArgs = process.argv.slice(2);
+if (preArgs.includes('--version') || preArgs.includes('-v') || preArgs[0] === 'version') {
+    console.log(CLI_VERSION);
+    process.exit(0);
+}
+if (preArgs.length === 1 && (preArgs[0] === '--help' || preArgs[0] === '-h')) {
+    printHelpText();
+    process.exit(0);
+}
+// `npx aman-cli` (no subcommand) → global install; use `aman` afterward.
+if (isAmanCliEntrypoint() && preArgs.length === 0) {
+    runGlobalInstall();
+    process.exit(0);
+}
+const cli = meow(`
+  Usage
+    $ aman <command> [options]
+  
+  Options
+    --global, -g    Target global scope
+    --project, -p   Target project scope
+    --github        Initialize with GitHub storage
+    --local         Initialize with local storage
+    --repo          Repository name for GitHub init
+    --path          Storage path for local init
+    --format        Output format (json, yaml, zip)
+    --all           Apply command to all installed items
+    --type          Asset type: skill, prompt, or mcp
+    --list, -l      List mode (browse)
+    --json          JSON output (browse)
+    --version, -v   Print CLI version
+`, {
+    importMeta: import.meta,
+    flags: {
+        global: { type: 'boolean', shortFlag: 'g' },
+        project: { type: 'boolean', shortFlag: 'p' },
+        type: { type: 'string' },
+        list: { type: 'boolean', shortFlag: 'l' },
+        json: { type: 'boolean' },
+        github: { type: 'boolean' },
+        local: { type: 'boolean' },
+        existing: { type: 'boolean' },
+        repo: { type: 'string' },
+        repository: { type: 'string' },
+        path: { type: 'string' },
+        format: { type: 'string' },
+        all: { type: 'boolean' },
+        version: { type: 'boolean', shortFlag: 'v' },
+        yes: { type: 'boolean', shortFlag: 'y' },
+        noTty: { type: 'boolean' },
+        from: { type: 'string' },
+        githubDest: { type: 'boolean' },
+    },
+});
+async function main() {
+    await ensureGlobalDirs().catch(() => { });
+    if (cli.flags.version) {
+        console.log(CLI_VERSION);
+        return;
+    }
+    const input = cli.input;
+    const cmd = input[0];
+    const args = input.slice(1);
+    const options = cli.flags;
+    switch (cmd) {
+        case undefined:
+            await dashboardCommand();
+            break;
+        case 'init':
+            await initCommand(args, options);
+            break;
+        case 'browse':
+            await browseCommand(args, options);
+            break;
+        case 'search':
+            await searchCommand(args, options);
+            break;
+        case 'cache':
+            await cacheCommand(args);
+            break;
+        case 'install':
+            await installCommand(args, options);
+            break;
+        case 'remove':
+            await removeCommand(args, options);
+            break;
+        case 'update':
+            await updateCommand(args, options);
+            break;
+        case 'import':
+            await importCommand(args, options);
+            break;
+        case 'export':
+            await exportCommand(args, options);
+            break;
+        case 'pack':
+            await packCommand(args, options);
+            break;
+        case 'stack':
+            await stackCommand(args, options);
+            break;
+        case 'backup':
+            await backupCommand(args, options);
+            break;
+        case 'doctor':
+            await doctorCommand();
+            break;
+        case 'config':
+            await configCommand(args);
+            break;
+        case 'sync':
+            await syncCommand(args);
+            break;
+        case 'info':
+            await infoCommand(args);
+            break;
+        case 'registry':
+            await registryCommand(args, options);
+            break;
+        case 'help':
+            await helpCommand();
+            break;
+        default:
+            if (cmd) {
+                console.error(`Unknown command: ${cmd}`);
+            }
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                printHelpText();
+                process.exit(cmd ? 1 : 0);
+            }
+            await helpCommand();
+            if (cmd)
+                process.exit(1);
+    }
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+});

package/dist/cli/global-install.d.ts

@@ -0,0 +1,7 @@
+/** True when the process was started via the `aman-cli` or `aman-intelligence` bin. */
+export declare function isAmanCliEntrypoint(): boolean;
+/**
+ * Installs this package globally so users can run `aman` from any directory.
+ * Invoked by `npx aman-intelligence` with no subcommand.
+ */
+export declare function runGlobalInstall(): void;

package/dist/cli/global-install.js

@@ -0,0 +1,36 @@
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { CLI_VERSION } from './version.js';
+/** True when the process was started via the `aman-cli` or `aman-intelligence` bin. */
+export function isAmanCliEntrypoint() {
+    const bin = path.basename(process.argv[1] ?? '');
+    return (bin === 'aman-cli' || bin === 'aman-cli.cmd' || bin === 'aman-cli.ps1' ||
+        bin === 'aman-intelligence' || bin === 'aman-intelligence.cmd' || bin === 'aman-intelligence.ps1');
+}
+/**
+ * Installs this package globally so users can run `aman` from any directory.
+ * Invoked by `npx aman-intelligence` with no subcommand.
+ */
+export function runGlobalInstall() {
+    if (process.env.AMAN_SKIP_GLOBAL_INSTALL === '1') {
+        console.log('AMAN_SKIP_GLOBAL_INSTALL=1 — skipping global install.');
+        return;
+    }
+    console.log(`\n  Installing aman ${CLI_VERSION} globally…\n`);
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const result = spawnSync(npm, ['install', '-g', `aman-intelligence@${CLI_VERSION}`], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        console.error('\n  Global install failed.');
+        console.error('  Try manually: npm install -g aman-intelligence\n');
+        process.exit(result.status === null ? 1 : result.status);
+    }
+    console.log('\n  ✓ aman is installed globally.\n');
+    console.log('  Next steps:');
+    console.log('    aman init --local');
+    console.log('    aman install caveman --global');
+    console.log('    aman doctor\n');
+}

package/dist/cli/help-text.d.ts

@@ -0,0 +1 @@
+export declare function printHelpText(): void;

package/dist/cli/help-text.js

@@ -0,0 +1,62 @@
+import { CLI_VERSION } from './version.js';
+import { MARKETPLACE_ENABLED } from '../config/features.js';
+export function printHelpText() {
+    const cacheSection = MARKETPLACE_ENABLED
+        ? `  cache <cmd>         Marketplace cache status or clear
+
+Cache:
+  cache status        Show marketplace cache size and age
+  cache clear         Clear marketplace discovery cache`
+        : `  cache <cmd>         Discovery cache (coming in a future release)`;
+    console.log(`aman ${CLI_VERSION} — package manager for AI workflow assets
+
+Install globally (one command):
+  npx aman-intelligence
+
+Usage:
+  aman <command> [options]
+
+Commands:
+  (none)              Open dashboard (interactive terminal required)
+  init                Set up local or GitHub-backed storage
+  browse              Browse skills, prompts, and MCPs
+  search <query>      Search across asset types
+  info <name>         View asset details
+  install [ref]       Install asset or @scope/name@version from registry
+  remove <name>       Remove an installed asset
+  update [name]       Update installed assets
+  import <source>     Import from GitHub URL, repo, local folder, or AI tool
+                    Sources: claude-code, cursor, windsurf, continue,
+                      vscode, github-copilot, codex, local-folder,
+                      custom-path, aman-environment, antigravity
+  export [name]       Export assets (--all, --type skill|prompt|mcp)
+  pack <cmd>          Create, inspect, or install packs
+  stack <cmd>         Manage workflow stacks
+  sync <push|pull>    Sync environment with GitHub
+  backup <cmd>        Save, list, restore, or delete backups
+  doctor              Check environment health
+  config <cmd>        Manage CLI settings
+  registry <cmd>      Publish and query the canonical asset registry
+  ${cacheSection}
+  help                Show this help
+
+Registry:
+  registry publish    Publish an immutable asset version
+  registry deprecate  Mark a version deprecated (still installable)
+  registry list       List published versions for a slug
+  registry search     Search published assets
+  registry resolve    Show metadata for slug@version
+
+Options:
+  --global, -g        Target global scope (~/.aman)
+  --project, -p       Target project scope (.aman/)
+  --type              Asset type: skill, prompt, or mcp
+  --version, -v       Print CLI version
+
+Environment:
+  AMAN_REGISTRY_BACKEND   Registry adapter: local (default) or github
+
+Documentation:
+  https://github.com/amandeavor/aman-intelligence-CLI#readme
+`);
+}

package/dist/cli/version.d.ts

@@ -0,0 +1 @@
+export declare const CLI_VERSION: string;

package/dist/cli/version.js

@@ -0,0 +1,6 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import path from 'path';
+const require = createRequire(import.meta.url);
+const packagePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../package.json');
+export const CLI_VERSION = require(packagePath).version;

package/dist/commands/backup.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface BackupAppProps {
+    subcmd: string;
+    idOrName?: string;
+    bypassConfirm?: boolean;
+}
+export declare const BackupApp: React.FC<BackupAppProps & {
+    onBack?: () => void;
+}>;
+export declare function backupCommand(args: string[], options?: any): Promise<void>;
+export {};