@untitled-devs/wasla 1.0.0 → 1.0.2

package/dist/packages/shared/src/config.js

@@ -10,17 +10,17 @@ export async function readConfiguredScope() {
         return null;
     const config = await readJSON(configPath);
     if (typeof config !== 'object' || config === null || typeof config.scope !== 'string') {
-        throw new Error(`Invalid scope in ${configPath}. Run: waslagenie config --scope <scope>`);
+        throw new Error(`Invalid scope in ${configPath}. Run: wasla config --scope <scope>`);
     }
     if (config.scope !== 'user' && config.scope !== 'workspace') {
-        throw new Error(`Invalid scope in ${configPath}. Run: waslagenie config --scope <scope>`);
+        throw new Error(`Invalid scope in ${configPath}. Run: wasla config --scope <scope>`);
     }
     return config.scope;
 }
 export async function requireConfiguredScope() {
     const scope = await readConfiguredScope();
     if (!scope) {
-        throw new Error('Scope is not configured. Run: waslagenie config --scope <user|workspace>');
+        throw new Error('Scope is not configured. Run: wasla config --scope <user|workspace>');
     }
     return scope;
 }

package/dist/packages/shared/src/paths.js

@@ -11,18 +11,18 @@ export function getRegistryPath(scope) {
         return resolve(`output/tests/${scope}-registry.json`);
     }
     if (scope === 'user') {
-        return expandTilde('~/.waslagenie/registry.json');
+        return expandTilde('~/.wasla/registry.json');
     }
-    return resolve('.waslagenie/registry.json');
+    return resolve('.wasla/registry.json');
 }
 export function getRegistryDir(scope) {
     if (process.env.NODE_ENV === 'test') {
         return resolve('output/tests');
     }
     if (scope === 'user') {
-        return expandTilde('~/.waslagenie');
+        return expandTilde('~/.wasla');
     }
-    return resolve('.waslagenie');
+    return resolve('.wasla');
 }
 export function getToolMarkers(scope = 'user') {
     if (scope === 'workspace') {

package/dist/packages/sync/src/index.d.ts

@@ -20,6 +20,15 @@ export declare class Syncer {
     attachAssetToTool(name: string, type: AssetType, sourceTool: string, targetTool: string): Promise<boolean>;
     detachAssetFromTool(name: string, type: AssetType, tool: string): Promise<boolean>;
     private calculateHash;
+    /**
+     * Filters discovered files, removing those that cannot be read (ENOENT).
+     * Treats read-time ENOENT as a deletion signal: if a file disappears during
+     * pruning, it is removed from sync and will be treated as a deletion in
+     * reconcileDeletedAssets. This prevents sync failures when files are deleted
+     * between scan and read phases.
+     */
+    private removeMissingFiles;
+    private isMissingFileError;
     private getTargetPath;
     private writeTarget;
     private writeMcpServer;

package/dist/packages/sync/src/index.js

@@ -27,6 +27,7 @@ export class Syncer {
         await ensureDir(join(registryDir, 'context'));
         const discovered = await this.scanner.scanAllTools();
         const grouped = this.groupByNameAndType(discovered);
+        await this.removeMissingFiles(grouped);
         const installedTools = await this.scanner.detectInstalledTools();
         let stubsWritten = 0;
         const stubsDeleted = await this.reconcileDeletedAssets(grouped, installedTools);
@@ -102,20 +103,7 @@ export class Syncer {
                     continue;
                 }
                 // Update stub info in registry
-                const existingStub = asset.stubs.find((s) => s.tool === tool);
-                if (existingStub) {
-                    existingStub.path = primaryTargetPath;
-                    existingStub.written_at = new Date().toISOString();
-                    existingStub.hash = contentHash;
-                }
-                else {
-                    asset.stubs.push({
-                        tool,
-                        path: primaryTargetPath,
-                        written_at: new Date().toISOString(),
-                        hash: contentHash,
-                    });
-                }
+                await this.upsertStub(asset, tool, primaryTargetPath, contentHash);
             }
             // Also save to canonical registry location
             const registrySubdir = type === 'agent'
@@ -166,11 +154,13 @@ export class Syncer {
         const assetTypes = ['agent', 'skill', 'mcp', 'context'];
         const discovered = await this.scanner.scanTool(sourceTool, assetTypes);
         const grouped = this.groupByNameAndType(discovered);
+        await this.removeMissingFiles(grouped);
         const deletionScan = [...discovered];
         for (const tool of targetTools.filter((tool) => tool !== sourceTool)) {
             deletionScan.push(...(await this.scanner.scanTool(tool, assetTypes)));
         }
         const deletionGrouped = this.groupByNameAndType(deletionScan);
+        await this.removeMissingFiles(deletionGrouped);
         let stubsWritten = 0;
         const stubsDeleted = await this.reconcileDeletedAssets(deletionGrouped, [...new Set([sourceTool, ...targetTools])], sourceTool);
         for (const key of Object.keys(grouped)) {
@@ -209,7 +199,7 @@ export class Syncer {
                     last_synced_at: new Date().toISOString(),
                 });
             }
-            this.upsertStub(asset, sourceTool, source.path, contentHash);
+            await this.upsertStub(asset, sourceTool, source.path, contentHash);
             // Write only to target tools
             for (const tool of targetTools) {
                 const adapter = getAdapter(tool, this.scope);
@@ -242,20 +232,7 @@ export class Syncer {
                     continue;
                 }
                 // Update stub info in registry
-                const existingStub = asset.stubs.find((s) => s.tool === tool);
-                if (existingStub) {
-                    existingStub.path = primaryTargetPath;
-                    existingStub.written_at = new Date().toISOString();
-                    existingStub.hash = contentHash;
-                }
-                else {
-                    asset.stubs.push({
-                        tool,
-                        path: primaryTargetPath,
-                        written_at: new Date().toISOString(),
-                        hash: contentHash,
-                    });
-                }
+                await this.upsertStub(asset, tool, primaryTargetPath, contentHash);
             }
             // Also save to canonical registry location
             const registrySubdir = type === 'agent'
@@ -284,7 +261,7 @@ export class Syncer {
         catch {
             await this.registry.load();
         }
-        const candidates = sourceTool === 'waslagenie'
+        const candidates = sourceTool === 'wasla'
             ? (await this.scanner.scanAllTools([type])).filter((item) => item.name === name)
             : (await this.scanner.scanTool(sourceTool, [type])).filter((item) => item.name === name);
         const sourceCandidates = candidates.filter((item) => item.tool !== targetTool);
@@ -292,7 +269,7 @@ export class Syncer {
         if (items.length === 0) {
             throw new Error(`Cannot find ${type}:${name} in ${sourceTool}`);
         }
-        const sourceItems = sourceTool === 'waslagenie' ? items.filter((item) => item.tool === items[0].tool) : items;
+        const sourceItems = sourceTool === 'wasla' ? items.filter((item) => item.tool === items[0].tool) : items;
         const sorted = sourceItems.sort((a, b) => b.modifiedAt - a.modifiedAt);
         const source = type === 'skill'
             ? sorted.find((item) => item.relativePath.endsWith(`${sep}SKILL.md`) || item.relativePath === 'SKILL.md') || sorted[0]
@@ -311,7 +288,7 @@ export class Syncer {
             };
             this.registry.addAsset(asset);
         }
-        this.upsertStub(asset, source.tool, source.path, contentHash);
+        await this.upsertStub(asset, source.tool, source.path, contentHash);
         const adapter = getAdapter(targetTool, this.scope);
         const formatsRecord = adapter.formats;
         if (!adapter.paths[type] || !formatsRecord[type]) {
@@ -374,6 +351,46 @@ export class Syncer {
     calculateHash(content) {
         return createHash('sha256').update(content).digest('hex');
     }
+    /**
+     * Filters discovered files, removing those that cannot be read (ENOENT).
+     * Treats read-time ENOENT as a deletion signal: if a file disappears during
+     * pruning, it is removed from sync and will be treated as a deletion in
+     * reconcileDeletedAssets. This prevents sync failures when files are deleted
+     * between scan and read phases.
+     */
+    async removeMissingFiles(grouped) {
+        for (const key of Object.keys(grouped)) {
+            const readable = [];
+            for (const item of grouped[key]) {
+                if (item.content !== undefined) {
+                    readable.push(item);
+                    continue;
+                }
+                try {
+                    item.content = await readText(item.path);
+                    readable.push(item);
+                }
+                catch (error) {
+                    if (!this.isMissingFileError(error)) {
+                        throw error;
+                    }
+                    // ENOENT: file was deleted after scanning, treat as deletion
+                }
+            }
+            if (readable.length > 0) {
+                grouped[key] = readable;
+            }
+            else {
+                delete grouped[key];
+            }
+        }
+    }
+    isMissingFileError(error) {
+        return (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT');
+    }
     getTargetPath(adapter, type, name, relativePath) {
         const typeDir = adapter.paths[type];
         const format = adapter.formats[type];
@@ -436,9 +453,15 @@ export class Syncer {
         await writeJSON(targetPath, config);
         return true;
     }
-    upsertStub(asset, tool, path, hash) {
+    async upsertStub(asset, tool, path, hash) {
         const existingStub = asset.stubs.find((stub) => stub.tool === tool);
         if (existingStub) {
+            if (asset.type === 'context' &&
+                existingStub.path !== path &&
+                (await fileExists(existingStub.path)) &&
+                this.calculateHash(await readText(existingStub.path)) === existingStub.hash) {
+                await removePath(existingStub.path);
+            }
             existingStub.path = path;
             existingStub.written_at = new Date().toISOString();
             existingStub.hash = hash;

package/dist/packages/sync/src/scanner.js

@@ -113,9 +113,9 @@ export class Scanner {
                 if (process.env.DEBUG_SCANNER) {
                     console.log(`[Scanner] Processing: path=${filePath}, rel=${relativePath}, name=${name}, isStub=${isStub}`);
                 }
-                if (name.toLowerCase() === 'waslagenie') {
+                if (name.toLowerCase() === 'wasla') {
                     if (process.env.DEBUG_SCANNER) {
-                        console.log(`[Scanner] Skipping waslagenie asset`);
+                        console.log(`[Scanner] Skipping wasla asset`);
                     }
                     continue;
                 }
@@ -201,7 +201,7 @@ export class Scanner {
         return grouped;
     }
     extractAssetName(relativePathOrFileName) {
-        // For nested paths: waslagenie/SKILL.md -> waslagenie
+        // For nested paths: wasla/SKILL.md -> wasla
         // For flat files: researcher.md -> researcher
         const parts = relativePathOrFileName.split(/[/\\]/);
         if (parts.length > 1) {