@ihsandeen/aya 1.0.0

package/src/data/tafsir.ts

@@ -0,0 +1,165 @@
+export interface Tafsir {
+  surah: string;
+  ayah: number;
+  steps: {
+    word: string;
+    meaning: string;
+    explanation: string;
+  }[];
+  finalThought: string;
+}
+
+export const tafsirData: Tafsir[] = [
+  {
+    surah: 'Ad-Duhaa',
+    ayah: 3,
+    steps: [
+      {
+        word: 'Maa',
+        meaning: 'Not / Negation',
+        explanation: 'The sentence starts with a strong negation. Allah is immediately shutting down the whispers of the disbelievers who said He had abandoned the Prophet (saw).'
+      },
+      {
+        word: 'wadda\'aka',
+        meaning: 'He said goodbye / He bid farewell',
+        explanation: 'From "wada\'a". This isn\'t just "left". It\'s a warm, affectionate goodbye. Like when a mother says goodbye to her child. Allah is saying "I didn\'t even say a warm goodbye to you, let alone abandon you."'
+      },
+      {
+        word: 'Rabbuka',
+        meaning: 'Your Lord / Your Master / Your Sustainer',
+        explanation: 'He didn\'t say "Allah". He said "Your Lord". The one who has been raising you, sustaining you, and caring for you from the beginning. It\'s personal. "YOUR" Lord.'
+      },
+      {
+        word: 'wa maa qalaa',
+        meaning: 'And He is not displeased / He does not hate',
+        explanation: '"Qalaa" means intense displeasure or hate. Notice He didn\'t say "wa maa qalaa-ka" (He is not displeased with YOU). He left out the "you" (ka). Why? Because He loves the Prophet (saw) so much, He didn\'t even want to put the word "hate" and "you" in the same sentence. SubhanAllah.'
+      }
+    ],
+    finalThought: "If you feel distant from Allah, know that He hasn't said goodbye. He is your Rabb. He is sustaining you even in your silence."
+  },
+  {
+    surah: 'Al-Fatiha',
+    ayah: 5,
+    steps: [
+      {
+        word: 'Iyyaka',
+        meaning: 'Only You',
+        explanation: 'Grammatically, "Na\'budu" (We worship) should come first. But Allah placed "Iyyaka" (Only You) at the front. This is "Taqdeem" for "Ikhtisas" (Exclusivity). Not "We worship You", but "It is ONLY You we worship".'
+      },
+      {
+        word: 'Na\'budu',
+        meaning: 'We worship / We enslave ourselves',
+        explanation: 'From "Abd" (Slave). Worship isn\'t just prayer. It is slavery. It is total submission. And notice "We". Even when you pray alone, you are part of the "We"—the Ummah.'
+      },
+      {
+        word: 'Wa Iyyaka',
+        meaning: 'And Only You',
+        explanation: 'Repetition for emphasis. We are not just monotheists in worship, but monotheists in seeking help.'
+      },
+      {
+        word: 'Nasta\'een',
+        meaning: 'We seek help / We ask for aid',
+        explanation: 'From "Isti\'anah". This isn\'t just "help me lift this box". It is asking for help in a matter you are already struggling with. You have to make the effort first, then ask for His aid to complete it.'
+      }
+    ],
+    finalThought: "You can't skip to 'Nasta'een' (Help me) without first committing to 'Na'budu' (I am your slave). The help comes to the one who serves."
+  },
+  {
+    surah: 'Al-Asr',
+    ayah: 1,
+    steps: [
+      {
+        word: 'Wal-Asr',
+        meaning: 'By Time',
+        explanation: 'Allah swears by "Time" (Asr). But Asr isn\'t just time; it\'s the squeezing of time. It\'s the late afternoon when the day is slipping away. He is swearing by the very thing we are losing every second.'
+      },
+      {
+        word: 'Inna',
+        meaning: 'Indeed / Verily',
+        explanation: 'Emphasis. No doubt about it.'
+      },
+      {
+        word: 'Al-Insaan',
+        meaning: 'The Human Being',
+        explanation: 'He didn\'t say "The Disbeliever". He said "The Human". Every single one of us. We are all in the same boat.'
+      },
+      {
+        word: 'La-fee Khusr',
+        meaning: 'Is surely in loss',
+        explanation: 'We aren\'t "going" to be in loss. We are *drowning* in loss right now. Like ice melting. Every breath is a capital loss unless invested.'
+      }
+    ],
+    finalThought: "You are running out of time. The only way to stop the loss is to invest your time in Iman and good deeds."
+  },
+  {
+    surah: 'Al-Ikhlas',
+    ayah: 1,
+    steps: [
+      {
+        word: 'Qul',
+        meaning: 'Say / Declare',
+        explanation: 'A direct command. Don\'t just know it, announce it. This is your identity.'
+      },
+      {
+        word: 'Huwa Allahu',
+        meaning: 'He is Allah',
+        explanation: 'The name Allah is unique. It has no plural, no gender. It is the proper name of God.'
+      },
+      {
+        word: 'Ahad',
+        meaning: 'The One / The Unique',
+        explanation: 'Not "Wahid" (one in number), but "Ahad" (Unique in every way). There is nothing comparable to Him. He is a category of One.'
+      }
+    ],
+    finalThought: "Purify your concept of God. He is not like anything you can imagine."
+  },
+  {
+    surah: 'Al-Falaq',
+    ayah: 1,
+    steps: [
+      {
+        word: 'Qul',
+        meaning: 'Say',
+        explanation: 'Again, a command to seek refuge actively.'
+      },
+      {
+        word: 'A\'udhu',
+        meaning: 'I seek refuge / I take cover',
+        explanation: 'Imagine a fortress. You are running into it for safety. You are admitting you are weak and need protection.'
+      },
+      {
+        word: 'Bi Rabbil Falaq',
+        meaning: 'In the Lord of the Daybreak',
+        explanation: 'Falaq is the splitting of darkness by light. Just as He splits the night to bring the dawn, He can split your problems to bring relief.'
+      }
+    ],
+    finalThought: "Darkness is temporary. The Lord of the Dawn is always ready to bring the light."
+  },
+  {
+    surah: 'An-Nas',
+    ayah: 1,
+    steps: [
+      {
+        word: 'Qul A\'udhu',
+        meaning: 'Say: I seek refuge',
+        explanation: 'We start with seeking protection again.'
+      },
+      {
+        word: 'Bi Rabbin-Nas',
+        meaning: 'In the Lord of Mankind',
+        explanation: 'He created us, sustains us, and owns us.'
+      },
+      {
+        word: 'Malikin-Nas',
+        meaning: 'The King of Mankind',
+        explanation: 'He has full authority over all people, including those who wish you harm.'
+      },
+      {
+        word: 'Ilahin-Nas',
+        meaning: 'The God of Mankind',
+        explanation: 'The only one worthy of worship and total devotion.'
+      }
+    ],
+    finalThought: "He is your Lord, your King, and your God. Who can harm you when you are with Him?"
+  }
+];

package/src/data/vocab.ts

@@ -0,0 +1,114 @@
+export interface Vocab {
+  id: string;
+  ayah: string;
+  missingWord: string;
+  answer: string;
+  meaning: string;
+  category: 'fatiha' | 'names_of_allah' | 'common' | 'short_surahs';
+}
+
+export const vocabList: Vocab[] = [
+  // Surah Al-Fatiha
+  {
+    id: 'fatiha_1',
+    ayah: '_____ iyyaka na\'budu wa iyyaka nasta\'een (1:5)',
+    missingWord: '[?]',
+    answer: 'Iyyaka',
+    meaning: 'Only You',
+    category: 'fatiha'
+  },
+  {
+    id: 'fatiha_2',
+    ayah: 'Ihdina al-sirat al-_____ (1:6)',
+    missingWord: '[?]',
+    answer: 'mustaqeem',
+    meaning: 'straight / upright',
+    category: 'fatiha'
+  },
+  {
+    id: 'fatiha_3',
+    ayah: 'Maliki yawm al-_____ (1:4)',
+    missingWord: '[?]',
+    answer: 'deen',
+    meaning: 'judgment / recompense',
+    category: 'fatiha'
+  },
+  {
+    id: 'fatiha_4',
+    ayah: 'Al-hamdu lillahi rabbi al-_____ (1:2)',
+    missingWord: '[?]',
+    answer: 'alameen',
+    meaning: 'worlds / universe',
+    category: 'fatiha'
+  },
+
+  // Names of Allah
+  {
+    id: 'names_1',
+    ayah: 'Wa huwa al-Ghafoor al-_____ (85:14)',
+    missingWord: '[?]',
+    answer: 'wadood',
+    meaning: 'The Loving / Affectionate',
+    category: 'names_of_allah'
+  },
+  {
+    id: 'names_2',
+    ayah: 'Qul huwa Allahu _____ (112:1)',
+    missingWord: '[?]',
+    answer: 'ahad',
+    meaning: 'The One / Unique',
+    category: 'names_of_allah'
+  },
+  {
+    id: 'names_3',
+    ayah: 'Ar-Rahman _____ (55:1)',
+    missingWord: '[?]',
+    answer: 'Ar-Raheem',
+    meaning: 'The Most Merciful',
+    category: 'names_of_allah'
+  },
+
+  // Common Words
+  {
+    id: 'common_1',
+    ayah: 'Inna ma\'al usri _____ (94:6)',
+    missingWord: '[?]',
+    answer: 'yusra',
+    meaning: 'relief / ease',
+    category: 'common'
+  },
+  {
+    id: 'common_2',
+    ayah: 'Hasbuna Allah wa ni\'mal _____ (3:173)',
+    missingWord: '[?]',
+    answer: 'wakil',
+    meaning: 'disposer of affairs / trustee',
+    category: 'common'
+  },
+  
+  // Short Surahs
+  {
+    id: 'short_1',
+    ayah: 'Wama _____ rabbuka wama qalaa (93:3)',
+    missingWord: '[?]',
+    answer: 'wadda\'aka',
+    meaning: 'said goodbye / abandoned',
+    category: 'short_surahs'
+  },
+  {
+    id: 'short_2',
+    ayah: 'Inna a\'tayna kal _____ (108:1)',
+    missingWord: '[?]',
+    answer: 'kawthar',
+    meaning: 'abundance / river in paradise',
+    category: 'short_surahs'
+  },
+  {
+    id: 'short_3',
+    ayah: 'Idha ja\'a nasrullahi wal _____ (110:1)',
+    missingWord: '[?]',
+    answer: 'fath',
+    meaning: 'victory / opening',
+    category: 'short_surahs'
+  }
+];

package/src/index.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import { initCommand } from './commands/init';
+import { pullCommand } from './commands/pull';
+import { statusCommand } from './commands/status';
+import { commitCommand } from './commands/commit';
+import { blameCommand } from './commands/blame';
+import { pushCommand } from './commands/push';
+import { journalCommand } from './commands/journal';
+import { tafsirCommand } from './commands/tafsir';
+import { memorizeCommand } from './commands/memorize';
+import { qiblaCommand } from './commands/qibla';
+import { adhanCommand } from './commands/adhan';
+import { parableCommand } from './commands/parable';
+import { historyCommand } from './commands/history';
+import { nazmCommand } from './commands/nazm';
+import { diffCommand } from './commands/diff';
+import { mirrorCommand } from './commands/mirror';
+import { soundCommand } from './commands/sound';
+import { lensCommand } from './commands/lens';
+import { sceneCommand } from './commands/scene';
+import { heroCommand } from './commands/hero';
+import { hijriCommand } from './commands/hijri';
+import { zakatCommand } from './commands/zakat';
+import { tasbihCommand } from './commands/tasbih';
+import { prayersCommand } from './commands/prayers';
+import { namesCommand } from './commands/names';
+import { duaCommand } from './commands/dua';
+import { fastCommand } from './commands/fast';
+import { sunnahCommand } from './commands/sunnah';
+import { sleepCommand } from './commands/sleep';
+import { anatomyCommand } from './commands/anatomy';
+import { journeyCommand } from './commands/journey';
+import { natureCommand } from './commands/nature';
+import { wuduCommand } from './commands/wudu';
+import { investCommand } from './commands/invest';
+import { sabrCommand } from './commands/sabr';
+import { shukrCommand } from './commands/shukr';
+import { fridayCommand } from './commands/friday';
+import { adabCommand } from './commands/adab';
+import { seekCommand } from './commands/seek';
+import { repoCommand } from './commands/repo';
+
+const program = new Command();
+
+// Bismillah Header
+console.log(chalk.dim('In the name of Allah, the Most Gracious, the Most Merciful'));
+
+console.log(
+  chalk.green(
+    figlet.textSync('aya', { horizontalLayout: 'full' })
+  )
+);
+
+program
+  .name('aya')
+  .description('A CLI for the mindful Muslim developer')
+  .version('1.0.0')
+  .action(() => {
+    program.outputHelp();
+  });
+
+// Register Commands
+const commands = [
+  initCommand, pullCommand, statusCommand, commitCommand, blameCommand,
+  pushCommand, journalCommand, tafsirCommand, memorizeCommand, qiblaCommand,
+  adhanCommand, parableCommand, historyCommand, nazmCommand, diffCommand,
+  mirrorCommand, soundCommand, lensCommand, sceneCommand, heroCommand,
+  hijriCommand, zakatCommand, tasbihCommand, prayersCommand, namesCommand,
+  duaCommand, fastCommand, sunnahCommand, sleepCommand, anatomyCommand,
+  journeyCommand, natureCommand, wuduCommand, investCommand, sabrCommand,
+  shukrCommand, fridayCommand, adabCommand, seekCommand, repoCommand
+];
+
+commands.forEach(cmd => program.addCommand(cmd));
+
+// Global Error Handler
+process.on('uncaughtException', (error) => {
+  if (error instanceof Error && error.message.includes('EPIPE')) {
+    // Ignore EPIPE errors (broken pipe) often caused by piping output
+    return;
+  }
+  console.error(chalk.red('\n❌ An unexpected error occurred (Qadar Allah).'));
+  console.error(chalk.gray(error.message));
+  process.exit(1);
+});
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/src/server.ts

@@ -0,0 +1,128 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { logger } from './utils/logger';
+
+const PUBLIC_DIR = path.join(__dirname, '../public');
+
+const serveFile = (res: http.ServerResponse, filePath: string, contentType: string = 'text/html') => {
+    fs.readFile(filePath, (err, content) => {
+        if (err) {
+            if (err.code === 'ENOENT') {
+                res.writeHead(404);
+                res.end('Not Found');
+            } else {
+                res.writeHead(500);
+                res.end(`Server Error: ${err.code}`);
+            }
+        } else {
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content, 'utf-8');
+        }
+    });
+};
+
+const readBody = (req: http.IncomingMessage): Promise<any> => {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => { body += chunk.toString(); });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            } catch (e) {
+                reject(e);
+            }
+        });
+        req.on('error', (err) => reject(err));
+    });
+};
+
+export const startServer = (port = 0): Promise<number> => {
+    return new Promise((resolve) => {
+        const server = http.createServer(async (req, res) => {
+            // Basic Router
+            if (req.url === '/' || req.url === '/index.html') {
+                serveFile(res, path.join(PUBLIC_DIR, 'index.html'));
+            } else if (req.url === '/repo') {
+                serveFile(res, path.join(PUBLIC_DIR, 'repo.html'));
+            } else if (req.url === '/hero') {
+                serveFile(res, path.join(PUBLIC_DIR, 'hero.html'));
+            } else if (req.url === '/api/commits') {
+                // API Endpoint: Serve commits log as JSON using the Logger utility
+                try {
+                    const commits = logger.getCommits();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(commits));
+                } catch (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Failed to read logs' }));
+                }
+            } else if (req.url === '/api/issues') {
+                if (req.method === 'GET') {
+                    const issues = logger.getIssues();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(issues));
+                } else if (req.method === 'POST') {
+                    try {
+                        const body = await readBody(req);
+                        if (body.title) {
+                            const issue = logger.logIssue(body.title);
+                            res.writeHead(201, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(issue));
+                        } else {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'Title required' }));
+                        }
+                    } catch (e) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                    }
+                }
+            } else if (req.url === '/api/pulls') {
+                if (req.method === 'GET') {
+                    const pulls = logger.getPulls();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(pulls));
+                } else if (req.method === 'POST') {
+                    try {
+                        const body = await readBody(req);
+                        if (body.title) {
+                            const pull = logger.logPull(body.title);
+                            res.writeHead(201, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(pull));
+                        } else {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'Title required' }));
+                        }
+                    } catch (e) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                    }
+                }
+            } else {
+                // 404 for any other route
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+
+        server.listen(port, () => {
+            const address = server.address();
+            const assignedPort = typeof address === 'string' ? 0 : (address as any).port;
+            resolve(assignedPort);
+        });
+    });
+};
+
+// Only run directly if executed as a script (not imported)
+if (require.main === module) {
+    startServer().then(port => {
+        console.log(chalk.green.bold(`\n  🌙 aya Landing Page is running!`));
+        console.log(chalk.white(`  Open your Book of Deeds:`));
+        console.log(chalk.cyan.bold(`  http://localhost:${port}/repo`));
+        console.log(chalk.white(`  Open the Hero Section:`));
+        console.log(chalk.cyan.bold(`  http://localhost:${port}/hero`));
+        console.log(chalk.gray(`\n  Press Ctrl+C to stop.`));
+    });
+}

package/src/utils/config.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CONFIG_DIR = path.join(process.cwd(), '.aya');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+interface UserConfig {
+  name?: string;
+  intention?: string;
+  location?: {
+    city: string;
+    country: string;
+  };
+  lastPrayerCheck?: string;
+}
+
+const defaultConfig: UserConfig = {
+  location: {
+    city: 'Mecca',
+    country: 'Saudi Arabia'
+  }
+};
+
+export const getConfig = (): UserConfig => {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return defaultConfig;
+  }
+  try {
+    const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    return defaultConfig;
+  }
+};
+
+export const setConfig = (newConfig: Partial<UserConfig>) => {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const currentConfig = getConfig();
+  const updatedConfig = { ...currentConfig, ...newConfig };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
+};

package/src/utils/logger.ts

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+
+const CONFIG_DIR = path.join(process.cwd(), '.aya');
+const LOG_FILE = path.join(CONFIG_DIR, 'commits.log');
+const ISSUES_FILE = path.join(CONFIG_DIR, 'issues.log');
+const PULLS_FILE = path.join(CONFIG_DIR, 'pulls.log');
+
+export interface Commit {
+  timestamp: string;
+  message: string;
+  hash: string;
+  path?: string; // Optional file path simulation
+}
+
+export interface Issue {
+  id: string;
+  title: string;
+  status: 'open' | 'closed';
+  timestamp: string;
+}
+
+export interface Pull {
+  id: string;
+  title: string;
+  status: 'open' | 'merged' | 'closed';
+  timestamp: string;
+}
+
+export const logger = {
+  ensureInit: () => {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+  },
+
+  // --- Commits (Deeds) ---
+  logCommit: (message: string): Commit => {
+    logger.ensureInit();
+    
+    const timestamp = new Date().toISOString();
+    // Simple format: [ISO] Message
+    const logEntry = `[${timestamp}] ${message}\n`;
+    
+    fs.appendFileSync(LOG_FILE, logEntry);
+
+    return {
+      timestamp,
+      message,
+      hash: Math.random().toString(16).substring(2, 9)
+    };
+  },
+
+  getCommits: (): Commit[] => {
+    if (!fs.existsSync(LOG_FILE)) return [];
+
+    try {
+      const content = fs.readFileSync(LOG_FILE, 'utf-8');
+      const lines = content.split('\n').filter(line => line.trim());
+      
+      return lines.map(line => {
+        // Match [timestamp] message
+        const match = line.match(/^\[(.*?)\] (.*)$/);
+        if (match) {
+            // Generate a deterministic-looking hash from timestamp
+            const hash = Math.abs(match[1].split('').reduce((a,b)=>{a=((a<<5)-a)+b.charCodeAt(0);return a&a},0)).toString(16).substring(0,7);
+            return {
+                timestamp: match[1],
+                message: match[2],
+                hash: hash
+            };
+        }
+        return null;
+      }).filter((c): c is Commit => c !== null);
+    } catch (error) {
+      console.error('Error reading log file:', error);
+      return [];
+    }
+  },
+
+  getTotalDeeds: (): number => {
+    if (!fs.existsSync(LOG_FILE)) return 0;
+    const content = fs.readFileSync(LOG_FILE, 'utf-8');
+    return content.split('\n').filter(line => line.trim()).length;
+  },
+
+  // --- Issues (Istighfar/Sins) ---
+  logIssue: (title: string): Issue => {
+    logger.ensureInit();
+    const timestamp = new Date().toISOString();
+    const id = Math.floor(Math.random() * 1000).toString();
+    const entry = JSON.stringify({ id, title, status: 'open', timestamp }) + '\n';
+    fs.appendFileSync(ISSUES_FILE, entry);
+    return { id, title, status: 'open', timestamp };
+  },
+
+  getIssues: (): Issue[] => {
+    if (!fs.existsSync(ISSUES_FILE)) return [];
+    try {
+        const content = fs.readFileSync(ISSUES_FILE, 'utf-8');
+        return content.trim().split('\n').map(line => JSON.parse(line));
+    } catch (e) { return []; }
+  },
+
+  // --- Pulls (Duas) ---
+  logPull: (title: string): Pull => {
+    logger.ensureInit();
+    const timestamp = new Date().toISOString();
+    const id = Math.floor(Math.random() * 1000).toString();
+    const entry = JSON.stringify({ id, title, status: 'open', timestamp }) + '\n';
+    fs.appendFileSync(PULLS_FILE, entry);
+    return { id, title, status: 'open', timestamp };
+  },
+
+  getPulls: (): Pull[] => {
+    if (!fs.existsSync(PULLS_FILE)) return [];
+    try {
+        const content = fs.readFileSync(PULLS_FILE, 'utf-8');
+        return content.trim().split('\n').map(line => JSON.parse(line));
+    } catch (e) { return []; }
+  }
+};