newo 1.9.1 → 2.0.0

package/dist/sync/projects.js

@@ -0,0 +1,283 @@
+/**
+ * Project synchronization operations
+ */
+import { listProjects, listAgents, listFlowSkills, listFlowEvents, listFlowStates } from '../api.js';
+import { ensureState, writeFileSafe, mapPath, projectMetadataPath, agentMetadataPath, flowMetadataPath, skillMetadataPath, skillScriptPath, skillFolderPath, flowsYamlPath, customerAttributesPath } from '../fsutil.js';
+import { findSkillScriptFiles, isContentDifferent, askForOverwrite, getExtensionForRunner } from './skill-files.js';
+import fs from 'fs-extra';
+import { sha256, saveHashes } from '../hash.js';
+import yaml from 'js-yaml';
+import { generateFlowsYaml } from './metadata.js';
+import { saveCustomerAttributes } from './attributes.js';
+// Type guards for project map formats
+export function isProjectMap(x) {
+    return typeof x === 'object' && x !== null && 'projects' in x;
+}
+export function isLegacyProjectMap(x) {
+    return typeof x === 'object' && x !== null && 'projectId' in x && 'agents' in x;
+}
+/**
+ * Pull a single project and all its data
+ */
+export async function pullSingleProject(client, customer, projectId, verbose = false, silentOverwrite = false) {
+    if (verbose)
+        console.log(`📋 Loading project list for customer ${customer.idn}...`);
+    const projects = projectId ?
+        [{ id: projectId, idn: 'unknown', title: 'Project' }] :
+        await listProjects(client);
+    if (projects.length === 0) {
+        console.log(`No projects found for customer ${customer.idn}`);
+        return;
+    }
+    await ensureState(customer.idn);
+    // Load existing mappings if they exist
+    let existingMap = { projects: {} };
+    const mapFile = mapPath(customer.idn);
+    if (await fs.pathExists(mapFile)) {
+        const mapData = await fs.readJson(mapFile);
+        if (isProjectMap(mapData)) {
+            existingMap = mapData;
+        }
+        else if (isLegacyProjectMap(mapData)) {
+            // Convert legacy format to new format
+            existingMap = {
+                projects: {
+                    [mapData.projectIdn || '']: mapData
+                }
+            };
+        }
+    }
+    const newHashes = {};
+    // Progress tracking
+    let totalSkills = 0;
+    let processedSkills = 0;
+    // Count total skills for progress tracking
+    for (const project of projects) {
+        const agents = await listAgents(client, project.id);
+        for (const agent of agents) {
+            const flows = agent.flows || [];
+            for (const flow of flows) {
+                const skills = await listFlowSkills(client, flow.id);
+                totalSkills += skills.length;
+            }
+        }
+    }
+    if (verbose)
+        console.log(`📊 Total skills to process: ${totalSkills}`);
+    for (const project of projects) {
+        if (verbose)
+            console.log(`📁 Processing project: ${project.title} (${project.idn})`);
+        // Create project metadata
+        const projectMeta = {
+            id: project.id,
+            idn: project.idn,
+            title: project.title,
+            description: project.description || '',
+            created_at: project.created_at || '',
+            updated_at: project.updated_at || ''
+        };
+        // Save project metadata
+        const projectMetaPath = projectMetadataPath(customer.idn, project.idn);
+        const projectMetaYaml = yaml.dump(projectMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+        await writeFileSafe(projectMetaPath, projectMetaYaml);
+        newHashes[projectMetaPath] = sha256(projectMetaYaml);
+        const agents = await listAgents(client, project.id);
+        if (verbose)
+            console.log(`  📋 Found ${agents.length} agents in project ${project.title}`);
+        const projectData = {
+            projectId: project.id,
+            projectIdn: project.idn,
+            agents: {}
+        };
+        for (const agent of agents) {
+            if (verbose)
+                console.log(`  📁 Processing agent: ${agent.title} (${agent.idn})`);
+            // Create agent metadata
+            const agentMeta = {
+                id: agent.id,
+                idn: agent.idn,
+                title: agent.title || '',
+                description: agent.description || ''
+            };
+            // Save agent metadata
+            const agentMetaPath = agentMetadataPath(customer.idn, project.idn, agent.idn);
+            const agentMetaYaml = yaml.dump(agentMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+            await writeFileSafe(agentMetaPath, agentMetaYaml);
+            newHashes[agentMetaPath] = sha256(agentMetaYaml);
+            projectData.agents[agent.idn] = {
+                id: agent.id,
+                flows: {}
+            };
+            const flows = agent.flows || [];
+            if (verbose && flows.length > 0) {
+                console.log(`    📋 Found ${flows.length} flows in agent ${agent.title}`);
+            }
+            for (const flow of flows) {
+                if (verbose)
+                    console.log(`    📁 Processing flow: ${flow.title} (${flow.idn})`);
+                // Get flow events and states for metadata
+                const [events, states] = await Promise.all([
+                    listFlowEvents(client, flow.id).catch(() => []),
+                    listFlowStates(client, flow.id).catch(() => [])
+                ]);
+                // Create flow metadata
+                const flowMeta = {
+                    id: flow.id,
+                    idn: flow.idn,
+                    title: flow.title,
+                    description: flow.description || '',
+                    default_runner_type: flow.default_runner_type,
+                    default_model: flow.default_model,
+                    events,
+                    state_fields: states
+                };
+                // Save flow metadata
+                const flowMetaPath = flowMetadataPath(customer.idn, project.idn, agent.idn, flow.idn);
+                const flowMetaYaml = yaml.dump(flowMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+                await writeFileSafe(flowMetaPath, flowMetaYaml);
+                newHashes[flowMetaPath] = sha256(flowMetaYaml);
+                projectData.agents[agent.idn].flows[flow.idn] = {
+                    id: flow.id,
+                    skills: {}
+                };
+                const skills = await listFlowSkills(client, flow.id);
+                if (verbose)
+                    console.log(`      📋 Found ${skills.length} skills in flow ${flow.title}`);
+                for (const skill of skills) {
+                    processedSkills++;
+                    const progress = `[${processedSkills}/${totalSkills}]`;
+                    if (verbose) {
+                        console.log(`      📄 ${progress} Processing skill: ${skill.title} (${skill.idn})`);
+                    }
+                    else {
+                        // Show progress for non-verbose mode
+                        if (processedSkills % 10 === 0 || processedSkills === totalSkills) {
+                            process.stdout.write(`\r📄 Processing skills: ${processedSkills}/${totalSkills} (${Math.round(processedSkills / totalSkills * 100)}%)`);
+                        }
+                    }
+                    // Create skill metadata
+                    const skillMeta = {
+                        id: skill.id,
+                        idn: skill.idn,
+                        title: skill.title,
+                        runner_type: skill.runner_type,
+                        model: skill.model,
+                        parameters: [...skill.parameters],
+                        path: skill.path
+                    };
+                    // Save skill metadata
+                    const skillMetaPath = skillMetadataPath(customer.idn, project.idn, agent.idn, flow.idn, skill.idn);
+                    const skillMetaYaml = yaml.dump(skillMeta, { indent: 2, quotingType: '"', forceQuotes: false });
+                    await writeFileSafe(skillMetaPath, skillMetaYaml);
+                    newHashes[skillMetaPath] = sha256(skillMetaYaml);
+                    // Handle skill script with IDN-based naming and overwrite detection
+                    const scriptContent = skill.prompt_script || '';
+                    const targetScriptPath = skillScriptPath(customer.idn, project.idn, agent.idn, flow.idn, skill.idn, skill.runner_type);
+                    const folderPath = skillFolderPath(customer.idn, project.idn, agent.idn, flow.idn, skill.idn);
+                    // Check for existing script files in the skill folder
+                    const existingFiles = await findSkillScriptFiles(folderPath);
+                    let shouldWrite = true;
+                    let hasContentMatch = false;
+                    if (existingFiles.length > 0) {
+                        // Check if any existing file has the same content
+                        hasContentMatch = existingFiles.some(file => !isContentDifferent(file.content, scriptContent));
+                        if (hasContentMatch) {
+                            // Content is the same - remove old files and write with correct IDN name
+                            const matchingFile = existingFiles.find(file => !isContentDifferent(file.content, scriptContent));
+                            const correctName = `${skill.idn}.${getExtensionForRunner(skill.runner_type)}`;
+                            if (matchingFile && matchingFile.fileName !== correctName) {
+                                // Remove old file and write with correct IDN-based name
+                                await fs.remove(matchingFile.filePath);
+                                if (verbose)
+                                    console.log(`        🔄 Renamed ${matchingFile.fileName} → ${correctName}`);
+                            }
+                            else if (matchingFile && matchingFile.fileName === correctName) {
+                                // Already has correct name and content
+                                shouldWrite = false;
+                                newHashes[matchingFile.filePath] = sha256(scriptContent);
+                                if (verbose)
+                                    console.log(`        ✓ Content unchanged for ${skill.idn}, keeping existing file`);
+                            }
+                        }
+                        else if (!silentOverwrite) {
+                            // Content is different, ask for overwrite
+                            const existingFile = existingFiles[0];
+                            const shouldOverwrite = await askForOverwrite(skill.idn, existingFile.fileName, `${skill.idn}.${getExtensionForRunner(skill.runner_type)}`);
+                            if (!shouldOverwrite) {
+                                shouldWrite = false;
+                                if (verbose)
+                                    console.log(`        ⚠️  Skipped overwrite for ${skill.idn}`);
+                            }
+                            else {
+                                // Remove existing files before writing new one
+                                for (const file of existingFiles) {
+                                    await fs.remove(file.filePath);
+                                    if (verbose)
+                                        console.log(`        🗑️  Removed ${file.fileName}`);
+                                }
+                            }
+                        }
+                        else {
+                            // Silent overwrite mode - remove existing files
+                            for (const file of existingFiles) {
+                                await fs.remove(file.filePath);
+                                if (verbose)
+                                    console.log(`        🔄 Silent overwrite: removed ${file.fileName}`);
+                            }
+                        }
+                    }
+                    if (shouldWrite) {
+                        await writeFileSafe(targetScriptPath, scriptContent);
+                        newHashes[targetScriptPath] = sha256(scriptContent);
+                        const fileName = `${skill.idn}.${getExtensionForRunner(skill.runner_type)}`;
+                        if (verbose)
+                            console.log(`        ✓ Saved ${fileName}`);
+                    }
+                    projectData.agents[agent.idn].flows[flow.idn].skills[skill.idn] = skillMeta;
+                }
+            }
+        }
+        // Store project data in map
+        existingMap.projects[project.idn] = projectData;
+    }
+    // Clear progress line for non-verbose mode
+    if (!verbose && totalSkills > 0) {
+        console.log(`\n✅ Processed ${totalSkills} skills`);
+    }
+    // Save updated project map
+    await writeFileSafe(mapFile, JSON.stringify(existingMap, null, 2));
+    // Pull customer attributes as part of the project pull
+    try {
+        if (verbose)
+            console.log(`🔍 Fetching customer attributes for ${customer.idn}...`);
+        const attributesContent = await saveCustomerAttributes(client, customer, verbose);
+        // Add attributes.yaml hash to the hash store
+        const attributesPath = customerAttributesPath(customer.idn);
+        newHashes[attributesPath] = sha256(attributesContent);
+        if (verbose)
+            console.log(`✅ Customer attributes saved to newo_customers/${customer.idn}/attributes.yaml`);
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to fetch customer attributes for ${customer.idn}: ${error instanceof Error ? error.message : String(error)}`);
+        if (verbose)
+            console.warn('You can manually pull attributes using: newo pull-attributes');
+    }
+    // Generate flows.yaml and get its content for hashing
+    const flowsYamlContent = await generateFlowsYaml(existingMap, customer.idn, verbose);
+    // Add flows.yaml hash to the hash store
+    const flowsYamlFilePath = flowsYamlPath(customer.idn);
+    newHashes[flowsYamlFilePath] = sha256(flowsYamlContent);
+    // Save hashes (now including flows.yaml and attributes.yaml)
+    await saveHashes(newHashes, customer.idn);
+}
+/**
+ * Pull all projects for a customer
+ */
+export async function pullAll(client, customer, projectId = null, verbose = false, silentOverwrite = false) {
+    if (verbose)
+        console.log(`🔄 Starting pull operation for customer ${customer.idn}...`);
+    await pullSingleProject(client, customer, projectId, verbose, silentOverwrite);
+    if (verbose)
+        console.log(`✅ Pull completed for customer ${customer.idn}`);
+}
+//# sourceMappingURL=projects.js.map

package/dist/sync/push.d.ts

@@ -0,0 +1,7 @@
+import type { AxiosInstance } from 'axios';
+import type { CustomerConfig } from '../types.js';
+/**
+ * Push changed files to NEWO platform
+ */
+export declare function pushChanged(client: AxiosInstance, customer: CustomerConfig, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=push.d.ts.map

package/dist/sync/push.js

@@ -0,0 +1,171 @@
+/**
+ * Push operations for changed files
+ */
+import { updateSkill } from '../api.js';
+import { ensureState, mapPath, skillMetadataPath } from '../fsutil.js';
+import { validateSkillFolder, getSingleSkillFile } from './skill-files.js';
+import fs from 'fs-extra';
+import { sha256, loadHashes, saveHashes } from '../hash.js';
+import yaml from 'js-yaml';
+import { generateFlowsYaml } from './metadata.js';
+import { isProjectMap, isLegacyProjectMap } from './projects.js';
+import { flowsYamlPath } from '../fsutil.js';
+/**
+ * Push changed files to NEWO platform
+ */
+export async function pushChanged(client, customer, verbose = false) {
+    await ensureState(customer.idn);
+    if (!(await fs.pathExists(mapPath(customer.idn)))) {
+        console.log(`No map for customer ${customer.idn}. Run \`newo pull --customer ${customer.idn}\` first.`);
+        return;
+    }
+    if (verbose)
+        console.log(`📋 Loading project mapping and hashes for customer ${customer.idn}...`);
+    const idMapData = await fs.readJson(mapPath(customer.idn));
+    const hashes = await loadHashes(customer.idn);
+    const newHashes = { ...hashes };
+    let pushed = 0;
+    let scanned = 0;
+    let metadataChanged = false;
+    // Handle both old single-project format and new multi-project format with type guards
+    const projects = isProjectMap(idMapData) && idMapData.projects
+        ? idMapData.projects
+        : isLegacyProjectMap(idMapData)
+            ? { '': idMapData }
+            : (() => { throw new Error('Invalid project map format'); })();
+    for (const [projectIdn, projectData] of Object.entries(projects)) {
+        if (verbose && projectIdn)
+            console.log(`📁 Checking project: ${projectIdn}`);
+        for (const [agentIdn, agentObj] of Object.entries(projectData.agents)) {
+            if (verbose)
+                console.log(`  📁 Checking agent: ${agentIdn}`);
+            for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+                if (verbose)
+                    console.log(`    📁 Checking flow: ${flowIdn}`);
+                for (const [skillIdn, skillMeta] of Object.entries(flowObj.skills)) {
+                    scanned++;
+                    // Validate skill folder has exactly one script file
+                    const validation = await validateSkillFolder(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);
+                    if (!validation.isValid) {
+                        // Show warnings and errors
+                        validation.errors.forEach(error => {
+                            console.error(`❌ ${error}`);
+                        });
+                        validation.warnings.forEach(warning => {
+                            console.warn(`⚠️  ${warning}`);
+                        });
+                        if (validation.files.length > 1) {
+                            console.warn(`⚠️  Skipping push for skill ${skillIdn} - multiple script files found:`);
+                            validation.files.forEach(file => {
+                                console.warn(`   • ${file.fileName}`);
+                            });
+                            console.warn(`   Please keep only one script file and try again.`);
+                        }
+                        continue;
+                    }
+                    // Get the single valid script file
+                    const skillFile = await getSingleSkillFile(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);
+                    if (!skillFile) {
+                        if (verbose)
+                            console.log(`      ❌ No valid script file found for: ${skillIdn}`);
+                        continue;
+                    }
+                    const content = skillFile.content;
+                    const currentPath = skillFile.filePath;
+                    const h = sha256(content);
+                    const oldHash = hashes[currentPath];
+                    if (oldHash !== h) {
+                        if (verbose)
+                            console.log(`🔄 Script changed, updating: ${skillIdn} (${skillFile.fileName})`);
+                        try {
+                            // Create skill object for update
+                            const skillObject = {
+                                id: skillMeta.id,
+                                title: skillMeta.title,
+                                idn: skillMeta.idn,
+                                prompt_script: content,
+                                runner_type: skillMeta.runner_type,
+                                model: skillMeta.model,
+                                parameters: skillMeta.parameters,
+                                path: skillMeta.path || undefined
+                            };
+                            await updateSkill(client, skillObject);
+                            console.log(`↑ Pushed: ${skillIdn} (${skillMeta.title}) from ${skillFile.fileName}`);
+                            newHashes[currentPath] = h;
+                            pushed++;
+                        }
+                        catch (error) {
+                            console.error(`❌ Failed to push ${skillIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    else if (verbose) {
+                        console.log(`      ✓ No changes: ${skillIdn} (${skillFile.fileName})`);
+                    }
+                }
+                // Check for metadata-only changes and push them separately
+                for (const [skillIdn] of Object.entries(flowObj.skills)) {
+                    const metadataPath = projectIdn ?
+                        skillMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn) :
+                        skillMetadataPath(customer.idn, '', agentIdn, flowIdn, skillIdn);
+                    if (await fs.pathExists(metadataPath)) {
+                        const metadataContent = await fs.readFile(metadataPath, 'utf8');
+                        const h = sha256(metadataContent);
+                        const oldHash = hashes[metadataPath];
+                        if (oldHash !== h) {
+                            if (verbose)
+                                console.log(`🔄 Metadata-only change detected for ${skillIdn}, updating skill...`);
+                            try {
+                                // Load updated metadata
+                                const updatedMetadata = yaml.load(metadataContent);
+                                // Get current script content using file validation
+                                const skillFile = await getSingleSkillFile(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);
+                                let scriptContent = '';
+                                if (skillFile) {
+                                    scriptContent = skillFile.content;
+                                }
+                                else {
+                                    console.warn(`⚠️  No valid script file found for metadata update: ${skillIdn}`);
+                                    continue;
+                                }
+                                // Create skill object with updated metadata
+                                const skillObject = {
+                                    id: updatedMetadata.id,
+                                    title: updatedMetadata.title,
+                                    idn: updatedMetadata.idn,
+                                    prompt_script: scriptContent,
+                                    runner_type: updatedMetadata.runner_type,
+                                    model: updatedMetadata.model,
+                                    parameters: updatedMetadata.parameters,
+                                    path: updatedMetadata.path || undefined
+                                };
+                                await updateSkill(client, skillObject);
+                                console.log(`↑ Pushed metadata update for skill: ${skillIdn} (${updatedMetadata.title})`);
+                                newHashes[metadataPath] = h;
+                                pushed++;
+                                metadataChanged = true;
+                            }
+                            catch (error) {
+                                console.error(`❌ Failed to push metadata for ${skillIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (verbose)
+        console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
+    // Regenerate flows.yaml if metadata was changed
+    if (metadataChanged) {
+        if (verbose)
+            console.log(`🔄 Regenerating flows.yaml due to metadata changes...`);
+        const flowsYamlContent = await generateFlowsYaml({ projects }, customer.idn, verbose);
+        // Update hash for flows.yaml
+        const flowsYamlFilePath = flowsYamlPath(customer.idn);
+        newHashes[flowsYamlFilePath] = sha256(flowsYamlContent);
+    }
+    // Save updated hashes
+    await saveHashes(newHashes, customer.idn);
+    console.log(pushed ? `${pushed} file(s) pushed.` : 'No changes to push.');
+}
+//# sourceMappingURL=push.js.map

package/dist/sync/skill-files.d.ts

@@ -0,0 +1,42 @@
+import type { RunnerType } from '../types.js';
+export interface SkillFile {
+    filePath: string;
+    fileName: string;
+    extension: string;
+    content: string;
+}
+export interface SkillFileValidation {
+    isValid: boolean;
+    files: SkillFile[];
+    warnings: string[];
+    errors: string[];
+}
+/**
+ * Get the correct file extension for a runner type
+ */
+export declare function getExtensionForRunner(runnerType: RunnerType): string;
+/**
+ * Generate IDN-based script file path
+ */
+export declare function getIdnBasedScriptPath(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string, runnerType: RunnerType): string;
+/**
+ * Find all script files in a skill folder
+ */
+export declare function findSkillScriptFiles(skillFolderPath: string): Promise<SkillFile[]>;
+/**
+ * Validate skill folder has exactly one script file
+ */
+export declare function validateSkillFolder(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string): Promise<SkillFileValidation>;
+/**
+ * Get the single skill script file (if valid)
+ */
+export declare function getSingleSkillFile(customerIdn: string, projectIdn: string, agentIdn: string, flowIdn: string, skillIdn: string): Promise<SkillFile | null>;
+/**
+ * Check if skill script content is different from target content
+ */
+export declare function isContentDifferent(existingContent: string, newContent: string): boolean;
+/**
+ * Interactive overwrite confirmation
+ */
+export declare function askForOverwrite(skillIdn: string, existingFile: string, newFile: string): Promise<boolean>;
+//# sourceMappingURL=skill-files.d.ts.map

package/dist/sync/skill-files.js

@@ -0,0 +1,121 @@
+/**
+ * Skill file management utilities
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { sha256 } from '../hash.js';
+import { skillFolderPath } from '../fsutil.js';
+/**
+ * Get the correct file extension for a runner type
+ */
+export function getExtensionForRunner(runnerType) {
+    switch (runnerType) {
+        case 'guidance':
+            return 'guidance';
+        case 'nsl':
+            return 'jinja';
+        default:
+            return 'guidance';
+    }
+}
+/**
+ * Generate IDN-based script file path
+ */
+export function getIdnBasedScriptPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn, runnerType) {
+    const extension = getExtensionForRunner(runnerType);
+    const folderPath = skillFolderPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn);
+    return path.join(folderPath, `${skillIdn}.${extension}`);
+}
+/**
+ * Find all script files in a skill folder
+ */
+export async function findSkillScriptFiles(skillFolderPath) {
+    if (!(await fs.pathExists(skillFolderPath))) {
+        return [];
+    }
+    const files = await fs.readdir(skillFolderPath);
+    const scriptFiles = [];
+    for (const fileName of files) {
+        const filePath = path.join(skillFolderPath, fileName);
+        const stats = await fs.stat(filePath);
+        if (stats.isFile()) {
+            const ext = path.extname(fileName).toLowerCase();
+            // Check for script file extensions
+            if (['.jinja', '.guidance', '.nsl'].includes(ext)) {
+                const content = await fs.readFile(filePath, 'utf8');
+                scriptFiles.push({
+                    filePath,
+                    fileName,
+                    extension: ext.slice(1), // Remove the dot
+                    content
+                });
+            }
+        }
+    }
+    return scriptFiles;
+}
+/**
+ * Validate skill folder has exactly one script file
+ */
+export async function validateSkillFolder(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn) {
+    const folderPath = skillFolderPath(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn);
+    const files = await findSkillScriptFiles(folderPath);
+    const warnings = [];
+    const errors = [];
+    if (files.length === 0) {
+        errors.push(`No script files found in skill folder: ${skillIdn}`);
+    }
+    else if (files.length > 1) {
+        errors.push(`Multiple script files found in skill ${skillIdn}: ${files.map(f => f.fileName).join(', ')}`);
+        warnings.push(`Only one script file allowed per skill. Remove extra files and keep one.`);
+    }
+    return {
+        isValid: files.length === 1,
+        files,
+        warnings,
+        errors
+    };
+}
+/**
+ * Get the single skill script file (if valid)
+ */
+export async function getSingleSkillFile(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn) {
+    const validation = await validateSkillFolder(customerIdn, projectIdn, agentIdn, flowIdn, skillIdn);
+    if (validation.isValid && validation.files.length === 1) {
+        return validation.files[0];
+    }
+    return null;
+}
+/**
+ * Check if skill script content is different from target content
+ */
+export function isContentDifferent(existingContent, newContent) {
+    return sha256(existingContent.trim()) !== sha256(newContent.trim());
+}
+/**
+ * Interactive overwrite confirmation
+ */
+export async function askForOverwrite(skillIdn, existingFile, newFile) {
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    console.log(`\n⚠️  File exists for skill ${skillIdn}:`);
+    console.log(`   Existing: ${existingFile}`);
+    console.log(`   New:      ${newFile}`);
+    const answer = await new Promise((resolve) => {
+        rl.question('Overwrite? (y)es/(n)o/(a)ll/(q)uit: ', resolve);
+    });
+    rl.close();
+    const choice = answer.toLowerCase().trim();
+    if (choice === 'q' || choice === 'quit') {
+        console.log('❌ Pull operation cancelled by user');
+        process.exit(0);
+    }
+    if (choice === 'a' || choice === 'all') {
+        return true; // This should be handled by caller to set global overwrite mode
+    }
+    return choice === 'y' || choice === 'yes';
+}
+//# sourceMappingURL=skill-files.js.map

package/dist/sync/status.d.ts

@@ -0,0 +1,6 @@
+import type { CustomerConfig } from '../types.js';
+/**
+ * Check status of files for a customer
+ */
+export declare function status(customer: CustomerConfig, verbose?: boolean): Promise<void>;
+//# sourceMappingURL=status.d.ts.map