remember-when-cli 1.0.1

package/README.md

@@ -0,0 +1,66 @@
+# Remember When - Storage CLI
+
+The persistence engine for the **Remember When** digital memory system. This Node.js application handles local file organization, automatic folder structure, and the master timeline ledger.
+
+## 📦 Installation
+
+Install globally to enable the `remember-when` command system-wide:
+
+```bash
+cd remember-when-cli
+npm install -g .
+```
+
+## 🛠 Command Reference
+
+### `add`
+Registers a new event and optionally moves a file to the permanent local archive.
+```bash
+remember-when add -g "Friends" -t "photo" -s "Juan" -r "Beach day" -f "/tmp/img.jpg"
+```
+
+### `set-group-info`
+Defines the purpose and participants of a group.
+```bash
+remember-when set-group-info -g "Friends" -d "Local hangout crew" -p "Juan, Eric, Maria"
+```
+
+### `set-daily-summary`
+Adds a high-level summary of what happened during a specific day.
+```bash
+remember-when set-daily-summary -g "Friends" -d "2026-04-10" -s "We planned the summer trip."
+```
+
+### `inventory`
+Audits the storage and highlights missing metadata or gaps in chronicles.
+```bash
+remember-when inventory
+```
+
+## 📂 Storage Architecture
+
+All data is stored in your home directory: `~/.remember-when/`
+
+### 1. `timeline.json`
+The master index of all your memories.
+```json
+{
+  "groups": {
+    "Friends": {
+      "info": { "description": "...", "participants": [] },
+      "daily_summaries": { "2026-04-10": "..." }
+    }
+  },
+  "entries": [
+    { "id": "...", "type": "...", "summary": "...", "file": "2026-04-10/123-img.jpg" }
+  ]
+}
+```
+
+### 2. Daily Folders
+Media files are copied to `~/.remember-when/YYYY-MM-DD/` with unique timestamps to prevent name collisions.
+
+## 🧪 Testing
+```bash
+npm test
+```

package/cli.test.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Setup test dir before importing index.js logic
+const testDir = path.join(os.tmpdir(), `remember-when-test-${Date.now()}`);
+process.env.REMEMBER_WHEN_TEST_DIR = testDir;
+
+import { 
+  addEntry, 
+  setGroupInfo, 
+  setDailySummary, 
+  loadTimeline
+} from './index.js';
+
+describe('Remember When CLI - Logic Tests', () => {
+
+  beforeAll(() => {
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(() => {
+    // Clear timeline before each test
+    const timelinePath = path.join(testDir, 'timeline.json');
+    if (fs.existsSync(timelinePath)) {
+      fs.unlinkSync(timelinePath);
+    }
+  });
+
+  it('should add a text entry correctly', () => {
+    const options = {
+      group: 'TestGroup',
+      type: 'text',
+      sender: 'Jest',
+      summary: 'Unit test entry',
+      date: new Date().toISOString()
+    };
+
+    const entry = addEntry(options);
+    const timeline = loadTimeline();
+
+    expect(Array.isArray(timeline.entries)).toBe(true);
+    expect(timeline.entries).toHaveLength(1);
+    expect(timeline.entries[0].group).toBe('TestGroup');
+    expect(timeline.entries[0].summary).toBe('Unit test entry');
+    expect(entry.id).toBeDefined();
+  });
+
+  it('should set group info correctly', () => {
+    const options = {
+      group: 'TestGroup',
+      desc: 'A group for testing',
+      participants: 'User1, User2'
+    };
+
+    setGroupInfo(options);
+    const timeline = loadTimeline();
+
+    expect(timeline.groups['TestGroup']).toBeDefined();
+    expect(timeline.groups['TestGroup'].info.description).toBe('A group for testing');
+    expect(timeline.groups['TestGroup'].info.participants).toEqual(['User1', 'User2']);
+  });
+
+  it('should set daily summary correctly', () => {
+    const options = {
+      group: 'TestGroup',
+      date: '2026-04-10',
+      summary: 'Today nothing happened'
+    };
+
+    setDailySummary(options);
+    const timeline = loadTimeline();
+
+    expect(timeline.groups['TestGroup'].daily_summaries['2026-04-10']).toBe('Today nothing happened');
+  });
+
+  it('should copy file when provided in add', () => {
+    const tempFilePath = path.join(testDir, 'test-file.txt');
+    fs.writeFileSync(tempFilePath, 'hello world');
+
+    const options = {
+      group: 'FileGroup',
+      type: 'file',
+      sender: 'Jest',
+      summary: 'File test',
+      date: '2026-04-10T10:00:00.000Z',
+      file: tempFilePath
+    };
+
+    const entry = addEntry(options);
+    
+    // Check if file exists in the day folder
+    const dayFolder = '2026-04-10';
+    const storedPath = path.join(testDir, entry.file);
+    
+    expect(fs.existsSync(storedPath)).toBe(true);
+    expect(fs.readFileSync(storedPath, 'utf8')).toBe('hello world');
+  });
+});

package/e2e.test.js

@@ -0,0 +1,43 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+describe('Remember When CLI - E2E Tests', () => {
+  const testDir = path.join(os.tmpdir(), `remember-when-e2e-${Date.now()}`);
+  const cliPath = path.resolve('./index.js');
+
+  beforeAll(() => {
+    if (!fs.existsSync(testDir)) {
+      fs.mkdirSync(testDir, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should run "add" command successfully', () => {
+    const cmd = `REMEMBER_WHEN_TEST_DIR=${testDir} node ${cliPath} add -g E2EGroup -t text -s Tester -r "E2E Test Summary"`;
+    const output = execSync(cmd).toString();
+    
+    expect(output).toContain('[remember-when] Added entry to E2EGroup');
+    
+    const timelinePath = path.join(testDir, 'timeline.json');
+    expect(fs.existsSync(timelinePath)).toBe(true);
+    
+    const timeline = JSON.parse(fs.readFileSync(timelinePath, 'utf8'));
+    expect(timeline.entries[0].group).toBe('E2EGroup');
+  });
+
+  it('should run "inventory" command successfully', () => {
+    const cmd = `REMEMBER_WHEN_TEST_DIR=${testDir} node ${cliPath} inventory`;
+    const output = execSync(cmd).toString();
+    
+    expect(output).toContain('--- REMEMBER-WHEN INVENTORY ---');
+    expect(output).toContain('Group: E2EGroup');
+    expect(output).toContain('[!] MISSING: Group description');
+  });
+});

package/index.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('./package.json');
+
+export function getStorageRoot() {
+  return process.env.REMEMBER_WHEN_TEST_DIR 
+    ? process.env.REMEMBER_WHEN_TEST_DIR 
+    : path.join(os.homedir(), '.remember-when');
+}
+
+export function getTimelinePath() {
+  return path.join(getStorageRoot(), 'timeline.json');
+}
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function loadTimeline() {
+  const root = getStorageRoot();
+  const timelinePath = getTimelinePath();
+  ensureDir(root);
+  if (!fs.existsSync(timelinePath)) {
+    return { groups: {}, entries: [] };
+  }
+  try {
+    const data = fs.readFileSync(timelinePath, 'utf8');
+    const parsed = JSON.parse(data || '{}');
+    return {
+      groups: parsed.groups || {},
+      entries: Array.isArray(parsed.entries) ? parsed.entries : []
+    };
+  } catch (e) {
+    return { groups: {}, entries: [] };
+  }
+}
+
+export function saveTimeline(timeline) {
+  const root = getStorageRoot();
+  const timelinePath = getTimelinePath();
+  ensureDir(root);
+  fs.writeFileSync(timelinePath, JSON.stringify(timeline, null, 2), 'utf8');
+}
+
+export function addEntry(options) {
+  const root = getStorageRoot();
+  const timeline = loadTimeline();
+  const date = new Date(options.date);
+  const dayFolderName = date.toISOString().split('T')[0];
+  let storedFilePath = null;
+
+  if (options.file && fs.existsSync(options.file)) {
+    const dayFolderPath = path.join(root, dayFolderName);
+    ensureDir(dayFolderPath);
+    const safeName = `${Date.now()}-${path.basename(options.file)}`;
+    storedFilePath = path.join(dayFolderName, safeName);
+    fs.copyFileSync(options.file, path.join(root, storedFilePath));
+  }
+
+  const entry = {
+    id: Math.random().toString(36).substring(2, 11),
+    timestamp: new Date().toISOString(),
+    originalDate: options.date,
+    group: options.group,
+    type: options.type,
+    sender: options.sender,
+    summary: options.summary,
+    file: storedFilePath
+  };
+
+  timeline.entries.push(entry);
+  saveTimeline(timeline);
+  return entry;
+}
+
+export function setGroupInfo(options) {
+  const timeline = loadTimeline();
+  if (!timeline.groups[options.group]) timeline.groups[options.group] = { info: {}, daily_summaries: {} };
+  
+  timeline.groups[options.group].info = {
+    description: options.desc,
+    participants: (options.participants || '').split(',').map(p => p.trim())
+  };
+  
+  saveTimeline(timeline);
+}
+
+export function setDailySummary(options) {
+  const timeline = loadTimeline();
+  if (!timeline.groups[options.group]) timeline.groups[options.group] = { info: {}, daily_summaries: {} };
+  
+  timeline.groups[options.group].daily_summaries[options.date] = options.summary;
+  
+  saveTimeline(timeline);
+}
+
+// CLI definition
+const isMain = import.meta.url === `file://${fs.realpathSync(process.argv[1])}` || process.argv[1].endsWith('remember-when');
+
+if (isMain) {
+  program
+    .name('remember-when')
+    .description('Local storage system for your digital memories')
+    .version(pkg.version);
+
+  program.command('add')
+    .description('Registers a new memory entry')
+    .requiredOption('-g, --group <group>', 'Group identifier')
+    .requiredOption('-t, --type <type>', 'Entry type (text, photo, etc.)')
+    .requiredOption('-s, --sender <sender>', 'Who sent it')
+    .requiredOption('-r, --summary <summary>', 'Entry description')
+    .option('-d, --date <date>', 'ISO Date', new Date().toISOString())
+    .option('-f, --file <path>', 'Local file path')
+    .action((options) => {
+      try {
+        const entry = addEntry(options);
+        console.log(`[remember-when] Added entry to ${options.group} | ID: ${entry.id}`);
+      } catch (err) {
+        console.error(`[remember-when] Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  program.command('set-group-info')
+    .description('Updates context information for a group')
+    .requiredOption('-g, --group <group>', 'Group identifier')
+    .requiredOption('-d, --desc <description>', 'What is this group about?')
+    .requiredOption('-p, --participants <participants>', 'List of members (comma separated)')
+    .action((options) => {
+      setGroupInfo(options);
+      console.log(`[remember-when] Group info updated for: ${options.group}`);
+    });
+
+  program.command('set-daily-summary')
+    .description('Sets a brief summary for a specific day')
+    .requiredOption('-g, --group <group>', 'Group identifier')
+    .requiredOption('-s, --summary <summary>', 'What happened today?')
+    .option('-d, --date <date>', 'Date (YYYY-MM-DD)', new Date().toISOString().split('T')[0])
+    .action((options) => {
+      setDailySummary(options);
+      console.log(`[remember-when] Daily summary updated for ${options.group} on ${options.date}`);
+    });
+
+  program.command('inventory')
+    .description('Shows missing information (context or summaries)')
+    .action(() => {
+      const timeline = loadTimeline();
+      console.log('\n--- REMEMBER-WHEN INVENTORY ---');
+      
+      if (timeline.entries.length === 0) {
+        console.log('No entries found yet. Use "add" to begin.');
+        return;
+      }
+
+      const allGroups = [...new Set(timeline.entries.map(e => e.group))];
+      
+      allGroups.forEach(groupName => {
+        console.log(`\nGroup: ${groupName}`);
+        const group = timeline.groups[groupName];
+        
+        if (!group || !group.info || !group.info.description) {
+          console.log(' [!] MISSING: Group description and participants. Use set-group-info.');
+        } else {
+          console.log(' [ok] Group info present.');
+        }
+        
+        const daysWithEntries = [...new Set(timeline.entries
+          .filter(e => e.group === groupName)
+          .map(e => e.originalDate.split('T')[0]))];
+        
+        const missingDays = daysWithEntries.filter(day => !group || !group.daily_summaries[day]);
+        
+        if (missingDays.length > 0) {
+          console.log(` [!] MISSING: Daily summaries for: ${missingDays.join(', ')}`);
+        } else {
+          console.log(' [ok] All active days have summaries.');
+        }
+      });
+      console.log('\n');
+    });
+
+  program.parse();
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "remember-when-cli",
+  "version": "1.0.1",
+  "description": "Local storage CLI for digital memories",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "remember-when": "./index.js"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}