newo 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -5,6 +5,47 @@ 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.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

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
@@ -113,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 }}
@@ -155,6 +156,45 @@ 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

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

package/dist/cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import dotenv from 'dotenv';
+import { makeClient, getProjectMeta, importAkbArticle } from './api.js';
+import { pullAll, pushChanged, status } from './sync.js';
+import { parseAkbFile, prepareArticlesForImport } from './akb.js';
+import path from 'path';
+dotenv.config();
+const { NEWO_PROJECT_ID } = process.env;
+async function main() {
+    const args = minimist(process.argv.slice(2));
+    const cmd = args._[0];
+    const verbose = Boolean(args.verbose || args.v);
+    if (!cmd || ['help', '-h', '--help'].includes(cmd)) {
+        console.log(`NEWO CLI
+Usage:
+  newo pull                    # download all projects -> ./projects/ OR specific project if NEWO_PROJECT_ID set
+  newo push                    # upload modified *.guidance/*.jinja back to NEWO
+  newo status                  # show modified files
+  newo meta                    # get project metadata (debug, requires NEWO_PROJECT_ID)
+  newo import-akb <file> <persona_id>  # import AKB articles from file
+  
+Flags:
+  --verbose, -v                # enable detailed logging
+  
+Env:
+  NEWO_BASE_URL, NEWO_PROJECT_ID (optional), NEWO_API_KEY, NEWO_REFRESH_URL (optional)
+  
+Notes:
+  - multi-project support: pull downloads all accessible projects or single project based on NEWO_PROJECT_ID
+  - If NEWO_PROJECT_ID is set, pull downloads only that project
+  - If NEWO_PROJECT_ID is not set, pull downloads all projects accessible with your API key
+  - Projects are stored in ./projects/{project-idn}/ folders
+  - Each project folder contains metadata.json and flows.yaml
+`);
+        return;
+    }
+    const client = await makeClient(verbose);
+    if (cmd === 'pull') {
+        // If PROJECT_ID is set, pull single project; otherwise pull all projects
+        await pullAll(client, NEWO_PROJECT_ID || null, verbose);
+    }
+    else if (cmd === 'push') {
+        await pushChanged(client, verbose);
+    }
+    else if (cmd === 'status') {
+        await status(verbose);
+    }
+    else if (cmd === 'meta') {
+        if (!NEWO_PROJECT_ID) {
+            throw new Error('NEWO_PROJECT_ID is not set in env');
+        }
+        const meta = await getProjectMeta(client, NEWO_PROJECT_ID);
+        console.log(JSON.stringify(meta, null, 2));
+    }
+    else if (cmd === 'import-akb') {
+        const akbFile = args._[1];
+        const personaId = args._[2];
+        if (!akbFile || !personaId) {
+            console.error('Usage: newo import-akb <file> <persona_id>');
+            console.error('Example: newo import-akb akb.txt da4550db-2b95-4500-91ff-fb4b60fe7be9');
+            process.exit(1);
+        }
+        const filePath = path.resolve(akbFile);
+        try {
+            if (verbose)
+                console.log(`📖 Parsing AKB file: ${filePath}`);
+            const articles = parseAkbFile(filePath);
+            console.log(`✓ Parsed ${articles.length} articles from ${akbFile}`);
+            if (verbose)
+                console.log(`🔧 Preparing articles for persona: ${personaId}`);
+            const preparedArticles = prepareArticlesForImport(articles, personaId);
+            let successCount = 0;
+            let errorCount = 0;
+            console.log(`📤 Importing ${preparedArticles.length} articles...`);
+            for (const [index, article] of preparedArticles.entries()) {
+                try {
+                    if (verbose) {
+                        console.log(`  [${index + 1}/${preparedArticles.length}] Importing ${article.topic_name}...`);
+                    }
+                    await importAkbArticle(client, article);
+                    successCount++;
+                    if (!verbose)
+                        process.stdout.write('.');
+                }
+                catch (error) {
+                    errorCount++;
+                    const errorMessage = error?.response?.data || error.message;
+                    console.error(`\n❌ Failed to import ${article.topic_name}:`, errorMessage);
+                }
+            }
+            if (!verbose)
+                console.log(''); // new line after dots
+            console.log(`✅ Import complete: ${successCount} successful, ${errorCount} failed`);
+        }
+        catch (error) {
+            console.error('❌ AKB import failed:', error.message);
+            process.exit(1);
+        }
+    }
+    else {
+        console.error('Unknown command:', cmd);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    const errorData = 'response' in error ? error?.response?.data : error;
+    console.error(errorData || error);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/fsutil.d.ts

@@ -0,0 +1,12 @@
+import type { RunnerType } from './types.js';
+export declare const ROOT_DIR: string;
+export declare const STATE_DIR: string;
+export declare const MAP_PATH: string;
+export declare const HASHES_PATH: string;
+export declare function ensureState(): Promise<void>;
+export declare function projectDir(projectIdn: string): string;
+export declare function skillPath(projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType?: RunnerType): string;
+export declare function metadataPath(projectIdn: string): string;
+export declare function writeFileAtomic(filepath: string, content: string): Promise<void>;
+export declare function readIfExists(filepath: string): Promise<string | null>;
+//# sourceMappingURL=fsutil.d.ts.map

package/dist/fsutil.js

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+import path from 'path';
+export const ROOT_DIR = path.join(process.cwd(), 'projects');
+export const STATE_DIR = path.join(process.cwd(), '.newo');
+export const MAP_PATH = path.join(STATE_DIR, 'map.json');
+export const HASHES_PATH = path.join(STATE_DIR, 'hashes.json');
+export async function ensureState() {
+    await fs.ensureDir(STATE_DIR);
+    await fs.ensureDir(ROOT_DIR);
+}
+export function projectDir(projectIdn) {
+    return path.join(ROOT_DIR, projectIdn);
+}
+export function skillPath(projectIdn, agentIdn, flowIdn, skillIdn, runnerType = 'guidance') {
+    const extension = runnerType === 'nsl' ? '.jinja' : '.guidance';
+    return path.join(ROOT_DIR, projectIdn, agentIdn, flowIdn, `${skillIdn}${extension}`);
+}
+export function metadataPath(projectIdn) {
+    return path.join(ROOT_DIR, projectIdn, 'metadata.json');
+}
+export async function writeFileAtomic(filepath, content) {
+    await fs.ensureDir(path.dirname(filepath));
+    await fs.writeFile(filepath, content, 'utf8');
+}
+export async function readIfExists(filepath) {
+    return (await fs.pathExists(filepath)) ? fs.readFile(filepath, 'utf8') : null;
+}
+//# sourceMappingURL=fsutil.js.map

package/dist/hash.d.ts

@@ -0,0 +1,5 @@
+import type { HashStore } from './types.js';
+export declare function sha256(str: string): string;
+export declare function loadHashes(): Promise<HashStore>;
+export declare function saveHashes(hashes: HashStore): Promise<void>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.js

@@ -0,0 +1,17 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+import { ensureState, HASHES_PATH } from './fsutil.js';
+export function sha256(str) {
+    return crypto.createHash('sha256').update(str, 'utf8').digest('hex');
+}
+export async function loadHashes() {
+    await ensureState();
+    if (await fs.pathExists(HASHES_PATH)) {
+        return fs.readJson(HASHES_PATH);
+    }
+    return {};
+}
+export async function saveHashes(hashes) {
+    await fs.writeJson(HASHES_PATH, hashes, { spaces: 2 });
+}
+//# sourceMappingURL=hash.js.map

package/dist/sync.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosInstance } from 'axios';
+import type { ProjectData } from './types.js';
+export declare function pullSingleProject(client: AxiosInstance, projectId: string, projectIdn: string, verbose?: boolean): Promise<ProjectData>;
+export declare function pullAll(client: AxiosInstance, projectId?: string | null, verbose?: boolean): Promise<void>;
+export declare function pushChanged(client: AxiosInstance, verbose?: boolean): Promise<void>;
+export declare function status(verbose?: boolean): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map