@orxataguy/tyr 1.0.41 → 1.0.43

package/README.md

@@ -184,7 +184,7 @@ Third parties can distribute commands as a `manifest.json` — a flat JSON map o
 }
 ```
 
-Register one with `tyr --add`, which validates the manifest, records it in `~/.tyr/imported_modules.yml`, and immediately downloads whatever commands are missing:
+Register one with `tyr --add`, which validates the manifest, records it in `~/.tyr/imported_modules.yaml`, and immediately downloads whatever commands are missing:
 
 ```bash
 tyr --add https://raw.githubusercontent.com/someuser/tyr-modules/main/manifest.json my-module
@@ -200,7 +200,7 @@ Rules worth knowing:
 
 - A command name that already exists locally is never overwritten by a plain sync — only `tyr --update` (or `tyr --modules sync --force`) refreshes commands that were themselves installed by an import.
 - Hand-written commands are never touched, even if a manifest later defines a command with the same name.
-- If two modules define the same command name, the one processed last (last entry in `imported_modules.yml`) wins.
+- If two modules define the same command name, the one processed last (last entry in `imported_modules.yaml`) wins.
 - Only `https://` URLs are accepted, both for manifests and for the command files they point to.
 
 Which commands came from which module is tracked in `~/.tyr/imported_modules.lock.yml`, generated automatically — you shouldn't need to edit it by hand.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orxataguy/tyr",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "type": "module",
   "bin": {
     "tyr": "./bin/tyr.js"

package/src/core/Kernel.ts

@@ -110,7 +110,7 @@ export class Kernel {
                 console.log('Run: tyr --config --repo <url>  to link it.');
             }
 
-            const modulesPath = path.join(this.userRoot, 'imported_modules.yml');
+            const modulesPath = path.join(this.userRoot, 'imported_modules.yaml');
             if (fs.existsSync(modulesPath)) {
                 console.log('\nUpdating imported modules...');
                 const updateContext = {

package/src/core/sys/config.ts

@@ -284,6 +284,10 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
             await tyrFs.write(mapPath, 'commands: {}\n');
             logger.success(`File created: ${mapPath}`);
 
+            const importedModulesPath = path.join(userRoot, 'imported_modules.yaml');
+            await tyrFs.write(importedModulesPath, 'modules: {}\n');
+            logger.success(`File created: ${importedModulesPath}`);
+
             const envPath = path.join(userRoot, '.env.example');
             if (!tyrFs.exists(envPath)) {
                 await tyrFs.write(envPath, ENV_TEMPLATE);
@@ -331,6 +335,12 @@ export default function config({ logger, fs: tyrFs, frameworkRoot, shell }: TyrC
             }
         }
 
+        const importedModulesPath = path.join(userRoot, 'imported_modules.yaml');
+        if (!tyrFs.exists(importedModulesPath)) {
+            await tyrFs.write(importedModulesPath, 'modules: {}\n');
+            logger.success(`File created: ${importedModulesPath}`);
+        }
+
         const packageJsonPath = path.join(userRoot, 'package.json');
         const tsconfigPath    = path.join(userRoot, 'tsconfig.json');
         let needsInstall = false;

package/src/core/sys/modules.ts

@@ -29,7 +29,7 @@ export interface SyncSummary {
     failed: { command: string; reason: string }[];
 }
 
-const IMPORTED_MODULES_FILE = 'imported_modules.yml';
+const IMPORTED_MODULES_FILE = 'imported_modules.yaml';
 const LOCK_FILE = 'imported_modules.lock.yml';
 
 function isValidHttpsUrl(value: string): boolean {
@@ -41,8 +41,19 @@ function isValidHttpsUrl(value: string): boolean {
     }
 }
 
+// Allows namespaced command names like 'db:migrate', but not a leading/
+// trailing/doubled ':' (e.g. ':foo', 'foo:', 'a::b'), since those would
+// produce an empty segment.
 function isValidCommandName(name: string): boolean {
-    return /^[a-zA-Z0-9_-]+$/.test(name);
+    return /^[a-zA-Z0-9_-]+(:[a-zA-Z0-9_-]+)*$/.test(name);
+}
+
+// ':' is a valid character in a command name (namespacing, e.g. 'db:migrate')
+// but isn't a safe filename component on every platform (Windows reserves it).
+// Only used when deriving the on-disk file name — the real name with its
+// colons is still what's stored in map.yml, the lockfile, and the manifest.
+function toSafeFilename(commandName: string): string {
+    return commandName.replace(/:/g, '-');
 }
 
 function slugFromUrl(url: string): string {
@@ -101,7 +112,7 @@ async function fetchManifest(web: any, manifestUrl: string): Promise<Record<stri
 }
 
 /**
- * Reconciles ~/.tyr/imported_modules.yml against ~/.tyr/map.yml.
+ * Reconciles ~/.tyr/imported_modules.yaml against ~/.tyr/map.yml.
  *
  * - A command that doesn't exist yet in map.yml is installed.
  * - A command that already exists and isn't tracked in the lockfile is left
@@ -111,7 +122,7 @@ async function fetchManifest(web: any, manifestUrl: string): Promise<Record<stri
  *   silently.
  * - If two modules define the same command name, the last one processed
  *   wins (modules are processed in the order they appear in
- *   imported_modules.yml).
+ *   imported_modules.yaml).
  */
 export async function syncModules(context: TyrContext, options: { force?: boolean } = {}): Promise<SyncSummary> {
     const { logger, fs, web, userRoot } = context as any;
@@ -155,6 +166,9 @@ export async function syncModules(context: TyrContext, options: { force?: boolea
         } catch (e) {
             const reason = e instanceof Error ? e.message : String(e);
             logger.error(`Could not read manifest for module '${moduleName}': ${reason}`);
+            // logger.error() is silenced unless --debug is passed, so mirror it via
+            // logger.info() too — otherwise this failure would be entirely invisible.
+            logger.info(`Skipped module '${moduleName}': ${reason}`);
             summary.failed.push({ command: moduleName, reason });
             continue;
         }
@@ -180,14 +194,15 @@ export async function syncModules(context: TyrContext, options: { force?: boolea
                 const content = await web.get(fileUrl);
                 const fileContent = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
 
-                const destPath = path.join(userRoot, 'commands', `${commandName}.tyr.ts`);
+                const fileName = toSafeFilename(commandName);
+                const destPath = path.join(userRoot, 'commands', `${fileName}.tyr.ts`);
                 await fs.write(destPath, fileContent);
 
                 if (managed && managed.module !== moduleName) {
                     logger.warn(`'${commandName}' was previously managed by module '${managed.module}'; now owned by '${moduleName}'.`);
                 }
 
-                mapConfig.commands[commandName] = `./commands/${commandName}.tyr.ts`;
+                mapConfig.commands[commandName] = `./commands/${fileName}.tyr.ts`;
                 lock.commands[commandName] = { module: moduleName, manifest: manifestUrl, source: fileUrl };
                 mapChanged = true;
                 lockChanged = true;
@@ -202,6 +217,7 @@ export async function syncModules(context: TyrContext, options: { force?: boolea
             } catch (e) {
                 const reason = e instanceof Error ? e.message : String(e);
                 logger.error(`Could not download '${commandName}' from '${fileUrl}': ${reason}`);
+                logger.info(`Skipped '${commandName}': ${reason}`);
                 summary.failed.push({ command: commandName, reason });
             }
         }
@@ -215,11 +231,18 @@ export async function syncModules(context: TyrContext, options: { force?: boolea
         `skipped: ${summary.skipped.length}, failed: ${summary.failed.length}.`
     );
 
+    if (summary.failed.length > 0) {
+        logger.info('Failures:');
+        for (const { command, reason } of summary.failed) {
+            logger.info(`  - ${command}: ${reason}`);
+        }
+    }
+
     return summary;
 }
 
 /**
- * Registers a manifest URL under a module name in imported_modules.yml and
+ * Registers a manifest URL under a module name in imported_modules.yaml and
  * immediately syncs it (downloads whatever commands are missing).
  */
 export async function addModule(context: TyrContext, manifestUrl: string, name?: string): Promise<void> {
@@ -233,6 +256,7 @@ export async function addModule(context: TyrContext, manifestUrl: string, name?:
 
     if (!isValidHttpsUrl(manifestUrl)) {
         logger.error('Manifest URL must be a valid https:// URL.');
+        logger.info(`Could not add module: '${manifestUrl}' is not a valid https:// URL.`);
         return;
     }
 
@@ -242,6 +266,7 @@ export async function addModule(context: TyrContext, manifestUrl: string, name?:
     } catch (e) {
         const reason = e instanceof Error ? e.message : String(e);
         logger.error(`Could not add module: ${reason}`);
+        logger.info(`Could not add module: ${reason}`);
         return;
     }
 
@@ -313,12 +338,14 @@ export async function generateManifest(context: TyrContext): Promise<void> {
         remoteUrl = await shell.exec('git remote get-url origin');
     } catch {
         logger.error("~/.tyr's repository has no 'origin' remote configured. Cannot generate manifest.json.");
+        logger.info("Cannot generate manifest.json: ~/.tyr's repository has no 'origin' remote configured.");
         return;
     }
 
     const repoInfo = parseGithubRemote(remoteUrl);
     if (!repoInfo) {
         logger.error(`Cannot generate manifest.json: only GitHub repositories are supported (raw.githubusercontent.com). Remote was: ${remoteUrl}`);
+        logger.info(`Cannot generate manifest.json: only GitHub repositories are supported. Remote was: ${remoteUrl}`);
         return;
     }
 
@@ -328,10 +355,10 @@ export async function generateManifest(context: TyrContext): Promise<void> {
         if (currentBranch && currentBranch !== 'HEAD') {
             branch = currentBranch;
         } else {
-            logger.warn(`Could not determine the current branch (detached HEAD?). Falling back to '${branch}'.`);
+            logger.info(`Could not determine the current branch (detached HEAD?). Falling back to '${branch}'.`);
         }
     } catch {
-        logger.warn(`Could not determine the current branch. Falling back to '${branch}'.`);
+        logger.info(`Could not determine the current branch. Falling back to '${branch}'.`);
     }
 
     const mapPath = path.join(userRoot, 'map.yml');
@@ -347,7 +374,7 @@ export async function generateManifest(context: TyrContext): Promise<void> {
             : scriptPath.replace(/^\.[/\\]/, '');
 
         if (repoRelativePath.startsWith('..')) {
-            logger.warn(`Skipping '${name}': its file lives outside ~/.tyr and can't be published.`);
+            logger.info(`Skipping '${name}': its file lives outside ~/.tyr and can't be published.`);
             skipped.push(name);
             continue;
         }
@@ -357,7 +384,7 @@ export async function generateManifest(context: TyrContext): Promise<void> {
     }
 
     if (Object.keys(manifest).length === 0) {
-        logger.warn('No commands to include in manifest.json.');
+        logger.info('No commands to include in manifest.json.');
     }
 
     const manifestPath = path.join(userRoot, 'manifest.json');