lucy-cli 2.0.0-alpha.9 → 2.0.0-beta.10

package/files/templates/expo verse[D]/files/lib/taskManager/loadData.ts

@@ -0,0 +1,14 @@
+import { Effect } from 'effect';
+
+import { loadData } from '../data';
+
+
+export const backgroundTask = (ready: Promise<void>) => {
+	return Effect.gen(function* () {
+		yield* Effect.promise(() => ready);
+		yield* Effect.log('Loading data');
+
+		yield* loadData;
+		
+	});
+};

package/files/templates/expo verse[D]/files/lib/utils/screenshot.ts

@@ -0,0 +1,77 @@
+import * as FileSystem from 'expo-file-system';
+import { isAvailableAsync as isSharingAvailable, shareAsync, type SharingOptions } from 'expo-sharing';
+import { captureScreen } from 'react-native-view-shot';
+
+// Explicitly type the external functions to satisfy strict lint rules
+const safeIsSharingAvailable: () => Promise<boolean> = (isSharingAvailable as unknown as () => Promise<boolean>);
+const safeShareAsync: (url: string, options?: SharingOptions) => Promise<void> = (shareAsync as unknown as (url: string, options?: SharingOptions) => Promise<void>);
+const safeCaptureScreen: (options: { format: 'png' | 'jpg'; quality: number; result: 'tmpfile' | 'base64' | 'data-uri' }) => Promise<string> = (captureScreen as unknown as (options: { format: 'png' | 'jpg'; quality: number; result: 'tmpfile' | 'base64' | 'data-uri' }) => Promise<string>);
+
+/**
+ * Captures the current screen and opens the native share sheet.
+ * @param source - The source of the screenshot.
+ * @returns The screenshot URI.
+ */
+export async function shareCurrentScreen(source: string) {
+	try {
+		const isShareAvailable = await safeIsSharingAvailable();
+		if (!isShareAvailable) {
+			// eslint-disable-next-line no-console
+			console.warn('Native sharing is not available on this platform.');
+			
+			return;
+		}
+
+		const uri = await safeCaptureScreen({
+			format: 'png',
+			quality: 1,
+			result: 'tmpfile',
+		});
+
+		if (!uri) {
+			// eslint-disable-next-line no-console
+			console.error('Failed to capture screen.');
+			
+			return;
+		}
+
+		// Build friendly file name, copy tmp file so share sheet shows it
+		const now = new Date();
+		const pad = (n: number) => n.toString().padStart(2, '0');
+		// Sanitize the provided reference to a filesystem-safe, non-empty slug
+		const base = (source ?? '').toString().trim().replace(/\s+/g, ' ');
+		const slugRaw = base.length > 0 ? base : 'Verse';
+		let slug = slugRaw.replace(/[^a-zA-Z0-9]+/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+		if (slug.length === 0) slug = 'Verse';
+		if (slug.length > 50) slug = slug.slice(0, 50);
+		const filename = `Daily-Verse_${slug}_${now.getFullYear()}.${pad(now.getMonth() + 1)}.${pad(now.getDate())}.png`;
+		const destUri = `${FileSystem.cacheDirectory ?? ''}${filename}`;
+		let shareUri = uri;
+		try {
+			await FileSystem.copyAsync({ from: uri, to: destUri });
+			const info = await FileSystem.getInfoAsync(destUri);
+			if (info.exists) shareUri = destUri;
+		} catch {
+			// ignore, fall back to tmp uri
+		}
+		const options: SharingOptions = {
+			mimeType: 'image/png',
+			dialogTitle: 'Share Daily Verse',
+			UTI: 'public.png',
+		};
+		await safeShareAsync(shareUri, options);
+		// Cleanup copied file best-effort
+		if (shareUri === destUri) {
+			try {
+				await FileSystem.deleteAsync(destUri, { idempotent: true });
+			} catch {
+				// ignore
+			}
+		}
+	} catch (error) {
+ 		// eslint-disable-next-line no-console
+		console.error('Error capturing or sharing screenshot:', error);
+	}
+}
+
+

package/files/templates/expo verse[D]/files/metro.config.js

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+const { getDefaultConfig } = require('expo/metro-config');
+const { withNativeWind } = require('nativewind/metro');
+const path = require('path');
+
+const ALIASES_WEB = {
+	'@wix/sdk': path.resolve(__dirname, './node_modules/@wix/sdk/cjs/build/index.js'),
+	// Example: redirect imports of 'some-native-library' to a web-compatible mock
+	// 'some-native-library': path.resolve(__dirname, 'src/mocks/some-native-library.web.js'),
+
+	// You can add your @wix/sdk aliases here if needed
+	// '@wix/sdk-something': path.resolve(__dirname, 'src/wix/sdk-something-web.js'),
+};
+const config = (() => {
+	let config = getDefaultConfig(__dirname);
+	const { transformer, resolver } = config;
+	config.transformer = {
+		...transformer,
+		// Enable source maps for debugging
+		minifierConfig: {
+			keep_fnames: true,
+			mangle: {
+				keep_fnames: true,
+			},
+		},
+		// Ensure source maps are generated for debugging
+		getTransformOptions: () => ({
+			transform: {
+				experimentalImportSupport: false,
+				inlineRequires: false,
+			},
+		}),
+	};
+	const assetExts = config.resolver.assetExts;
+	if (!assetExts.includes('csv')) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+		assetExts.push('csv');
+	}
+	
+	config.resolver = {
+		...resolver,
+	};
+	
+	config.resolver.unstable_enablePackageExports = false;
+	// config.resolver.unstable_conditionsByPlatform = ['ios', 'android']
+	config.resolver.resolveRequest = (context, moduleName, platform) => {
+		if (platform === 'web') {
+		// Check if the module name is in our alias map
+			const alias = ALIASES_WEB[moduleName];
+			if (alias) {
+				// eslint-disable-next-line no-console
+				console.log(`Aliasing '${moduleName}' to '${alias}'`);
+				// If it is, resolve to the new path
+				
+				// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+				return context.resolveRequest(context, alias, platform);
+			}
+		}
+		// Ensure you call the default resolver for everything else.
+
+		return context.resolveRequest(context, moduleName, platform);
+	};
+
+	config.resolver.extraNodeModules = {
+		...config.resolver.extraNodeModules,
+		...require('node-libs-react-native'),
+		// 'node:buffer': require.resolve('buffer/'),
+		// 'node:crypto': require.resolve('react-native-crypto/'),
+		// 'node:util': require.resolve('util/'),
+		// 'node:http': require.resolve('stream-http/'),
+		// 'node:https': require.resolve('https-browserify/'),
+		// 'node:events': require.resolve('events/'),
+	};
+	
+	return config;
+})();
+// console.log('Using Metro config:', JSON.stringify(config, null, 2));
+module.exports = withNativeWind(config, { input: './global.css' });
+

package/files/templates/expo verse[D]/files/models/index.ts

@@ -0,0 +1,28 @@
+import { Schema } from 'effect';
+
+export const versionSchema = Schema.Struct({
+	version: Schema.String,
+	languages: Schema.Array(Schema.String)
+});
+export type Version = typeof versionSchema.Type;
+
+export const dataStateSchema = Schema.Struct({
+	index: Schema.Number,
+	date: Schema.DateTimeUtc,
+	lastUpdateCheck: Schema.DateTimeUtc,
+	language: Schema.String,
+	deviceLanguage: Schema.String,
+	version: Schema.String,
+});
+export type DataState = typeof dataStateSchema.Type;
+
+
+export const quoteSchema = Schema.Struct({
+	Verse: Schema.String,
+	Reference: Schema.String,
+	Topic: Schema.String,
+});
+export type Quote = typeof quoteSchema.Type;
+
+const schema = Schema.parseJson();
+const decode = Schema.decodeUnknown(schema);

package/files/templates/expo verse[D]/files/package.json

@@ -0,0 +1,102 @@
+{
+	"name": "daily-verse",
+	"version": "1.0.0",
+	"main": "index.ts",
+	"scripts": {
+		"start": "expo start --port=8082",
+		"android": "expo run:android --port=8082",
+		"ios": "expo run:ios --port=8082",
+		"web": "expo start --web --port=8082",
+		"dev": "expo start --port=8082",
+		"reset": "tsx ./scripts/reset-project.ts",
+		"format": "prettier --write \"./*.json\" \"**/*.{ts,tsx,md,json,jsonc,json5}\"",
+		"prebuild": "expo prebuild",
+		"pods": "npx pod-install",
+		"build:dev": "eas build --local --profile development && tsx ./scripts/move-artifacts.ts",
+		"build:sim": "eas build --local --profile ios-simulator && tsx ./scripts/move-artifacts.ts",
+		"build:prev": "eas build --local --profile preview && tsx ./scripts/move-artifacts.ts",
+		"build:prod": "eas build --local --profile production && tsx ./scripts/move-artifacts.ts",
+		"build:web": "expo export --platform web",
+		"doctor": "expo-doctor"
+	},
+	"dependencies": {
+		"@effect/platform": "^0.90.3",
+		"@expo/metro-runtime": "~5.0.4",
+		"@react-native-async-storage/async-storage": "2.1.2",
+		"@wix/data": "^1.0.269",
+		"@wix/sdk": "^1.15.24",
+		"class-variance-authority": "^0.7.1",
+		"clsx": "^2.1.1",
+		"effect": "^3.17.1",
+		"events": "^3.3.0",
+		"expo": "~53.0.22",
+		"expo-application": "~6.1.5",
+		"expo-asset": "~11.1.7",
+		"expo-background-task": "~0.2.8",
+		"expo-crypto": "~14.1.5",
+		"expo-dev-client": "~5.2.4",
+		"expo-file-system": "~18.1.11",
+		"expo-font": "~13.3.2",
+		"expo-haptics": "~14.1.4",
+		"expo-localization": "~16.1.6",
+		"expo-sharing": "~13.1.5",
+		"expo-splash-screen": "~0.30.10",
+		"expo-standard-web-crypto": "^2.1.4",
+		"expo-status-bar": "~2.2.3",
+		"expo-system-ui": "~5.0.11",
+		"expo-task-manager": "~13.1.6",
+		"expo-updates": "~0.28.17",
+		"nativewind": "^4.1.23",
+		"node-libs-react-native": "^1.2.1",
+		"papaparse": "^5.5.3",
+		"react": "19.0.0",
+		"react-dom": "19.0.0",
+		"react-native": "0.79.5",
+		"react-native-reanimated": "~3.17.4",
+		"react-native-safe-area-context": "5.4.0",
+		"react-native-svg": "^15.11.2",
+		"react-native-view-shot": "4.0.3",
+		"react-native-web": "^0.20.0",
+		"tailwind-merge": "^3.3.1",
+		"tailwindcss-animate": "^1.0.7",
+		"util": "^0.12.5"
+	},
+	"devDependencies": {
+		"@babel/core": "^7.25.2",
+		"@next/eslint-plugin-next": "^15.4.4",
+		"@react-native-community/cli": "^20.0.0",
+		"@styled/typescript-styled-plugin": "^1.0.1",
+		"@stylelint/postcss-css-in-js": "^0.38.0",
+		"@total-typescript/ts-reset": "^0.6.1",
+		"@types/node": "^24.2.0",
+		"@types/papaparse": "^5.3.16",
+		"@types/react": "~19.0.10",
+		"@typescript-eslint/parser": "^8.38.0",
+		"eslint": "^9.33.0",
+		"eslint-config-expo": "^9.2.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-jsdoc": "^51.4.1",
+		"eslint-plugin-named-import-spacing": "^1.0.3",
+		"eslint-plugin-only-warn": "^1.1.0",
+		"eslint-plugin-react": "^7.37.5",
+		"eslint-plugin-react-hooks": "^5.2.0",
+		"eslint-plugin-simple-import-sort": "^12.1.1",
+		"expo-doctor": "^1.13.5",
+		"prettier-plugin-tailwindcss": "^0.5.11",
+		"tailwindcss": "^3.4.17",
+		"ts-node": "^10.9.2",
+		"tsx": "^4.20.3",
+		"typescript": "~5.8.3",
+		"typescript-eslint": "^8.38.0",
+		"typescript-eslint-language-service": "^5.0.5"
+	},
+	"private": true,
+	"expo": {
+		"doctor": {
+			"reactNativeDirectoryCheck": {
+				"listUnknownPackages": false
+			}
+		}
+	},
+	"packageManager": "pnpm@10.14.0+sha1.85759954ad817d248e2fed7f789f046a24f0327d"
+}

package/files/templates/expo verse[D]/files/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+onlyBuiltDependencies:
+  - esbuild
+nodeLinker: hoisted

package/files/templates/expo verse[D]/files/scripts/convert-verses.ts

@@ -0,0 +1,309 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface CSVVerse {
+  Verse: string;
+  Reference: string;
+  Topic: string;
+}
+
+interface ConvertedVerse {
+  Verse: string;
+  Reference: string;
+  Topic: string;
+}
+
+interface FailedVerse {
+  Verse: string;
+  Reference: string;
+  Topic: string;
+  Reason: string;
+}
+
+// Function to convert Bible reference to XML format
+function convertReferenceToXMLFormat(reference: string): string {
+  // Map common book names to their abbreviations
+  const bookMap: { [key: string]: string } = {
+    '1 Chronicles': '1CH',
+    '1 Corinthians': '1CO',
+    '1 John': '1JN',
+    '1 Peter': '1PE',
+    '1 Samuel': '1SA',
+    '1 Thessalonians': '1TH',
+    '1 Timothy': '1TI',
+    '2 Chronicles': '2CH',
+    '2 Corinthians': '2CO',
+    '2 John': '2JN',
+    '2 Peter': '2PE',
+    '2 Samuel': '2SA',
+    '2 Thessalonians': '2TH',
+    '2 Timothy': '2TI',
+    'Acts': 'ACT',
+    'Colossians': 'COL',
+    'Daniel': 'DAN',
+    'Deuteronomy': 'DEU',
+    'Ecclesiastes': 'ECC',
+    'Ephesians': 'EPH',
+    'Esther': 'EST',
+    'Exodus': 'EXO',
+    'Ezekiel': 'EZK',
+    'Ezra': 'EZR',
+    'Galatians': 'GAL',
+    'Genesis': 'GEN',
+    'Habakkuk': 'HAB',
+    'Haggai': 'HAG',
+    'Hebrews': 'HEB',
+    'Hosea': 'HOS',
+    'Isaiah': 'ISA',
+    'James': 'JAS',
+    'Jeremiah': 'JER',
+    'Job': 'JOB',
+    'Joel': 'JOE',
+    'John': 'JHN',
+    'Jonah': 'JON',
+    'Joshua': 'JOS',
+    'Jude': 'JUD',
+    'Judges': 'JDG',
+    'Lamentations': 'LAM',
+    'Leviticus': 'LEV',
+    'Luke': 'LUK',
+    'Malachi': 'MAL',
+    'Mark': 'MRK',
+    'Matthew': 'MAT',
+    'Micah': 'MIC',
+    'Nahum': 'NAH',
+    'Nehemiah': 'NEH',
+    'Numbers': 'NUM',
+    'Obadiah': 'OBA',
+    'Philemon': 'PHM',
+    'Philippians': 'PHP',
+    'Proverbs': 'PRO',
+    'Psalms': 'PSA',
+    'Revelation': 'REV',
+    'Romans': 'ROM',
+    'Ruth': 'RUT',
+    'Song of Solomon': 'SNG',
+    'Titus': 'TIT',
+    'Zechariah': 'ZEC',
+    'Zephaniah': 'ZEP'
+  };
+
+  // Extract book name and verse numbers
+  const match = reference.match(/^(.+?)\s+(\d+):(\d+)$/);
+  if (!match) {
+    throw new Error(`Invalid reference format: ${reference}`);
+  }
+
+  const bookName = match[1];
+  const chapter = match[2];
+  const verse = match[3];
+
+  const bookAbbr = bookMap[bookName];
+  if (!bookAbbr) {
+    throw new Error(`Unknown book: ${bookName}`);
+  }
+
+  return `${bookAbbr}.${chapter}.${verse}`;
+}
+
+// Function to add proper sentence ending
+function addSentenceEnding(text: string): string {
+  const trimmed = text.trim();
+  
+  // If it already ends with a proper sentence ending, return as is
+  if (trimmed.match(/[.!?;]$/)) {
+    return trimmed;
+  }
+  
+  // If it ends with a comma, replace with period
+  if (trimmed.endsWith(',')) {
+    return trimmed.slice(0, -1) + '.';
+  }
+  
+  // Otherwise, add a period
+  return trimmed + '.';
+}
+
+// Function to extract complete verse text from XML
+function extractCompleteVerse(xmlContent: string, bcv: string): string {
+  // Find the verse in the XML
+  const versePattern = new RegExp(`<v id="[^"]*" bcv="${bcv.replace(/\./g, '\\.')}"[^>]*/>([\\s\\S]*?)(?=<v id="[^"]*" bcv="[^"]*"|<ve />|</p>)`, 'g');
+  const match = versePattern.exec(xmlContent);
+  
+  if (!match) {
+    return '';
+  }
+
+  let verseText = match[1];
+  
+  // Extract text from <w> tags
+  const wordPattern = /<w[^>]*>([^<]+)<\/w>/g;
+  let words: string[] = [];
+  let wordMatch;
+  
+  while ((wordMatch = wordPattern.exec(verseText)) !== null) {
+    words.push(wordMatch[1]);
+  }
+  
+  let completeVerse = words.join(' ').trim();
+  
+  // Check if the verse ends with a comma or incomplete sentence
+  // If so, try to find the complete sentence by looking at the next verse
+  if (completeVerse.endsWith(',') || !completeVerse.match(/[.!?;]$/)) {
+    // Extract chapter and verse numbers
+    const bcvMatch = bcv.match(/^([^.]+)\.(\d+)\.(\d+)$/);
+    if (bcvMatch) {
+      const [, book, chapter, verse] = bcvMatch;
+      const nextVerse = parseInt(verse) + 1;
+      const nextBcv = `${book}.${chapter}.${nextVerse}`;
+      
+      // Try to get the next verse
+      const nextVersePattern = new RegExp(`<v id="[^"]*" bcv="${nextBcv.replace(/\./g, '\\.')}"[^>]*/>([\\s\\S]*?)(?=<v id="[^"]*" bcv="[^"]*"|<ve />|</p>)`, 'g');
+      const nextMatch = nextVersePattern.exec(xmlContent);
+      
+      if (nextMatch) {
+        let nextVerseText = nextMatch[1];
+        const nextWords: string[] = [];
+        const nextWordPattern = /<w[^>]*>([^<]+)<\/w>/g;
+        let nextWordMatch;
+        
+        while ((nextWordMatch = nextWordPattern.exec(nextVerseText)) !== null) {
+          nextWords.push(nextWordMatch[1]);
+        }
+        
+        const nextCompleteVerse = nextWords.join(' ').trim();
+        
+        // Combine verses until we find a proper sentence ending
+        let combinedVerse = completeVerse + ' ' + nextCompleteVerse;
+        
+        // If still incomplete, try one more verse
+        if (combinedVerse.endsWith(',') || !combinedVerse.match(/[.!?;]$/)) {
+          const nextNextVerse = nextVerse + 1;
+          const nextNextBcv = `${book}.${chapter}.${nextNextVerse}`;
+          const nextNextVersePattern = new RegExp(`<v id="[^"]*" bcv="${nextNextBcv.replace(/\./g, '\\.')}"[^>]*/>([\\s\\S]*?)(?=<v id="[^"]*" bcv="[^"]*"|<ve />|</p>)`, 'g');
+          const nextNextMatch = nextNextVersePattern.exec(xmlContent);
+          
+          if (nextNextMatch) {
+            let nextNextVerseText = nextNextMatch[1];
+            const nextNextWords: string[] = [];
+            const nextNextWordPattern = /<w[^>]*>([^<]+)<\/w>/g;
+            let nextNextWordMatch;
+            
+            while ((nextNextWordMatch = nextNextWordPattern.exec(nextNextVerseText)) !== null) {
+              nextNextWords.push(nextNextWordMatch[1]);
+            }
+            
+            const nextNextCompleteVerse = nextNextWords.join(' ').trim();
+            combinedVerse = combinedVerse + ' ' + nextNextCompleteVerse;
+          }
+        }
+        
+        return addSentenceEnding(combinedVerse);
+      }
+    }
+  }
+  
+  return addSentenceEnding(completeVerse);
+}
+
+// Main conversion function
+function convertVerses(): void {
+  try {
+    // Read the original CSV file
+    const csvPath = path.join(__dirname, '../data/en.csv');
+    const xmlPath = path.join(__dirname, '../data/engwebp_usfx.xml');
+    
+    if (!fs.existsSync(csvPath)) {
+      console.error('Original CSV file not found:', csvPath);
+      return;
+    }
+    
+    if (!fs.existsSync(xmlPath)) {
+      console.error('XML file not found:', xmlPath);
+      return;
+    }
+    
+    console.log('Reading CSV file...');
+    const csvContent = fs.readFileSync(csvPath, 'utf-8');
+    const lines = csvContent.split('\n');
+    
+    console.log('Reading XML file...');
+    const xmlContent = fs.readFileSync(xmlPath, 'utf-8');
+    
+    const convertedVerses: ConvertedVerse[] = [];
+    const failedVerses: FailedVerse[] = [];
+    
+    console.log('Processing verses...');
+    
+    // Skip header line
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      
+      // Parse CSV line (simple parsing, assumes no commas in content)
+      const parts = line.split(',');
+      if (parts.length < 3) continue;
+      
+      const verse = parts[0];
+      const reference = parts[1];
+      const topic = parts[2];
+      
+      try {
+        const bcv = convertReferenceToXMLFormat(reference);
+        const convertedVerse = extractCompleteVerse(xmlContent, bcv);
+        
+        if (convertedVerse && convertedVerse.trim()) {
+          convertedVerses.push({
+            Verse: convertedVerse.trim(),
+            Reference: reference,
+            Topic: topic
+          });
+        } else {
+          failedVerses.push({
+            Verse: verse,
+            Reference: reference,
+            Topic: topic,
+            Reason: 'Could not find verse in XML'
+          });
+        }
+      } catch (error) {
+        failedVerses.push({
+          Verse: verse,
+          Reference: reference,
+          Topic: topic,
+          Reason: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
+        });
+      }
+    }
+    
+    // Write converted verses to CSV
+    const convertedPath = path.join(__dirname, '../data/en_converted.csv');
+    let convertedCsv = 'Verse,Reference,Topic\n';
+    convertedVerses.forEach(v => {
+      convertedCsv += `${v.Verse},${v.Reference},${v.Topic}\n`;
+    });
+    fs.writeFileSync(convertedPath, convertedCsv);
+    
+    // Write failed verses to CSV
+    const failedPath = path.join(__dirname, '../data/en_failed.csv');
+    let failedCsv = 'Verse,Reference,Topic,Reason\n';
+    failedVerses.forEach(v => {
+      failedCsv += `${v.Verse},${v.Reference},${v.Topic},${v.Reason}\n`;
+    });
+    fs.writeFileSync(failedPath, failedCsv);
+    
+    console.log(`\nConversion complete!`);
+    console.log(`Successfully converted: ${convertedVerses.length} verses`);
+    console.log(`Failed to convert: ${failedVerses.length} verses`);
+    console.log(`Total processed: ${convertedVerses.length + failedVerses.length} verses`);
+    console.log(`\nFiles created:`);
+    console.log(`- ${convertedPath} (${convertedVerses.length + 1} lines)`);
+    console.log(`- ${failedPath} (${failedVerses.length + 1} lines)`);
+    
+  } catch (error) {
+    console.error('Error during conversion:', error);
+  }
+}
+
+// Run the conversion
+convertVerses();