wasibase 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# Wasibase
+
+> Dein Second Brain. Terminal-basiert. Mit Backlinks.
+
+Ein terminal-basiertes Notizen-System mit Markdown-Unterstuetzung, Backlinks und Graph-Visualisierung.
+
+## Installation
+
+```bash
+npm install -g wasibase
+```
+
+## Verwendung
+
+```bash
+# Hauptmenu oeffnen
+wasibase
+
+# Neue Note erstellen oder bearbeiten
+wasibase note
+
+# Notes durchsuchen
+wasibase search
+
+# Wissens-Graph anzeigen
+wasibase graph
+
+# Backup erstellen/wiederherstellen
+wasibase backup
+
+# Mit Cloud synchronisieren (Proton Drive, Dropbox, iCloud)
+wasibase sync
+```
+
+## Features
+
+- **Markdown Notes** - Schreibe deine Notizen in Markdown mit Live-Vorschau
+- **Backlinks** - Verknuepfe Wissen mit `[[Backlinks]]` wie in Obsidian
+- **Graph View** - Visualisiere dein Wissen als interaktiven Graph
+- **Schnelle Suche** - Finde jede Note sofort
+- **Cloud Backup** - Automatisches Backup zu Proton Drive, Dropbox oder iCloud
+- **Terminal First** - Schnell und effizient direkt aus dem Terminal
+
+## Struktur
+
+Notes werden in `~/.wasibase/notes/` gespeichert:
+
+```
+~/.wasibase/
+├── notes/
+│   ├── Oberkategorie/
+│   │   └── Unterkategorie/
+│   │       └── Note.md
+├── backups/
+└── config.json
+```
+
+## Systemanforderungen
+
+- Node.js 18+
+- macOS, Linux oder Windows
+
+## Lizenz
+
+MIT
+
+## Autor
+
+[Wasili](https://github.com/wasuli)

package/bin/wasibase.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { main } from '../src/index.js';
+
+main();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "wasibase",
+  "version": "1.0.0",
+  "description": "Second Brain - Terminal-basiertes Notizen-System mit Backlinks und Graph-Visualisierung",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "wasibase": "./bin/wasibase.js"
+  },
+  "scripts": {
+    "start": "node bin/wasibase.js",
+    "note": "node bin/wasibase.js note",
+    "search": "node bin/wasibase.js search",
+    "graph": "node bin/wasibase.js graph",
+    "backup": "node bin/wasibase.js backup",
+    "sync": "node bin/wasibase.js sync"
+  },
+  "keywords": [
+    "notes",
+    "second-brain",
+    "backlinks",
+    "markdown",
+    "cli",
+    "terminal",
+    "knowledge-base",
+    "zettelkasten",
+    "note-taking",
+    "graph"
+  ],
+  "author": "Wasili",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wasuli/wasibase.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wasuli/wasibase/issues"
+  },
+  "homepage": "https://wasuli.github.io/wasibase",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "express": "^5.2.1",
+    "inquirer": "^9.3.8",
+    "marked": "^17.0.1",
+    "open": "^11.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,11 @@
+import path from 'path';
+import os from 'os';
+
+export const CONFIG = {
+  baseDir: path.join(os.homedir(), '.wasibase'),
+  notesDir: path.join(os.homedir(), '.wasibase', 'notes'),
+  tempDir: path.join(os.homedir(), '.wasibase', 'temp'),
+  configFile: path.join(os.homedir(), '.wasibase', 'config.json'),
+  backupDir: path.join(os.homedir(), '.wasibase', 'backups'),
+  editor: process.env.EDITOR || 'vim'
+};

package/src/index.js

@@ -0,0 +1,54 @@
+import { mainMenu } from './ui/manage.js';
+import { noteMenu } from './ui/note.js';
+import { searchMenu } from './ui/search.js';
+import { graphMenu } from './ui/graph.js';
+import { backupMenu } from './ui/backup.js';
+import { syncMenu } from './ui/sync.js';
+import chalk from 'chalk';
+
+export async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case 'note':
+    case 'n':
+      await noteMenu();
+      break;
+    case 'search':
+    case 's':
+      await searchMenu();
+      break;
+    case 'graph':
+    case 'g':
+      await graphMenu();
+      break;
+    case 'backup':
+    case 'b':
+      await backupMenu();
+      break;
+    case 'sync':
+      await syncMenu();
+      break;
+    case 'help':
+    case 'h':
+      showHelp();
+      break;
+    default:
+      await mainMenu();
+      break;
+  }
+}
+
+function showHelp() {
+  console.clear();
+  console.log(chalk.cyan.bold('\n  WASIBASE\n'));
+  console.log(chalk.bold('  Befehle:\n'));
+  console.log(chalk.gray('  wasibase          ') + chalk.bold('Verwaltung (Kategorien)'));
+  console.log(chalk.gray('  wasibase note     ') + chalk.bold('Note erstellen/bearbeiten'));
+  console.log(chalk.gray('  wasibase search   ') + chalk.bold('Notes durchsuchen'));
+  console.log(chalk.gray('  wasibase graph    ') + chalk.bold('Verknuepfungen visualisieren'));
+  console.log(chalk.gray('  wasibase backup   ') + chalk.bold('Backup erstellen/wiederherstellen'));
+  console.log(chalk.gray('  wasibase sync     ') + chalk.bold('Mit Cloud synchronisieren'));
+  console.log(chalk.gray('  wasibase help     ') + chalk.bold('Diese Hilfe\n'));
+}

package/src/storage.js

@@ -0,0 +1,262 @@
+/**
+ * Storage Module - File system operations for Wasibase
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { CONFIG } from './config.js';
+
+// =============================================================================
+// Directory Operations
+// =============================================================================
+
+export function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// =============================================================================
+// Category Operations
+// =============================================================================
+
+export function getOberkategorien() {
+  ensureDir(CONFIG.notesDir);
+  return fs.readdirSync(CONFIG.notesDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name)
+    .sort();
+}
+
+export function getUnterkategorien(oberkategorie) {
+  const dir = path.join(CONFIG.notesDir, oberkategorie);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name)
+    .sort();
+}
+
+export function createOberkategorie(name) {
+  const dir = path.join(CONFIG.notesDir, name);
+  ensureDir(dir);
+  return dir;
+}
+
+export function createUnterkategorie(oberkategorie, name) {
+  const dir = path.join(CONFIG.notesDir, oberkategorie, name);
+  ensureDir(dir);
+  return dir;
+}
+
+export function deleteOberkategorie(name) {
+  const dir = path.join(CONFIG.notesDir, name);
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+export function deleteUnterkategorie(oberkategorie, name) {
+  const dir = path.join(CONFIG.notesDir, oberkategorie, name);
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true });
+  }
+}
+
+// =============================================================================
+// Note Operations
+// =============================================================================
+
+export function getNotes(oberkategorie, unterkategorie) {
+  const dir = path.join(CONFIG.notesDir, oberkategorie, unterkategorie);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith('.md'))
+    .map(f => f.replace('.md', ''))
+    .sort();
+}
+
+export function getNotePath(oberkategorie, unterkategorie, thema) {
+  return path.join(CONFIG.notesDir, oberkategorie, unterkategorie, `${thema}.md`);
+}
+
+export function noteExists(oberkategorie, unterkategorie, thema) {
+  return fs.existsSync(getNotePath(oberkategorie, unterkategorie, thema));
+}
+
+export function readNote(oberkategorie, unterkategorie, thema) {
+  const filePath = getNotePath(oberkategorie, unterkategorie, thema);
+  if (!fs.existsSync(filePath)) return null;
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+export function saveNote(oberkategorie, unterkategorie, thema, content) {
+  const dir = path.join(CONFIG.notesDir, oberkategorie, unterkategorie);
+  ensureDir(dir);
+  const filePath = path.join(dir, `${thema}.md`);
+  fs.writeFileSync(filePath, content);
+  return filePath;
+}
+
+export function deleteNote(oberkategorie, unterkategorie, thema) {
+  const filePath = getNotePath(oberkategorie, unterkategorie, thema);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+/**
+ * Get all notes across all categories
+ */
+export function getAllNotes() {
+  const allNotes = [];
+
+  for (const ober of getOberkategorien()) {
+    for (const unter of getUnterkategorien(ober)) {
+      for (const thema of getNotes(ober, unter)) {
+        allNotes.push({ oberkategorie: ober, unterkategorie: unter, thema });
+      }
+    }
+  }
+
+  return allNotes;
+}
+
+/**
+ * Get statistics about the notes collection
+ */
+export function getStats() {
+  const oberkategorien = getOberkategorien();
+  let unterCount = 0;
+  let noteCount = 0;
+
+  for (const ober of oberkategorien) {
+    const unters = getUnterkategorien(ober);
+    unterCount += unters.length;
+    for (const unter of unters) {
+      noteCount += getNotes(ober, unter).length;
+    }
+  }
+
+  return {
+    oberkategorien: oberkategorien.length,
+    unterkategorien: unterCount,
+    notes: noteCount
+  };
+}
+
+// =============================================================================
+// Search
+// =============================================================================
+
+export function searchNotes(query) {
+  const results = [];
+  const queryLower = query.toLowerCase();
+
+  for (const { oberkategorie, unterkategorie, thema } of getAllNotes()) {
+    const content = readNote(oberkategorie, unterkategorie, thema);
+    if (!content) continue;
+
+    const contentLower = content.toLowerCase();
+    const themaLower = thema.toLowerCase();
+
+    if (themaLower.includes(queryLower) || contentLower.includes(queryLower)) {
+      let preview = '';
+      const idx = contentLower.indexOf(queryLower);
+
+      if (idx !== -1) {
+        const start = Math.max(0, idx - 50);
+        const end = Math.min(content.length, idx + query.length + 50);
+        preview = (start > 0 ? '...' : '') +
+          content.substring(start, idx) +
+          '<mark>' + content.substring(idx, idx + query.length) + '</mark>' +
+          content.substring(idx + query.length, end) +
+          (end < content.length ? '...' : '');
+      } else {
+        preview = content.substring(0, 100) + (content.length > 100 ? '...' : '');
+      }
+
+      results.push({
+        oberkategorie,
+        unterkategorie,
+        thema,
+        preview: preview.replace(/\n/g, ' ')
+      });
+    }
+  }
+
+  return results;
+}
+
+// =============================================================================
+// Backup & Restore
+// =============================================================================
+
+export function createBackup() {
+  return {
+    version: 1,
+    created: new Date().toISOString(),
+    notes: getAllNotes().map(note => ({
+      ...note,
+      content: readNote(note.oberkategorie, note.unterkategorie, note.thema) || ''
+    }))
+  };
+}
+
+export function saveBackupToFile(filePath) {
+  const backup = createBackup();
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(backup, null, 2));
+  return backup.notes.length;
+}
+
+export function loadBackupFromFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function restoreFromBackup(backupData) {
+  let restored = 0;
+  for (const note of backupData.notes) {
+    saveNote(note.oberkategorie, note.unterkategorie, note.thema, note.content);
+    restored++;
+  }
+  return restored;
+}
+
+// =============================================================================
+// Configuration
+// =============================================================================
+
+export function loadConfig() {
+  if (!fs.existsSync(CONFIG.configFile)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG.configFile, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function saveConfig(config) {
+  ensureDir(CONFIG.baseDir);
+  fs.writeFileSync(CONFIG.configFile, JSON.stringify(config, null, 2));
+}
+
+export function getSyncPath() {
+  return loadConfig().syncPath || null;
+}
+
+export function setSyncPath(syncPath) {
+  const config = loadConfig();
+  config.syncPath = syncPath;
+  saveConfig(config);
+}
+
+export function syncToPath(syncPath) {
+  const backupFile = path.join(syncPath, 'wasibase-backup.json');
+  return saveBackupToFile(backupFile);
+}

package/src/ui/backup.js

@@ -0,0 +1,248 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+import * as storage from '../storage.js';
+import { CONFIG } from '../config.js';
+
+function clear() {
+  console.clear();
+  console.log('');
+  console.log(chalk.bgGreen.white.bold('  WASIBASE BACKUP  '));
+  console.log('');
+}
+
+function formatSize(bytes) {
+  if (bytes < 1024) return bytes + ' B';
+  if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+  return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+}
+
+export async function backupMenu() {
+  clear();
+
+  const oberkategorien = storage.getOberkategorien();
+  let totalNotes = 0;
+
+  for (const ober of oberkategorien) {
+    const unters = storage.getUnterkategorien(ober);
+    for (const unter of unters) {
+      totalNotes += storage.getNotes(ober, unter).length;
+    }
+  }
+
+  console.log(chalk.gray(`  ${totalNotes} Notes in ${oberkategorien.length} Kategorien\n`));
+
+  const { action } = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message: chalk.blue('Aktion'),
+    prefix: chalk.blue('◆'),
+    choices: [
+      { name: chalk.green('  ↓ ') + chalk.bold('Backup erstellen'), value: 'create' },
+      { name: chalk.yellow('  ↑ ') + chalk.bold('Backup wiederherstellen'), value: 'restore' },
+      { name: chalk.gray('  < Zurueck'), value: 'exit' }
+    ]
+  }]);
+
+  if (action === 'exit') return;
+
+  if (action === 'create') {
+    return createBackup();
+  }
+
+  if (action === 'restore') {
+    return restoreBackup();
+  }
+}
+
+async function createBackup() {
+  clear();
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const defaultName = `wasibase-backup-${timestamp}.json`;
+  const defaultPath = path.join(CONFIG.backupDir, defaultName);
+
+  console.log(chalk.gray('  Standard Speicherort:'));
+  console.log(chalk.cyan(`  ${CONFIG.backupDir}\n`));
+
+  const { location } = await inquirer.prompt([{
+    type: 'list',
+    name: 'location',
+    message: chalk.blue('Wo speichern?'),
+    prefix: chalk.blue('◆'),
+    choices: [
+      { name: chalk.cyan('  → ') + chalk.bold('Standard (~/.wasibase/backups/)'), value: 'default' },
+      { name: chalk.cyan('  → ') + chalk.bold('Eigener Pfad angeben'), value: 'custom' },
+      { name: chalk.gray('  < Zurueck'), value: 'back' }
+    ]
+  }]);
+
+  if (location === 'back') return backupMenu();
+
+  let filePath = defaultPath;
+
+  if (location === 'custom') {
+    const { customPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'customPath',
+      message: chalk.green('Pfad (mit Dateiname):'),
+      prefix: chalk.green('+'),
+      default: path.join(process.env.HOME, 'Downloads', defaultName)
+    }]);
+
+    if (!customPath.trim()) return backupMenu();
+    filePath = customPath.trim();
+
+    if (!filePath.endsWith('.json')) {
+      filePath = path.join(filePath, defaultName);
+    }
+  }
+
+  console.log('');
+  console.log(chalk.gray('  Erstelle Backup...'));
+
+  try {
+    const noteCount = storage.saveBackupToFile(filePath);
+    const stats = fs.statSync(filePath);
+
+    console.log('');
+    console.log(chalk.green.bold('  ✓ Backup erstellt!'));
+    console.log('');
+    console.log(chalk.gray('  Datei: ') + chalk.bold(filePath));
+    console.log(chalk.gray('  Notes: ') + chalk.bold(noteCount));
+    console.log(chalk.gray('  Groesse: ') + chalk.bold(formatSize(stats.size)));
+    console.log('');
+  } catch (err) {
+    console.log(chalk.red(`\n  ✕ Fehler: ${err.message}\n`));
+  }
+
+  await inquirer.prompt([{
+    type: 'input',
+    name: 'continue',
+    message: chalk.gray('Enter zum Fortfahren...'),
+    prefix: ''
+  }]);
+
+  return backupMenu();
+}
+
+async function restoreBackup() {
+  clear();
+
+  storage.ensureDir(CONFIG.backupDir);
+  const backupFiles = fs.existsSync(CONFIG.backupDir)
+    ? fs.readdirSync(CONFIG.backupDir).filter(f => f.endsWith('.json')).sort().reverse()
+    : [];
+
+  if (backupFiles.length === 0) {
+    console.log(chalk.yellow('  Keine Backups gefunden.\n'));
+    console.log(chalk.gray('  Du kannst einen eigenen Pfad angeben.\n'));
+  } else {
+    console.log(chalk.gray(`  ${backupFiles.length} Backup(s) gefunden\n`));
+  }
+
+  const choices = [
+    ...backupFiles.slice(0, 10).map(f => {
+      const filePath = path.join(CONFIG.backupDir, f);
+      const stats = fs.statSync(filePath);
+      return {
+        name: chalk.cyan('  → ') + chalk.bold(f) + chalk.gray(` (${formatSize(stats.size)})`),
+        value: filePath,
+        short: f
+      };
+    }),
+    { name: chalk.yellow('  ? ') + chalk.yellow('Eigenen Pfad angeben'), value: 'custom' },
+    { name: chalk.gray('  < Zurueck'), value: 'back' }
+  ];
+
+  if (backupFiles.length > 0) {
+    choices.splice(backupFiles.slice(0, 10).length, 0, new inquirer.Separator(chalk.gray('─'.repeat(40))));
+  }
+
+  const { selection } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selection',
+    message: chalk.blue('Backup auswaehlen'),
+    prefix: chalk.blue('◆'),
+    choices,
+    pageSize: 15
+  }]);
+
+  if (selection === 'back') return backupMenu();
+
+  let filePath = selection;
+
+  if (selection === 'custom') {
+    const { customPath } = await inquirer.prompt([{
+      type: 'input',
+      name: 'customPath',
+      message: chalk.green('Pfad zur Backup-Datei:'),
+      prefix: chalk.green('?')
+    }]);
+
+    if (!customPath.trim()) return restoreBackup();
+    filePath = customPath.trim();
+  }
+
+  if (!fs.existsSync(filePath)) {
+    console.log(chalk.red(`\n  ✕ Datei nicht gefunden: ${filePath}\n`));
+    await inquirer.prompt([{
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Enter zum Fortfahren...'),
+      prefix: ''
+    }]);
+    return restoreBackup();
+  }
+
+  try {
+    const backup = storage.loadBackupFromFile(filePath);
+
+    if (!backup || !backup.notes) {
+      console.log(chalk.red('\n  ✕ Ungueltige Backup-Datei\n'));
+      await inquirer.prompt([{
+        type: 'input',
+        name: 'continue',
+        message: chalk.gray('Enter zum Fortfahren...'),
+        prefix: ''
+      }]);
+      return restoreBackup();
+    }
+
+    console.log('');
+    console.log(chalk.yellow('  Backup-Info:'));
+    console.log(chalk.gray('  Erstellt: ') + chalk.bold(backup.created || 'Unbekannt'));
+    console.log(chalk.gray('  Notes: ') + chalk.bold(backup.notes.length));
+    console.log('');
+
+    const { confirm } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'confirm',
+      message: chalk.yellow('Wiederherstellen? (Ueberschreibt bestehende Notes)'),
+      default: false
+    }]);
+
+    if (!confirm) return backupMenu();
+
+    console.log('');
+    console.log(chalk.gray('  Stelle wieder her...'));
+
+    const restored = storage.restoreFromBackup(backup);
+
+    console.log('');
+    console.log(chalk.green.bold('  ✓ Wiederhergestellt!'));
+    console.log(chalk.gray(`  ${restored} Notes wurden importiert.\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  ✕ Fehler: ${err.message}\n`));
+  }
+
+  await inquirer.prompt([{
+    type: 'input',
+    name: 'continue',
+    message: chalk.gray('Enter zum Fortfahren...'),
+    prefix: ''
+  }]);
+
+  return backupMenu();
+}