@link-assistant/hive-mind 1.72.2 → 1.72.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.72.4
+
+### Patch Changes
+
+- 82d440c: Fix fork creation verification for dotted repository names such as GitHub Pages forks.
+
+## 1.72.3
+
+### Patch Changes
+
+- 502e78f: Use `lino-i18n` for Hive Mind translation loading and runtime lookup.
+
 ## 1.72.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.72.2",
+  "version": "1.72.4",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -76,6 +76,7 @@
     "dayjs": "^1.11.19",
     "decimal.js-light": "^2.5.1",
     "lino-arguments": "^0.3.0",
+    "lino-i18n": "^0.1.1",
     "lino-objects-codec": "^0.3.6",
     "secretlint": "^11.2.5",
     "semver": "^7.7.3",

package/src/github-repository-names.lib.mjs

@@ -0,0 +1,63 @@
+const OWNER_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+const REPOSITORY_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+const FULL_NAME_IN_TEXT_PATTERN = /(?:^|\s)([A-Za-z0-9_-]+\/[A-Za-z0-9._-]+)(?=$|\s|[),.;:])/;
+
+function trimOutputToken(token) {
+  return token.replace(/^[<([{'"`]+/, '').replace(/[>\])}'"`.,;]+$/, '');
+}
+
+function stripGitSuffix(repositoryName) {
+  return repositoryName.endsWith('.git') ? repositoryName.slice(0, -4) : repositoryName;
+}
+
+function normalizeRepositoryFullName(owner, repositoryName) {
+  if (!owner || !repositoryName) return null;
+  if (!OWNER_NAME_PATTERN.test(owner)) return null;
+  if (!REPOSITORY_NAME_PATTERN.test(repositoryName)) return null;
+  return `${owner}/${repositoryName}`;
+}
+
+function parseGitHubRepositoryUrlToken(token) {
+  const cleaned = trimOutputToken(token);
+  let pathName = null;
+
+  if (cleaned.startsWith('git@github.com:')) {
+    pathName = cleaned.slice('git@github.com:'.length);
+  } else if (cleaned.startsWith('github.com/')) {
+    pathName = cleaned.slice('github.com/'.length);
+  } else {
+    try {
+      const parsed = new URL(cleaned);
+      if (parsed.hostname !== 'github.com') return null;
+      pathName = parsed.pathname.replace(/^\/+/, '');
+    } catch {
+      return null;
+    }
+  }
+
+  const [owner, repositoryName] = pathName.split('/');
+  return normalizeRepositoryFullName(owner, stripGitSuffix(repositoryName || ''));
+}
+
+/**
+ * Parse the repository full name returned by `gh repo fork`.
+ *
+ * GitHub repository names can contain dots, notably GitHub Pages names like
+ * `parking.github.io`. The previous inline regex only accepted letters,
+ * digits, underscores, and dashes, so it truncated dotted fork names and
+ * verified the wrong repository.
+ *
+ * @param {string} output
+ * @returns {string|null}
+ */
+export function parseForkFullNameFromGhOutput(output) {
+  const text = String(output || '');
+
+  for (const token of text.match(/\S+/g) || []) {
+    const parsed = parseGitHubRepositoryUrlToken(token);
+    if (parsed) return parsed;
+  }
+
+  const fullNameMatch = text.match(FULL_NAME_IN_TEXT_PATTERN);
+  return fullNameMatch ? fullNameMatch[1] : null;
+}

package/src/i18n.lib.mjs

@@ -1,6 +1,6 @@
 // i18n module for hive-mind.
 // - Translation files live in src/locales/<locale>.lino and are stored
-//   in Links Notation, parsed via lino-objects-codec.
+//   in Links Notation, parsed and resolved via lino-i18n.
 // - Supported locales: en (default fallback), ru, zh, hi.
 // - Two locale tracks: ui (user-facing strings) and work (AI prompts /
 //   tool preferred language). Both default to the value of --language.
@@ -9,23 +9,31 @@
 //   normalizeLocale, getUserLocale, setUserLocale, clearUserLocale,
 //   resolveLocaleFromTelegramCtx.
 
-import { promises as fs } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { parseIndented } from 'lino-objects-codec';
+import { createI18n } from 'lino-i18n';
+import { loadLocalesFromFile } from 'lino-i18n/loaders';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const DEFAULT_LOCALE = 'en';
 const SUPPORTED_LOCALES = ['en', 'ru', 'zh', 'hi'];
+const LINO_COMPATIBILITY_ALIASES = ['collapseTail', 'parentLabel'];
 
 const localeCache = new Map(); // locale -> { key: string }
 const userLocales = new Map(); // userId/chatId -> locale (in-memory)
+const localesDir = path.join(__dirname, 'locales');
 
 let currentUiLocale = DEFAULT_LOCALE;
 let currentWorkLocale = DEFAULT_LOCALE;
 let fallbackLoaded = false;
+let i18n = createI18n({
+  locales: {},
+  defaultLocale: DEFAULT_LOCALE,
+  fallback: [DEFAULT_LOCALE],
+  compatibilityAliases: LINO_COMPATIBILITY_ALIASES,
+});
 
 export function getSupportedLocales() {
   return [...SUPPORTED_LOCALES];
@@ -46,31 +54,22 @@ export function detectLocale() {
 }
 
 async function readLocaleFile(locale) {
-  const localesDir = path.join(__dirname, 'locales');
   const linoFile = path.join(localesDir, `${locale}.lino`);
-  const data = await fs.readFile(linoFile, 'utf-8');
-  return parseIndentedToFlatMap(data);
-}
-
-// parseIndented returns { id, obj } where obj is the key->value map.
-// Some keys contain dots (e.g., error.invalid_github_url). The parser
-// supports them when the key is a plain reference (no spaces/quotes).
-function unescapeString(s) {
-  // Convert literal escape sequences (e.g., "\n" inside a quoted string in
-  // Links Notation) into the corresponding JS characters. This keeps the
-  // .lino files single-line and human-friendly.
-  return s.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r').replace(/\\\\/g, '\\');
-}
-
-function parseIndentedToFlatMap(text) {
-  const parsed = parseIndented({ text });
-  // parsed: { id: <localeName>, obj: { key: value, ... } }
-  if (!parsed || !parsed.obj) return {};
-  const out = {};
-  for (const [k, v] of Object.entries(parsed.obj)) {
-    out[k] = typeof v === 'string' ? unescapeString(v) : String(v);
-  }
-  return out;
+  const loaded = await loadLocalesFromFile(linoFile, {
+    compatibilityAliases: LINO_COMPATIBILITY_ALIASES,
+  });
+  const match = loaded.find(catalogue => catalogue.locale === locale) || loaded[0];
+  return match?.translations || {};
+}
+
+function refreshI18nRuntime() {
+  i18n = createI18n({
+    locales: Object.fromEntries(localeCache.entries()),
+    defaultLocale: currentUiLocale,
+    fallback: [DEFAULT_LOCALE],
+    compatibilityAliases: LINO_COMPATIBILITY_ALIASES,
+  });
+  i18n.setLocale(currentUiLocale);
 }
 
 export async function loadTranslations(locale) {
@@ -83,6 +82,7 @@ export async function loadTranslations(locale) {
     translations = {};
   }
   localeCache.set(locale, translations);
+  refreshI18nRuntime();
 
   // Always have the fallback (English) ready
   if (!fallbackLoaded && locale !== DEFAULT_LOCALE) {
@@ -93,6 +93,7 @@ export async function loadTranslations(locale) {
       localeCache.set(DEFAULT_LOCALE, {});
     }
     fallbackLoaded = true;
+    refreshI18nRuntime();
   } else if (locale === DEFAULT_LOCALE) {
     fallbackLoaded = true;
   }
@@ -157,10 +158,8 @@ export function t(key, params = {}, options = {}) {
   } else {
     locale = currentUiLocale;
   }
-  const main = localeCache.get(locale) || {};
-  const fallback = localeCache.get(DEFAULT_LOCALE) || {};
-  const value = main[key] ?? fallback[key] ?? key;
-  return applyParams(value, params);
+  const value = i18n.t(key, params, { ...options, locale });
+  return typeof value === 'string' ? value : applyParams(String(value), params);
 }
 
 // Convenience helper for work-language strings (AI prompts).
@@ -185,12 +184,16 @@ export function setLocale(locale) {
   if (normalized) {
     currentUiLocale = normalized;
     currentWorkLocale = normalized;
+    i18n.setLocale(normalized);
   }
 }
 
 export function setUiLocale(locale) {
   const normalized = normalizeLocale(locale);
-  if (normalized) currentUiLocale = normalized;
+  if (normalized) {
+    currentUiLocale = normalized;
+    i18n.setLocale(normalized);
+  }
 }
 
 export function setWorkLocale(locale) {