@hamak/smart-data-dico 1.0.0

package/bin/cli.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { existsSync, mkdirSync, cpSync } from 'fs';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PKG_ROOT = join(__dirname, '..');
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const flags = {};
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--port' && args[i + 1]) { flags.port = args[++i]; }
+  else if (args[i] === '--data-dir' && args[i + 1]) { flags.dataDir = args[++i]; }
+  else if (args[i] === '--no-open') { flags.noOpen = true; }
+  else if (args[i] === '--help' || args[i] === '-h') { flags.help = true; }
+}
+
+if (flags.help) {
+  console.log(`
+  smart-data-dico - Collaborative Data Dictionary Management
+
+  Usage:
+    smart-data-dico [options]
+    npx smart-data-dico [options]
+
+  Options:
+    --port <number>     Server port (default: 3001)
+    --data-dir <path>   Data directory path (default: ./data-dictionaries)
+    --no-open           Don't open browser automatically
+    -h, --help          Show this help
+
+  Examples:
+    smart-data-dico
+    smart-data-dico --port 4000
+    smart-data-dico --data-dir ~/my-dictionaries
+  `);
+  process.exit(0);
+}
+
+const port = flags.port || process.env.PORT || '3001';
+const dataDir = resolve(flags.dataDir || process.env.DATA_DIR || './data-dictionaries');
+
+// Ensure data directory exists
+if (!existsSync(dataDir)) {
+  mkdirSync(dataDir, { recursive: true });
+  console.log(`Created data directory: ${dataDir}`);
+
+  const defaultStereotypes = join(PKG_ROOT, 'data-dictionaries', 'stereotypes.yaml');
+  if (existsSync(defaultStereotypes)) {
+    cpSync(defaultStereotypes, join(dataDir, 'stereotypes.yaml'));
+    console.log('Copied default stereotypes');
+  }
+
+  mkdirSync(join(dataDir, 'microservices'), { recursive: true });
+  mkdirSync(join(dataDir, 'perspectives'), { recursive: true });
+}
+
+const serverTs = join(PKG_ROOT, 'backend', 'src', 'server.ts');
+const frontendDist = join(PKG_ROOT, 'frontend', 'dist');
+
+if (!existsSync(serverTs)) {
+  console.error('Error: Backend source not found.');
+  process.exit(1);
+}
+
+console.log(`
+  Smart Data Dictionary
+
+  Port:       ${port}
+  Data:       ${dataDir}
+  Profile:    ${process.env.PROFILE || 'local'}
+  Frontend:   ${existsSync(frontendDist) ? 'bundled' : 'dev (use frontend dev server on :3000)'}
+`);
+
+// Find tsx binary — check local node_modules first, then global
+const tsxPaths = [
+  join(PKG_ROOT, 'node_modules', '.bin', 'tsx'),
+  join(PKG_ROOT, 'backend', 'node_modules', '.bin', 'tsx'),
+];
+let tsxBin = tsxPaths.find(p => existsSync(p)) || 'npx';
+const tsxArgs = tsxBin === 'npx' ? ['tsx', serverTs] : [serverTs];
+
+const child = spawn(tsxBin, tsxArgs, {
+  cwd: join(PKG_ROOT, 'backend'),
+  env: {
+    ...process.env,
+    PORT: port,
+    NODE_ENV: existsSync(frontendDist) ? 'production' : 'development',
+    PROFILE: process.env.PROFILE || 'local',
+    DATA_DIR: dataDir,
+  },
+  stdio: 'inherit',
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start server:', err.message);
+  process.exit(1);
+});
+
+child.on('exit', (code) => process.exit(code || 0));
+
+// Open browser after short delay
+if (!flags.noOpen) {
+  setTimeout(async () => {
+    const url = `http://localhost:${port}`;
+    console.log(`Opening ${url} ...`);
+    try {
+      const { exec } = await import('child_process');
+      const cmd = process.platform === 'darwin' ? 'open' :
+                  process.platform === 'win32' ? 'start' : 'xdg-open';
+      exec(`${cmd} ${url}`);
+    } catch {
+      console.log(`Open ${url} in your browser`);
+    }
+  }, 3000);
+}
+
+process.on('SIGINT', () => {
+  console.log('\nShutting down...');
+  child.kill('SIGINT');
+});
+
+process.on('SIGTERM', () => {
+  child.kill('SIGTERM');
+});

package/data-dictionaries/stereotypes.yaml

@@ -0,0 +1,91 @@
+- id: aggregate-root
+  name: Aggregate Root
+  appliesTo: entity
+  description: Root entity of an aggregate boundary
+  metadataDefinitions:
+    - name: bounded-context
+      type: string
+      required: true
+      description: Name of the bounded context this aggregate belongs to
+    - name: invariants
+      type: rule
+      description: Business invariants enforced by this aggregate
+
+- id: reference-data
+  name: Reference Data
+  appliesTo: entity
+  description: Slowly-changing lookup/reference data
+  metadataDefinitions:
+    - name: cacheable
+      type: flag
+      required: true
+      description: Whether this data can be cached
+    - name: update-frequency
+      type: string
+      description: How often this data changes (daily, weekly, rarely)
+
+- id: event
+  name: Domain Event
+  appliesTo: entity
+  description: An event that represents something that happened in the domain
+  metadataDefinitions:
+    - name: event-source
+      type: string
+      required: true
+      description: The aggregate or service that emits this event
+    - name: idempotent
+      type: flag
+      description: Whether processing this event is idempotent
+
+- id: value-object
+  name: Value Object
+  appliesTo: entity
+  description: An immutable object defined by its attributes rather than identity
+  metadataDefinitions:
+    - name: immutable
+      type: flag
+      required: true
+
+- id: pii
+  name: PII
+  appliesTo: attribute
+  description: Personally Identifiable Information
+  metadataDefinitions:
+    - name: pii-category
+      type: string
+      required: true
+      description: "Category: direct, indirect, or sensitive"
+    - name: retention-days
+      type: number
+      description: Data retention period in days
+    - name: encryption-required
+      type: flag
+      description: Whether this field must be encrypted at rest
+
+- id: indexed
+  name: Indexed
+  appliesTo: attribute
+  description: Database-indexed attribute
+  metadataDefinitions:
+    - name: index-type
+      type: string
+      description: "Index type: btree, hash, gin, gist"
+    - name: unique-index
+      type: flag
+      description: Whether the index enforces uniqueness
+
+- id: deprecated
+  name: Deprecated
+  appliesTo: attribute
+  description: Attribute scheduled for removal
+  metadataDefinitions:
+    - name: deprecated-since
+      type: date
+      required: true
+      description: Date when this attribute was deprecated
+    - name: replacement
+      type: string
+      description: Name of the replacement attribute
+    - name: removal-target
+      type: date
+      description: Target date for removal

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@hamak/smart-data-dico",
+  "version": "1.0.0",
+  "description": "Collaborative data dictionary management system — model, document, and govern your data landscape",
+  "type": "module",
+  "bin": {
+    "smart-data-dico": "bin/cli.js"
+  },
+  "scripts": {
+    "build": "cd frontend && npm run build",
+    "start": "node bin/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "bin/",
+    "backend/src/",
+    "backend/package.json",
+    "backend/tsconfig.json",
+    "frontend/dist/",
+    "data-dictionaries/stereotypes.yaml"
+  ],
+  "dependencies": {
+    "tsx": "^4.0.0"
+  },
+  "keywords": [
+    "data-dictionary",
+    "data-modeling",
+    "data-governance",
+    "schema-management",
+    "yaml",
+    "git"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/smart-data-dico.git"
+  }
+}