newo 1.3.0 → 1.5.0

package/.env.example

@@ -1,8 +1,8 @@
 # NEWO endpoints
 NEWO_BASE_URL=https://app.newo.ai
 
-# Project you want to sync
-NEWO_PROJECT_ID=b78188ba-0df0-46a8-8713-f0d7cff0a06e
+# Project you want to sync (optional - leave blank to sync all accessible projects)
+# NEWO_PROJECT_ID=b78188ba-0df0-46a8-8713-f0d7cff0a06e
 
 # Auth (choose one)
 # 1) Recommended: API key that can be exchanged for tokens:

package/CHANGELOG.md

@@ -5,7 +5,104 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [1.3.0] - 2025-01-21
+## [1.5.0] - 2025-09-03
+
+### Changed
+- **Complete TypeScript Refactoring**: Major codebase conversion from JavaScript to TypeScript
+  - All source files converted to TypeScript with `.ts` extensions
+  - Added comprehensive type definitions in `src/types.ts`
+  - Strict TypeScript configuration with `exactOptionalPropertyTypes` and `noUncheckedIndexedAccess`
+  - Modern ES2022 target with ESNext modules for optimal performance
+  - Enhanced IntelliSense support and developer experience
+
+### Added
+- **TypeScript Build System**: 
+  - `tsconfig.json` with strict type checking and modern ES features
+  - New build scripts: `npm run build`, `npm run build:watch`, `npm run typecheck`
+  - Development scripts: `npm run dev`, `npm run pull`, `npm run push`, `npm run status`
+  - Source map generation for debugging compiled JavaScript
+- **Enhanced Type Safety**:
+  - Complete type definitions for all NEWO API responses and data structures
+  - Strict error handling with proper TypeScript error types
+  - Optional property handling with explicit `| undefined` types
+  - Enhanced Axios integration with proper TypeScript interceptor types
+
+### Technical Details
+- **Type Definitions**: Comprehensive interfaces for `ProjectMeta`, `Agent`, `Flow`, `Skill`, `FlowEvent`, `FlowState`, and all API responses
+- **Build Output**: TypeScript compiles to `dist/` directory with JavaScript and declaration files
+- **Import Strategy**: Uses runtime `.js` extensions in TypeScript source (required for ESModules)
+- **Dependency Updates**: Added TypeScript and @types packages for full type support
+- **Package.json**: Updated with TypeScript build pipeline and development scripts
+
+### Migration for Developers
+- **New Development Workflow**: `npm run build` required before running CLI commands
+- **Source Files**: All development now in `src/*.ts` files instead of `src/*.js`
+- **Build Artifacts**: Generated JavaScript in `dist/` directory (automatically created)
+- **IDE Support**: Enhanced autocomplete, error detection, and refactoring capabilities
+
+### Backward Compatibility
+- **Runtime Behavior**: No changes to CLI command interface or functionality
+- **Environment Variables**: All existing `.env` configurations continue to work
+- **File Formats**: Same `.guidance` and `.jinja` file support as before
+- **API Compatibility**: No changes to NEWO API integration or endpoints
+
+## [1.4.0] - 2025-08-20
+
+### Added
+- **Multi-Project Support**: Major feature allowing users to work with multiple NEWO projects
+  - Optional `NEWO_PROJECT_ID` environment variable - if not set, pulls all accessible projects
+  - New API endpoint: `GET /api/v1/designer/projects` to list all accessible projects
+  - Projects stored in organized folder structure: `./projects/{project-idn}/`
+  - Each project folder contains `metadata.json` with complete project information
+  - Project-specific `flows.yaml` files for individual project structure exports
+- **Enhanced Project Structure**:
+  - Changed from single `./project/` to multi-project `./projects/{project-idn}/` hierarchy
+  - Backward compatibility maintained for existing single-project workflows
+  - Improved organization with project-specific metadata and flows
+
+### Changed
+- **Folder Structure**: Project files now stored in `./projects/{project-idn}/` instead of `./project/`
+- **CLI Behavior**: `newo pull` now downloads all projects by default (unless NEWO_PROJECT_ID specified)
+- **CI/CD Paths**: GitHub Actions workflow paths updated from `project/**/*` to `projects/**/*`
+- **Help Documentation**: Updated CLI help text to reflect multi-project capabilities
+- **API Integration**: Enhanced sync logic to handle both single and multi-project scenarios
+
+### Technical Details
+- **New API Functions**:
+  - `listProjects()`: Fetch all accessible projects from NEWO platform
+  - `pullSingleProject()`: Pull individual project with metadata generation
+  - `metadataPath()`: Generate project-specific metadata file paths
+- **Enhanced Sync Engine**:
+  - Multi-project mapping in `.newo/map.json` with backward compatibility
+  - Project-specific hash tracking for efficient change detection
+  - Automatic project metadata collection and storage
+- **File System Updates**:
+  - Updated `fsutil.js` with multi-project path utilities
+  - Enhanced `skillPath()` function to include project identifier
+  - New `projectDir()` and `metadataPath()` helper functions
+
+### Migration Guide
+- **Existing Users**: Single-project setups continue to work with `NEWO_PROJECT_ID` set
+- **New Users**: Leave `NEWO_PROJECT_ID` unset to access all projects automatically
+- **File Paths**: Update any scripts referencing `./project/` to use `./projects/{project-idn}/`
+- **CI/CD**: Update workflow paths from `project/**/*` to `projects/**/*`
+
+### Example Usage
+```bash
+# Pull all accessible projects (new default behavior)
+npx newo pull
+
+# Pull specific project (original behavior)
+NEWO_PROJECT_ID=your-project-id npx newo pull
+
+# Push changes from any project structure
+npx newo push
+
+# Status works with both single and multi-project setups
+npx newo status
+```
+
+## [1.3.0] - 2025-08-20
 
 ### Added
 - **AKB Import Feature**: New `import-akb` command to import knowledge base articles from structured text files
@@ -57,7 +154,7 @@ Another Item: $Price [Modifiers: modifier3]
 ---
 ```
 
-## [1.2.2] - 2025-01-20
+## [1.2.2] - 2025-08-12
 
 ### Changed
 - Updated README with API key image

package/README.md

@@ -33,6 +33,7 @@ npx newo status
 git clone https://github.com/sabbah13/newo-cli.git
 cd newo-cli
 npm install
+npm run build    # Build TypeScript to JavaScript
 ```
 
 ## Configure
@@ -54,34 +55,41 @@ cp .env.example .env
 
 Required environment variables:
 - `NEWO_BASE_URL` (default `https://app.newo.ai`)
-- `NEWO_PROJECT_ID` (your project UUID from NEWO)
 - `NEWO_API_KEY` (your API key from Step 1)
 
-Optional (advanced):
+Optional environment variables:
+- `NEWO_PROJECT_ID` (specific project UUID - if not set, pulls all accessible projects)
 - `NEWO_ACCESS_TOKEN` (direct access token)
 - `NEWO_REFRESH_TOKEN` (refresh token)
 - `NEWO_REFRESH_URL` (custom refresh endpoint)
 
 ## Commands
 ```bash
-npx newo pull                              # download project -> ./project
+npx newo pull                              # download all projects -> ./projects/ OR specific project if NEWO_PROJECT_ID set
 npx newo status                            # list modified files
 npx newo push                              # upload modified *.guidance/*.jinja back to NEWO
 npx newo import-akb <file> <persona_id>    # import AKB articles from file
-npx newo meta                              # get project metadata (debug)
+npx newo meta                              # get project metadata (debug, requires NEWO_PROJECT_ID)
 ```
 
+### Project Structure
 Files are stored as:
-- `./project/<AgentIdn>/<FlowIdn>/<SkillIdn>.guidance` (AI guidance scripts)
-- `./project/<AgentIdn>/<FlowIdn>/<SkillIdn>.jinja` (NSL/Jinja template scripts)
+- **Multi-project mode** (no NEWO_PROJECT_ID): `./projects/<ProjectIdn>/<AgentIdn>/<FlowIdn>/<SkillIdn>.guidance|.jinja`
+- **Single-project mode** (NEWO_PROJECT_ID set): `./projects/<ProjectIdn>/<AgentIdn>/<FlowIdn>/<SkillIdn>.guidance|.jinja`
+
+Each project folder contains:
+- `metadata.json` - Project metadata (title, description, version, etc.)
+- `flows.yaml` - Complete project structure export for external tools
+- Agent/Flow/Skill hierarchy with `.guidance` (AI prompts) and `.jinja` (NSL templates)
 
 Hashes are tracked in `.newo/hashes.json` so only changed files are pushed.
-Project structure is also exported to `flows.yaml` for reference.
 
 ## Features
+- **Multi-project support**: Pull all accessible projects or specify a single project
 - **Two-way sync**: Pull NEWO projects to local files, push local changes back
 - **Change detection**: SHA256 hashing prevents unnecessary uploads
 - **Multiple file types**: `.guidance` (AI prompts) and `.jinja` (NSL templates)
+- **Project metadata**: Each project includes `metadata.json` with complete project info
 - **AKB import**: Import knowledge base articles from structured text files
 - **Project structure export**: Generates `flows.yaml` with complete project metadata
 - **Robust authentication**: API key exchange with automatic token refresh
@@ -95,8 +103,8 @@ on:
   push:
     branches: [ main ]
     paths:
-      - 'project/**/*.guidance'
-      - 'project/**/*.jinja'
+      - 'projects/**/*.guidance'
+      - 'projects/**/*.jinja'
 jobs:
   deploy:
     runs-on: ubuntu-latest
@@ -106,7 +114,7 @@ jobs:
         with:
           node-version: 20
       - run: npm ci
-      - run: node ./src/cli.js push
+      - run: npm run build && node ./dist/cli.js push
         env:
           NEWO_BASE_URL: https://app.newo.ai
           NEWO_PROJECT_ID: ${{ secrets.NEWO_PROJECT_ID }}
@@ -148,7 +156,48 @@ Each article will be imported with:
 
 Use `--verbose` flag to see detailed import progress.
 
+## Development
+
+This project is built with TypeScript for enhanced type safety and developer experience.
+
+### Development Commands
+```bash
+# Build TypeScript to JavaScript
+npm run build
+
+# Build and watch for changes
+npm run build:watch
+
+# Run CLI commands (after building)
+npm run dev pull                    # Build and run pull command
+npm run pull                        # Build and run pull command
+npm run push                        # Build and run push command
+npm run status                      # Build and run status command
+
+# Type checking without emitting files
+npm run typecheck
+
+# Run tests
+npm test
+```
+
+### Project Structure
+- `src/` - TypeScript source files
+- `dist/` - Compiled JavaScript output (generated by `npm run build`)
+- `test/` - Test files
+- `projects/` - Downloaded NEWO projects (generated by pull command)
+- `.newo/` - CLI state directory (tokens, hashes, mappings)
+
+### TypeScript Features
+- Full type safety with strict TypeScript configuration
+- Modern ES2022 target with ESNext modules
+- Comprehensive type definitions for all NEWO API responses
+- Enhanced error handling and validation
+- IntelliSense support in compatible IDEs
+
 ## API Endpoints
+- `GET /api/v1/designer/projects` - List all accessible projects
+- `GET /api/v1/designer/projects/by-id/{projectId}` - Get specific project metadata
 - `GET /api/v1/bff/agents/list?project_id=...` - List project agents
 - `GET /api/v1/designer/flows/{flowId}/skills` - List skills in flow
 - `GET /api/v1/designer/skills/{skillId}` - Get skill content

package/dist/akb.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedArticle, AkbImportArticle } from './types.js';
+/**
+ * Parse AKB file and extract articles
+ */
+export declare function parseAkbFile(filePath: string): ParsedArticle[];
+/**
+ * Convert parsed articles to API format for bulk import
+ */
+export declare function prepareArticlesForImport(articles: ParsedArticle[], personaId: string): AkbImportArticle[];
+//# sourceMappingURL=akb.d.ts.map

package/dist/akb.js

@@ -0,0 +1,84 @@
+import fs from 'fs-extra';
+/**
+ * Parse AKB file and extract articles
+ */
+export function parseAkbFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const articles = [];
+    // Split by article separators (---)
+    const sections = content.split(/^---\s*$/gm).filter(section => section.trim());
+    for (const section of sections) {
+        const lines = section.split('\n').filter(line => line.trim());
+        if (lines.length === 0)
+            continue;
+        const article = parseArticleSection(lines);
+        if (article) {
+            articles.push(article);
+        }
+    }
+    return articles;
+}
+/**
+ * Parse individual article section
+ */
+function parseArticleSection(lines) {
+    let topicName = '';
+    let category = '';
+    let summary = '';
+    let keywords = '';
+    let topicSummary = '';
+    // Find topic name (# r001)
+    const topicLine = lines.find(line => line.match(/^#\s+r\d+/));
+    if (!topicLine)
+        return null;
+    topicName = topicLine.replace(/^#\s+/, '').trim();
+    // Extract category/subcategory/description (first ## line)
+    const categoryLine = lines.find(line => line.startsWith('## ') && line.includes(' / '));
+    if (categoryLine) {
+        category = categoryLine.replace(/^##\s+/, '').trim();
+    }
+    // Extract summary (second ## line)
+    const summaryLineIndex = lines.findIndex(line => line.startsWith('## ') && line.includes(' / '));
+    if (summaryLineIndex >= 0 && summaryLineIndex + 1 < lines.length) {
+        const nextLine = lines[summaryLineIndex + 1];
+        if (nextLine && nextLine.startsWith('## ') && !nextLine.includes(' / ')) {
+            summary = nextLine.replace(/^##\s+/, '').trim();
+        }
+    }
+    // Extract keywords (third ## line)
+    const keywordsLineIndex = lines.findIndex((line, index) => index > summaryLineIndex + 1 && line.startsWith('## ') && !line.includes(' / '));
+    if (keywordsLineIndex >= 0) {
+        const keywordsLine = lines[keywordsLineIndex];
+        if (keywordsLine) {
+            keywords = keywordsLine.replace(/^##\s+/, '').trim();
+        }
+    }
+    // Extract category content
+    const categoryStartIndex = lines.findIndex(line => line.includes('<Category type='));
+    const categoryEndIndex = lines.findIndex(line => line.includes('</Category>'));
+    if (categoryStartIndex >= 0 && categoryEndIndex >= 0) {
+        const categoryLines = lines.slice(categoryStartIndex, categoryEndIndex + 1);
+        topicSummary = categoryLines.join('\n');
+    }
+    // Create topic_facts array
+    const topicFacts = [category, summary, keywords].filter(fact => fact.trim() !== '');
+    return {
+        topic_name: category, // Use the descriptive title as topic_name
+        persona_id: null, // Will be set when importing
+        topic_summary: topicSummary,
+        topic_facts: topicFacts,
+        confidence: 100,
+        source: topicName, // Use the ID (r001) as source
+        labels: ['rag_context']
+    };
+}
+/**
+ * Convert parsed articles to API format for bulk import
+ */
+export function prepareArticlesForImport(articles, personaId) {
+    return articles.map(article => ({
+        ...article,
+        persona_id: personaId
+    }));
+}
+//# sourceMappingURL=akb.js.map

package/dist/api.d.ts

@@ -0,0 +1,13 @@
+import { type AxiosInstance } from 'axios';
+import type { ProjectMeta, Agent, Skill, FlowEvent, FlowState, AkbImportArticle } from './types.js';
+export declare function makeClient(verbose?: boolean): Promise<AxiosInstance>;
+export declare function listProjects(client: AxiosInstance): Promise<ProjectMeta[]>;
+export declare function listAgents(client: AxiosInstance, projectId: string): Promise<Agent[]>;
+export declare function getProjectMeta(client: AxiosInstance, projectId: string): Promise<ProjectMeta>;
+export declare function listFlowSkills(client: AxiosInstance, flowId: string): Promise<Skill[]>;
+export declare function getSkill(client: AxiosInstance, skillId: string): Promise<Skill>;
+export declare function updateSkill(client: AxiosInstance, skillObject: Skill): Promise<void>;
+export declare function listFlowEvents(client: AxiosInstance, flowId: string): Promise<FlowEvent[]>;
+export declare function listFlowStates(client: AxiosInstance, flowId: string): Promise<FlowState[]>;
+export declare function importAkbArticle(client: AxiosInstance, articleData: AkbImportArticle): Promise<unknown>;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -0,0 +1,100 @@
+import axios from 'axios';
+import dotenv from 'dotenv';
+import { getValidAccessToken, forceReauth } from './auth.js';
+dotenv.config();
+const { NEWO_BASE_URL } = process.env;
+export async function makeClient(verbose = false) {
+    let accessToken = await getValidAccessToken();
+    if (verbose)
+        console.log('✓ Access token obtained');
+    if (!NEWO_BASE_URL) {
+        throw new Error('NEWO_BASE_URL is not set in environment variables');
+    }
+    const client = axios.create({
+        baseURL: NEWO_BASE_URL,
+        headers: { accept: 'application/json' }
+    });
+    client.interceptors.request.use(async (config) => {
+        config.headers = config.headers || {};
+        config.headers.Authorization = `Bearer ${accessToken}`;
+        if (verbose) {
+            console.log(`→ ${config.method?.toUpperCase()} ${config.url}`);
+            if (config.data)
+                console.log('  Data:', JSON.stringify(config.data, null, 2));
+            if (config.params)
+                console.log('  Params:', config.params);
+        }
+        return config;
+    });
+    let retried = false;
+    client.interceptors.response.use((response) => {
+        if (verbose) {
+            console.log(`← ${response.status} ${response.config.method?.toUpperCase()} ${response.config.url}`);
+            if (response.data && Object.keys(response.data).length < 20) {
+                console.log('  Response:', JSON.stringify(response.data, null, 2));
+            }
+            else if (response.data) {
+                console.log(`  Response: [${typeof response.data}] ${Array.isArray(response.data) ? response.data.length + ' items' : 'large object'}`);
+            }
+        }
+        return response;
+    }, async (error) => {
+        const status = error?.response?.status;
+        if (verbose) {
+            console.log(`← ${status} ${error.config?.method?.toUpperCase()} ${error.config?.url} - ${error.message}`);
+            if (error.response?.data)
+                console.log('  Error data:', error.response.data);
+        }
+        if (status === 401 && !retried) {
+            retried = true;
+            if (verbose)
+                console.log('🔄 Retrying with fresh token...');
+            accessToken = await forceReauth();
+            if (error.config) {
+                error.config.headers = error.config.headers || {};
+                error.config.headers.Authorization = `Bearer ${accessToken}`;
+                return client.request(error.config);
+            }
+        }
+        throw error;
+    });
+    return client;
+}
+export async function listProjects(client) {
+    const response = await client.get('/api/v1/designer/projects');
+    return response.data;
+}
+export async function listAgents(client, projectId) {
+    const response = await client.get('/api/v1/bff/agents/list', {
+        params: { project_id: projectId }
+    });
+    return response.data;
+}
+export async function getProjectMeta(client, projectId) {
+    const response = await client.get(`/api/v1/designer/projects/by-id/${projectId}`);
+    return response.data;
+}
+export async function listFlowSkills(client, flowId) {
+    const response = await client.get(`/api/v1/designer/flows/${flowId}/skills`);
+    return response.data;
+}
+export async function getSkill(client, skillId) {
+    const response = await client.get(`/api/v1/designer/skills/${skillId}`);
+    return response.data;
+}
+export async function updateSkill(client, skillObject) {
+    await client.put(`/api/v1/designer/flows/skills/${skillObject.id}`, skillObject);
+}
+export async function listFlowEvents(client, flowId) {
+    const response = await client.get(`/api/v1/designer/flows/${flowId}/events`);
+    return response.data;
+}
+export async function listFlowStates(client, flowId) {
+    const response = await client.get(`/api/v1/designer/flows/${flowId}/states`);
+    return response.data;
+}
+export async function importAkbArticle(client, articleData) {
+    const response = await client.post('/api/v1/akb/append-manual', articleData);
+    return response.data;
+}
+//# sourceMappingURL=api.js.map

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+import type { StoredTokens } from './types.js';
+export declare function exchangeApiKeyForToken(): Promise<StoredTokens>;
+export declare function refreshWithEndpoint(refreshToken: string): Promise<StoredTokens>;
+export declare function getValidAccessToken(): Promise<string>;
+export declare function forceReauth(): Promise<string>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,104 @@
+import fs from 'fs-extra';
+import path from 'path';
+import axios from 'axios';
+import dotenv from 'dotenv';
+dotenv.config();
+const { NEWO_BASE_URL, NEWO_API_KEY, NEWO_ACCESS_TOKEN, NEWO_REFRESH_TOKEN, NEWO_REFRESH_URL } = process.env;
+const STATE_DIR = path.join(process.cwd(), '.newo');
+const TOKENS_PATH = path.join(STATE_DIR, 'tokens.json');
+async function saveTokens(tokens) {
+    await fs.ensureDir(STATE_DIR);
+    await fs.writeJson(TOKENS_PATH, tokens, { spaces: 2 });
+}
+async function loadTokens() {
+    if (await fs.pathExists(TOKENS_PATH)) {
+        return fs.readJson(TOKENS_PATH);
+    }
+    if (NEWO_ACCESS_TOKEN || NEWO_REFRESH_TOKEN) {
+        const tokens = {
+            access_token: NEWO_ACCESS_TOKEN || '',
+            refresh_token: NEWO_REFRESH_TOKEN || '',
+            expires_at: Date.now() + 10 * 60 * 1000
+        };
+        await saveTokens(tokens);
+        return tokens;
+    }
+    return null;
+}
+function isExpired(tokens) {
+    if (!tokens?.expires_at)
+        return false;
+    return Date.now() >= tokens.expires_at - 10_000;
+}
+export async function exchangeApiKeyForToken() {
+    if (!NEWO_API_KEY) {
+        throw new Error('NEWO_API_KEY not set. Provide an API key in .env');
+    }
+    const url = `${NEWO_BASE_URL}/api/v1/auth/api-key/token`;
+    const response = await axios.post(url, {}, {
+        headers: {
+            'x-api-key': NEWO_API_KEY,
+            'accept': 'application/json'
+        }
+    });
+    const data = response.data;
+    const access = data.access_token || data.token || data.accessToken;
+    const refresh = data.refresh_token || data.refreshToken || '';
+    const expiresInSec = data.expires_in || data.expiresIn || 3600;
+    if (!access) {
+        throw new Error('Failed to get access token from API key exchange');
+    }
+    const tokens = {
+        access_token: access,
+        refresh_token: refresh,
+        expires_at: Date.now() + expiresInSec * 1000
+    };
+    await saveTokens(tokens);
+    return tokens;
+}
+export async function refreshWithEndpoint(refreshToken) {
+    if (!NEWO_REFRESH_URL) {
+        throw new Error('NEWO_REFRESH_URL not set');
+    }
+    const response = await axios.post(NEWO_REFRESH_URL, { refresh_token: refreshToken }, { headers: { 'accept': 'application/json' } });
+    const data = response.data;
+    const access = data.access_token || data.token || data.accessToken;
+    const refresh = data.refresh_token ?? refreshToken;
+    const expiresInSec = data.expires_in || 3600;
+    if (!access) {
+        throw new Error('Failed to get access token from refresh');
+    }
+    const tokens = {
+        access_token: access,
+        refresh_token: refresh,
+        expires_at: Date.now() + expiresInSec * 1000
+    };
+    await saveTokens(tokens);
+    return tokens;
+}
+export async function getValidAccessToken() {
+    let tokens = await loadTokens();
+    if (!tokens || !tokens.access_token) {
+        tokens = await exchangeApiKeyForToken();
+        return tokens.access_token;
+    }
+    if (!isExpired(tokens)) {
+        return tokens.access_token;
+    }
+    if (NEWO_REFRESH_URL && tokens.refresh_token) {
+        try {
+            tokens = await refreshWithEndpoint(tokens.refresh_token);
+            return tokens.access_token;
+        }
+        catch (error) {
+            console.warn('Refresh failed, falling back to API key exchange…');
+        }
+    }
+    tokens = await exchangeApiKeyForToken();
+    return tokens.access_token;
+}
+export async function forceReauth() {
+    const tokens = await exchangeApiKeyForToken();
+    return tokens.access_token;
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map