@hanzo/persona 1.0.0

package/scripts/add-personality.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Helper to ask questions
+const question = (q) => new Promise(resolve => rl.question(q, resolve));
+
+// Categories and their directories
+const CATEGORIES = {
+  programmer: 'programmers',
+  philosopher: 'philosophers',
+  scientist: 'scientists',
+  religious: 'religious',
+  revolutionary: 'revolutionaries',
+  writer: 'writers',
+  artist: 'artists',
+  architect: 'architects',
+  athlete: 'athletes',
+  explorer: 'explorers',
+  activist: 'activists',
+  tech_leader: 'leaders',
+  leader: 'leaders',
+  pioneer: 'pioneers',
+  special: 'special'
+};
+
+// Generate ID from name
+function generateId(name) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '_')
+    .replace(/-+/g, '_')
+    .substring(0, 50);
+}
+
+// Main function
+async function addPersonality() {
+  console.log('\n=== Add New Personality ===\n');
+
+  try {
+    // Basic info
+    const name = await question('Name (display name): ');
+    const fullName = await question('Full name (optional, press Enter to skip): ');
+    const id = await question(`ID (press Enter for "${generateId(name)}"): `) || generateId(name);
+
+    // Category
+    console.log('\nCategories:', Object.keys(CATEGORIES).join(', '));
+    const category = await question('Category: ');
+
+    if (!CATEGORIES[category]) {
+      console.error(`Invalid category: ${category}`);
+      process.exit(1);
+    }
+
+    // Tags
+    const tagsInput = await question('Tags (comma-separated, optional): ');
+    const tags = tagsInput ? tagsInput.split(',').map(t => t.trim()).filter(Boolean) : [];
+
+    // OCEAN scores
+    console.log('\n=== OCEAN Scores (0-100) ===');
+    const openness = parseInt(await question('Openness (creativity, curiosity): ')) || 50;
+    const conscientiousness = parseInt(await question('Conscientiousness (organization, discipline): ')) || 50;
+    const extraversion = parseInt(await question('Extraversion (sociability, energy): ')) || 50;
+    const agreeableness = parseInt(await question('Agreeableness (cooperation, trust): ')) || 50;
+    const neuroticism = parseInt(await question('Neuroticism (emotional instability): ')) || 50;
+
+    // Personality
+    console.log('\n=== Personality ===');
+    const summary = await question('Summary (brief description): ');
+    const philosophy = await question('Philosophy (core belief/motto): ');
+    const approach = await question('Approach (optional): ');
+    const communication = await question('Communication style (optional): ');
+
+    // Values
+    const valuesInput = await question('Core values (comma-separated, optional): ');
+    const values = valuesInput ? valuesInput.split(',').map(v => v.trim()).filter(Boolean) : undefined;
+
+    // Quotes
+    console.log('\n=== Quotes (optional, enter empty line to finish) ===');
+    const quotes = [];
+    let quoteNum = 1;
+    while (true) {
+      const quote = await question(`Quote ${quoteNum}: `);
+      if (!quote) break;
+      quotes.push(quote);
+      quoteNum++;
+    }
+
+    // For programmers, add technical info
+    let technical;
+    if (category === 'programmer' || category === 'tech_leader') {
+      console.log('\n=== Technical Info (optional) ===');
+      const languagesInput = await question('Programming languages (comma-separated): ');
+      const languages = languagesInput ? languagesInput.split(',').map(l => l.trim()).filter(Boolean) : undefined;
+
+      const domainsInput = await question('Domains (comma-separated): ');
+      const domains = domainsInput ? domainsInput.split(',').map(d => d.trim()).filter(Boolean) : undefined;
+
+      const essentialTools = await question('Essential tools (comma-separated): ');
+      const essential = essentialTools ? essentialTools.split(',').map(t => t.trim()).filter(Boolean) : undefined;
+
+      if (languages || domains || essential) {
+        technical = {};
+        if (languages) technical.languages = languages;
+        if (domains) technical.domains = domains;
+        if (essential) technical.tools = { essential };
+      }
+    }
+
+    // Build the personality object
+    const personality = {
+      "$schema": "../schemas/personality.schema.json",
+      id,
+      name,
+      category
+    };
+
+    if (fullName) personality.fullName = fullName;
+    if (tags.length > 0) personality.tags = tags;
+
+    personality.ocean = {
+      openness: Math.min(100, Math.max(0, openness)),
+      conscientiousness: Math.min(100, Math.max(0, conscientiousness)),
+      extraversion: Math.min(100, Math.max(0, extraversion)),
+      agreeableness: Math.min(100, Math.max(0, agreeableness)),
+      neuroticism: Math.min(100, Math.max(0, neuroticism))
+    };
+
+    personality.personality = {
+      summary: summary || `${category} personality`,
+      philosophy: philosophy || 'No philosophy recorded'
+    };
+
+    if (approach) personality.personality.approach = approach;
+    if (communication) personality.personality.communication = communication;
+    if (values) personality.personality.values = values;
+    if (technical) personality.technical = technical;
+    if (quotes.length > 0) personality.quotes = quotes;
+
+    // Determine target directory
+    const targetDir = CATEGORIES[category];
+    const baseDir = path.join(__dirname, '..', 'personalities_v2');
+    const dirPath = path.join(baseDir, targetDir);
+
+    // Ensure directory exists
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Check if file already exists
+    const filePath = path.join(dirPath, `${id}.json`);
+    if (fs.existsSync(filePath)) {
+      const overwrite = await question(`\nFile ${id}.json already exists. Overwrite? (y/N): `);
+      if (overwrite.toLowerCase() !== 'y') {
+        console.log('Cancelled.');
+        process.exit(0);
+      }
+    }
+
+    // Write the file
+    fs.writeFileSync(filePath, JSON.stringify(personality, null, 2));
+    console.log(`\n✅ Created: ${targetDir}/${id}.json`);
+
+    // Update manifest
+    const manifestPath = path.join(baseDir, 'index', 'manifest.json');
+    if (fs.existsSync(manifestPath)) {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+      // Update index
+      manifest.index[id] = {
+        path: `${targetDir}/${id}.json`,
+        name: name,
+        category: category,
+        tags: tags
+      };
+
+      // Update category
+      if (!manifest.categories[category]) {
+        manifest.categories[category] = {
+          count: 0,
+          path: targetDir,
+          ids: []
+        };
+      }
+
+      if (!manifest.categories[category].ids.includes(id)) {
+        manifest.categories[category].ids.push(id);
+        manifest.categories[category].count++;
+        manifest.total++;
+      }
+
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+      console.log('✅ Updated manifest.json');
+    }
+
+    // Suggest rebuilding
+    console.log('\nTo rebuild aggregated files, run: npm run build');
+
+  } catch (err) {
+    console.error('\nError:', err.message);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  addPersonality();
+}
+
+module.exports = { addPersonality };

package/scripts/build.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const PERSONAS_DIR = path.join(__dirname, '..', 'personalities_v2');
+const DIST_DIR = path.join(PERSONAS_DIR, 'dist');
+const INDEX_FILE = path.join(PERSONAS_DIR, 'index', 'manifest.json');
+
+// Category mappings (reverse of migrate.js)
+const CATEGORY_DIRS = {
+  programmers: ['programmer', 'systems', 'language-creator', 'gaming', 'blockchain'],
+  philosophers: ['philosopher'],
+  scientists: ['scientist', 'mathematician'],
+  religious: ['religious'],
+  revolutionaries: ['revolutionary'],
+  writers: ['writer', 'poet', 'historian'],
+  artists: ['artist', 'musician', 'filmmaker', 'comedian', 'composer'],
+  architects: ['architect'],
+  athletes: ['athlete'],
+  explorers: ['explorer'],
+  activists: ['activist'],
+  leaders: ['tech_leader', 'leader', 'statesman', 'media'],
+  pioneers: ['pioneer'],
+  special: ['special', 'master']
+};
+
+// Load all personalities from a directory
+function loadPersonalities(dirPath) {
+  const personalities = [];
+
+  if (!fs.existsSync(dirPath)) {
+    return personalities;
+  }
+
+  const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+
+  files.forEach(file => {
+    try {
+      const content = fs.readFileSync(path.join(dirPath, file), 'utf8');
+      const personality = JSON.parse(content);
+      // Remove the schema reference for the aggregated files
+      delete personality.$schema;
+      personalities.push(personality);
+    } catch (err) {
+      console.error(`Error loading ${file}: ${err.message}`);
+    }
+  });
+
+  return personalities;
+}
+
+// Build all personalities file
+function buildAllPersonalities() {
+  console.log('Building all personalities file...');
+
+  const allPersonalities = [];
+  const dirs = fs.readdirSync(PERSONAS_DIR)
+    .filter(d => !['dist', 'index', 'schemas', 'scripts'].includes(d))
+    .filter(d => fs.statSync(path.join(PERSONAS_DIR, d)).isDirectory());
+
+  dirs.forEach(dir => {
+    const personalities = loadPersonalities(path.join(PERSONAS_DIR, dir));
+    allPersonalities.push(...personalities);
+  });
+
+  // Sort by name
+  allPersonalities.sort((a, b) => a.name.localeCompare(b.name));
+
+  // Write the file
+  const outputPath = path.join(DIST_DIR, 'all.json');
+  fs.writeFileSync(outputPath, JSON.stringify({
+    version: '2.0.0',
+    generated: new Date().toISOString(),
+    total: allPersonalities.length,
+    personalities: allPersonalities
+  }, null, 2));
+
+  console.log(`  Created: dist/all.json (${allPersonalities.length} personalities)`);
+
+  return allPersonalities;
+}
+
+// Build category-specific files
+function buildCategoryFiles() {
+  console.log('\nBuilding category files...');
+
+  const categoryDir = path.join(DIST_DIR, 'by-category');
+  if (!fs.existsSync(categoryDir)) {
+    fs.mkdirSync(categoryDir, { recursive: true });
+  }
+
+  Object.entries(CATEGORY_DIRS).forEach(([dirName, categories]) => {
+    const dirPath = path.join(PERSONAS_DIR, dirName);
+    const personalities = loadPersonalities(dirPath);
+
+    if (personalities.length > 0) {
+      const outputPath = path.join(categoryDir, `${dirName}.json`);
+      fs.writeFileSync(outputPath, JSON.stringify({
+        version: '2.0.0',
+        generated: new Date().toISOString(),
+        category: dirName,
+        categories: categories,
+        total: personalities.length,
+        personalities: personalities
+      }, null, 2));
+
+      console.log(`  Created: dist/by-category/${dirName}.json (${personalities.length} personalities)`);
+    }
+  });
+}
+
+// Build tag-based collections
+function buildTagFiles(allPersonalities) {
+  console.log('\nBuilding tag files...');
+
+  const tagDir = path.join(DIST_DIR, 'by-tag');
+  if (!fs.existsSync(tagDir)) {
+    fs.mkdirSync(tagDir, { recursive: true });
+  }
+
+  // Collect all tags
+  const tagMap = new Map();
+
+  allPersonalities.forEach(p => {
+    if (p.tags && Array.isArray(p.tags)) {
+      p.tags.forEach(tag => {
+        if (!tagMap.has(tag)) {
+          tagMap.set(tag, []);
+        }
+        tagMap.get(tag).push(p);
+      });
+    }
+  });
+
+  // Write files for tags with 3+ personalities
+  let tagCount = 0;
+  tagMap.forEach((personalities, tag) => {
+    if (personalities.length >= 3) {
+      const sanitizedTag = tag.replace(/[^a-z0-9_-]/gi, '_');
+      const outputPath = path.join(tagDir, `${sanitizedTag}.json`);
+
+      fs.writeFileSync(outputPath, JSON.stringify({
+        version: '2.0.0',
+        generated: new Date().toISOString(),
+        tag: tag,
+        total: personalities.length,
+        personalities: personalities
+      }, null, 2));
+
+      tagCount++;
+    }
+  });
+
+  console.log(`  Created ${tagCount} tag files (tags with 3+ personalities)`);
+}
+
+// Generate TypeScript types
+function generateTypes(allPersonalities) {
+  console.log('\nGenerating TypeScript types...');
+
+  const types = `// Auto-generated TypeScript types for personalities
+// Generated: ${new Date().toISOString()}
+
+export interface OceanScores {
+  openness: number;
+  conscientiousness: number;
+  extraversion: number;
+  agreeableness: number;
+  neuroticism: number;
+}
+
+export interface PersonalityMetadata {
+  born?: string;
+  died?: string;
+  nationality?: string;
+  active?: boolean;
+  company?: string;
+  achievements?: string[];
+}
+
+export interface PersonalityInfo {
+  summary: string;
+  philosophy: string;
+  approach?: string;
+  communication?: string;
+  values?: string[];
+}
+
+export interface TechnicalInfo {
+  languages?: string[];
+  domains?: string[];
+  tools?: {
+    essential?: string[];
+    preferred?: string[];
+    created?: string[];
+  };
+}
+
+export interface BehavioralTraits {
+  codeStyle?: string;
+  reviewStyle?: string;
+  workStyle?: string;
+  collaboration?: string;
+}
+
+export interface Personality {
+  id: string;
+  name: string;
+  fullName?: string;
+  category: string;
+  subcategory?: string;
+  tags?: string[];
+  metadata?: PersonalityMetadata;
+  ocean: OceanScores;
+  personality: PersonalityInfo;
+  technical?: TechnicalInfo;
+  quotes?: string[];
+  behavioral?: BehavioralTraits;
+}
+
+export interface PersonalityCollection {
+  version: string;
+  generated: string;
+  total: number;
+  personalities: Personality[];
+  category?: string;
+  tag?: string;
+}
+
+// Personality ID union type
+export type PersonalityId = ${allPersonalities.map(p => `'${p.id}'`).join(' | ')};
+
+// Category union type
+export type PersonalityCategory = ${[...new Set(allPersonalities.map(p => `'${p.category}'`))].join(' | ')};
+`;
+
+  const outputPath = path.join(DIST_DIR, 'types.ts');
+  fs.writeFileSync(outputPath, types);
+  console.log('  Created: dist/types.ts');
+}
+
+// Generate index file for easy imports
+function generateIndex() {
+  console.log('\nGenerating index file...');
+
+  const indexContent = `// Auto-generated index for personality imports
+// Generated: ${new Date().toISOString()}
+
+// Individual personality imports
+${Object.entries(CATEGORY_DIRS).map(([dir, cats]) => {
+  const dirPath = path.join(PERSONAS_DIR, dir);
+  if (!fs.existsSync(dirPath)) return '';
+
+  const files = fs.readdirSync(dirPath).filter(f => f.endsWith('.json'));
+  return files.map(f => {
+    const id = f.replace('.json', '');
+    return `export { default as ${id} } from '../${dir}/${f}';`;
+  }).join('\n');
+}).filter(Boolean).join('\n')}
+
+// Category collections
+export { default as allPersonalities } from './all.json';
+${Object.keys(CATEGORY_DIRS).map(dir =>
+  `export { default as ${dir} } from './by-category/${dir}.json';`
+).join('\n')}
+
+// Type exports
+export * from './types';
+`;
+
+  const outputPath = path.join(DIST_DIR, 'index.js');
+  fs.writeFileSync(outputPath, indexContent);
+  console.log('  Created: dist/index.js');
+}
+
+// Update package.json exports
+function updatePackageJson() {
+  console.log('\nUpdating package.json exports...');
+
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  if (!fs.existsSync(packagePath)) {
+    console.log('  No package.json found, skipping...');
+    return;
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+
+    // Add exports field for modern module resolution
+    pkg.exports = {
+      '.': './personalities_v2/dist/index.js',
+      './all': './personalities_v2/dist/all.json',
+      './types': './personalities_v2/dist/types.ts',
+      './by-category/*': './personalities_v2/dist/by-category/*.json',
+      './by-tag/*': './personalities_v2/dist/by-tag/*.json',
+      './personalities/*': './personalities_v2/*/*.json'
+    };
+
+    // Add files field to include in npm package
+    pkg.files = [
+      'personalities_v2/**/*.json',
+      'personalities_v2/dist/**/*',
+      'personalities_v2/schemas/*.json',
+      '!personalities_v2/scripts'
+    ];
+
+    fs.writeFileSync(packagePath, JSON.stringify(pkg, null, 2));
+    console.log('  Updated package.json with exports field');
+  } catch (err) {
+    console.error(`  Error updating package.json: ${err.message}`);
+  }
+}
+
+// Main build function
+async function build() {
+  console.log('Starting build process...\n');
+
+  // Ensure dist directories exist
+  if (!fs.existsSync(DIST_DIR)) {
+    fs.mkdirSync(DIST_DIR, { recursive: true });
+  }
+
+  // Build all files
+  const allPersonalities = buildAllPersonalities();
+  buildCategoryFiles();
+  buildTagFiles(allPersonalities);
+  generateTypes(allPersonalities);
+  generateIndex();
+  updatePackageJson();
+
+  console.log('\nBuild complete!');
+  console.log(`Total personalities: ${allPersonalities.length}`);
+}
+
+// Run build
+if (require.main === module) {
+  build().catch(err => {
+    console.error('Build failed:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = { build };