:::reader
- [[lost-in-public/market-maps/The Future of CPG|The Future of CPG]]
- [[essays/Partnering with Startups when they Scale Up|Partnering with Startups when they Scale Up]]
:::

:::features
- Reader
- Projects
- Portfolio
- Recommendations
:::

:::portfolio
- [[Featured Project A]]
- [[Featured Project B]]
:::

:::vocabulary
- [[Technical Term 1]]
- [[Technical Term 2]]
:::

:::concepts
- [[Core Concept A]]
- [[Core Concept B]]
:::

---
title: Entity Name
date: YYYY-MM-DD
category: MOC
---

# Entity Name

## Content Capacity

:::features
- Reader
- Projects
- Portfolio
- Recommendations
:::

:::portfolio
- [[Aalo Atomics]]
- [[Pencil Spaces]]
:::

:::vocabulary
- [[Agile]]
- [[AI Models]]
:::

:::concepts
- [[Coherence]]
- [[AI Avatars]]
:::

:::toolingGallery
- [[Flowise]]
- [[Wordware]]
- tag:AI Models
:::

---
import fs from 'node:fs/promises';
import path from 'node:path';
import { contentBasePath } from '@utils/envUtils';
import { extractBacklinkDisplayTexts } from '@utils/backlink-parser';
import { resolvePortfolioId, loadToolsFromMocToolingGallery } from '@utils/toolUtils';
import { toProperCase, slugify } from '@utils/slugify';

const { client } = Astro.props;

// Load MOC file for the entity
const clientMdPath = path.resolve(contentBasePath, 'moc', `${toProperCase(client)}.md`);
const rawClientMd = await fs.readFile(clientMdPath, 'utf-8');

// Extract features directive for filtering
const featuresBlockMatch = rawClientMd.match(/:::features([\s\S]*?):::/i);
let clientPortalCards = []; // Your existing cards collection

if (featuresBlockMatch) {
  const block = featuresBlockMatch[1] || '';
  const featureLines = block
    .split('\n')
    .map((line) => line.trim())
    .filter((line) => line.startsWith('-') || line.startsWith('*'));

  const requestedFeatures = featureLines
    .map((line) => line.replace(/^[-*]\s*/, '').trim())
    .filter(Boolean);

  // Normalize and alias common variants/typos
  const aliasMap = new Map<string, string>([
    ['recs', 'recommendations'],
    ['recommendation', 'recommendations'],
    ['recommendations', 'recommendations'],
    ['reccomendations', 'recommendations'], // common misspelling
    ['projects', 'projects'],
    ['portfolio', 'portfolio'],
    ['reader', 'reader'],
  ]);

  const normalizeFeature = (name: string): string => {
    const slug = slugify(name).toLowerCase();
    return aliasMap.get(slug) || slug;
  };

  const allowed = new Set(requestedFeatures.map((f) => normalizeFeature(f)));
  clientPortalCards = clientPortalCards.filter((card: any) => 
    allowed.has(normalizeFeature(card.title))
  );
}

// Extract portfolio directive
let featuredPortfolios: any[] = [];
const portfolioBlockMatch = rawClientMd.match(/:::portfolio([\s\S]*?):::/i);
if (portfolioBlockMatch) {
  const block = portfolioBlockMatch[1] || '';
  const lines = block
    .split('\n')
    .map((l) => l.trim())
    .filter((l) => l.startsWith('-') || l.startsWith('*'));

  const requested = lines
    .map((line) => {
      // Extract [[Name]] allowing for missing closing brackets
      const m = line.match(/^[-*]\s*\[\[(.*?)(?:\]\])?\s*$/);
      if (m && m[1]) return m[1].trim();
      return line.replace(/^[-*]\s*/, '').trim();
    })
    .filter(Boolean);

  if (requested.length > 0) {
    const allPortfolios = await getCollection('client-portfolios');
    
    // Resolve each requested name to a portfolio entry
    for (const name of requested) {
      const resolvedId = await resolvePortfolioId(name, allPortfolios);
      if (!resolvedId) continue;
      const entry = allPortfolios.find((e) => e.id === resolvedId);
      if (!entry) continue;

      featuredPortfolios.push({
        ...entry.data,
        id: getReferenceSlug(entry.id.split('/').pop()?.replace(/\.md$/, '') || ''),
        filename: entry.id.split('/').pop()?.replace(/\.md$/, '') || '',
        filePath: entry.id,
      });
    }
  }
}

// Extract reference terms using backlink parser
const extractList = (blockName: string): string[] => {
  const m = rawClientMd.match(new RegExp(`:::${blockName}([\\s\\S]*?):::`,'i'));
  if (!m) return [];
  const blockContent = m[1] || '';
  
  // Use backlink parser to extract display texts for matching
  return extractBacklinkDisplayTexts(blockContent);
};

const selectedVocabulary = extractList('vocabulary');
const selectedConcepts = extractList('concepts');

// Load tools from toolingGallery directive
const allTools = await getCollection('tooling');
const mocToolingGalleryTools = await loadToolsFromMocToolingGallery(rawClientMd, allTools);
---

<!-- Render filtered content -->
<FeatureGrid features={clientPortalCards} />
<PortfolioGrid items={featuredPortfolios} />
<ClientReferenceSection 
  selectedVocabulary={selectedVocabulary} 
  selectedConcepts={selectedConcepts} 
/>
{mocToolingGalleryTools.length > 0 && (
  <ToolingGallery tools={mocToolingGalleryTools} />
)}

// utils/backlink-parser.ts
export function extractBacklinkDisplayTexts(content: string): string[] {
  const lines = content.split(/\r?\n/);
  const displayTexts: string[] = [];
  
  for (const line of lines) {
    const trimmedLine = line.trim();
    
    // Skip empty lines and non-list items
    if (!trimmedLine || (!trimmedLine.startsWith('-') && !trimmedLine.startsWith('*'))) {
      continue;
    }
    
    // Look for backlinks in list items - capture both path and display text
    const backlinkMatch = trimmedLine.match(/^[-*]\s*\[\[((?!.*?visuals).*?)(?:\|(.*?))?\]\]/);
    if (backlinkMatch) {
      const path = backlinkMatch[1].trim();
      const displayText = backlinkMatch[2]?.trim();
      
      if (path) {
        // Use display text if provided, otherwise fall back to last segment of path
        const finalDisplayText = displayText || 
          path.split('/').pop()?.replace(/\.md$/, '').replace(/-/g, ' ') || '';
        displayTexts.push(finalDisplayText);
      }
    }
  }
  
  return displayTexts;
}

// utils/toolUtils.ts
export async function resolvePortfolioId(input: string, allPortfolios: any[]): Promise<string | null> {
  // 1. Try exact match
  const directMatch = allPortfolios.find(portfolio => portfolio.id === input);
  if (directMatch) return directMatch.id;

  // 2. Try normalized match
  const normalized = slugify(input);
  const normMatch = allPortfolios.find(portfolio => slugify(portfolio.id) === normalized);
  if (normMatch) return normMatch.id;

  // 3. Try case-insensitive filename match with space handling
  const filename = input.split('/').pop() || input;
  const filenameMatch = allPortfolios.find(portfolio => {
    const portfolioFilename = portfolio.id.split('/').pop()?.replace(/\.md$/, '') || '';
    
    // Compare both original and slugified versions
    const inputLower = filename.toLowerCase();
    const portfolioLower = portfolioFilename.toLowerCase();
    const inputSlugified = slugify(filename);
    const portfolioSlugified = slugify(portfolioFilename);
    
    return inputLower === portfolioLower || 
           inputSlugified === portfolioSlugified ||
           inputLower.replace(/[-_]/g, ' ') === portfolioLower ||
           portfolioLower.replace(/[-_]/g, ' ') === inputLower;
  });
  if (filenameMatch) return filenameMatch.id;

  // 4. Try matching by slugified filename across all portfolios
  const slugifiedInput = slugify(input);
  const slugMatch = allPortfolios.find(portfolio => {
    const portfolioFilename = portfolio.id.split('/').pop()?.replace(/\.md$/, '') || '';
    return slugify(portfolioFilename) === slugifiedInput;
  });
  if (slugMatch) return slugMatch.id;

  // 5. Try partial path matching for route-transformed inputs
  if (input.includes('/')) {
    const pathSegments = input.split('/');
    const lastSegment = pathSegments[pathSegments.length - 1];
    
    // Try to find by converting slugified back to spaced version
    const unslugified = lastSegment.replace(/-/g, ' ');
    const unslugifiedMatch = allPortfolios.find(portfolio => {
      const portfolioFilename = portfolio.id.split('/').pop()?.replace(/\.md$/, '') || '';
      return portfolioFilename.toLowerCase() === unslugified.toLowerCase();
    });
    if (unslugifiedMatch) return unslugifiedMatch.id;
  }

  return null;
}

---
// components/client-portals/ClientReferenceSection.astro
interface Props {
  selectedVocabulary: string[];
  selectedConcepts: string[];
}

const { selectedVocabulary, selectedConcepts } = Astro.props;

// Process entries using existing normalization utilities
const vocabularyCollection = await getCollection('vocabulary');
const conceptsCollection = await getCollection('concepts');

const processedVocab = vocabularyCollection
  .filter(entry => selectedVocabulary.includes(entry.data.title || entry.id));

const processedConcepts = conceptsCollection
  .filter(entry => selectedConcepts.includes(entry.data.title || entry.id));
---

<ReferenceGrid 
  vocabulary={processedVocab} 
  concepts={processedConcepts} 
/>

// utils/envUtils.js
import path from 'node:path';

export function getContentBasePath(): string {
  const deployEnv = process.env.DEPLOY_ENV || 'LocalSiteOnly';
  
  switch (deployEnv) {
    case 'LocalSiteOnly':
      return path.resolve(process.cwd(), '../content');
    case 'LocalMonorepo':
      return path.resolve(process.cwd(), '../content');
    case 'Vercel':
      return path.resolve(process.cwd(), 'content');
    case 'Railway':
      return path.resolve(process.cwd(), 'content');
    default:
      return path.resolve(process.cwd(), '../content');
  }
}

export const contentBasePath = getContentBasePath();
export const resolvedContentPath = path.resolve(contentBasePath);

// utils/backlink-parser.ts
export function extractBacklinkDisplayTexts(content: string): string[] {
  const lines = content.split(/\r?\n/);
  const displayTexts: string[] = [];
  
  for (const line of lines) {
    const trimmedLine = line.trim();
    
    // Skip empty lines and non-list items
    if (!trimmedLine || (!trimmedLine.startsWith('-') && !trimmedLine.startsWith('*'))) {
      continue;
    }
    
    // Look for backlinks in list items - capture both path and display text
    const backlinkMatch = trimmedLine.match(/^[-*]\s*\[\[((?!.*?visuals).*?)(?:\|(.*?))?\]\]/);
    if (backlinkMatch) {
      const path = backlinkMatch[1].trim();
      const displayText = backlinkMatch[2]?.trim();
      
      if (path) {
        // Use display text if provided, otherwise fall back to last segment of path
        const finalDisplayText = displayText || 
          path.split('/').pop()?.replace(/\.md$/, '').replace(/-/g, ' ') || '';
        displayTexts.push(finalDisplayText);
      }
    }
  }
  
  return displayTexts;
}

function extractDirectiveContent(content, directiveName) {
  const regex = new RegExp(`:::${directiveName}([\\s\\S]*?):::`, 'i');
  const match = content.match(regex);
  if (!match) return [];
  
  const block = match[1] || '';
  const lines = block
    .split('\n')
    .map(line => line.trim())
    .filter(line => line.startsWith('-') || line.startsWith('*'));

  return lines
    .map(line => line.replace(/^[-*]\s*/, '').trim())
    .filter(Boolean)
    .map(line => {
      // Handle backlink syntax [[Name]] or [[Path|Display]]
      const backlinkMatch = line.match(/^\[\[(.*?)(?:\|(.*?))?\]\]$/);
      if (backlinkMatch) {
        const path = backlinkMatch[1].trim();
        const displayText = backlinkMatch[2]?.trim();
        return displayText || path.split('/').pop()?.replace(/\.md$/, '') || path;
      }
      return line;
    });
}

function normalizeFeatureName(name) {
  const aliasMap = new Map([
    ['recs', 'recommendations'],
    ['recommendation', 'recommendations'],
    ['recommendations', 'recommendations'],
    ['reccomendations', 'recommendations'], // common misspelling
    ['porfolio', 'portfolio'], // common misspelling
    ['projects', 'projects'],
    ['portfolio', 'portfolio'],
    ['reader', 'reader'],
  ]);
  
  const slug = slugify(name).toLowerCase();
  return aliasMap.get(slug) || slug;
}

// utils/toolUtils.ts
export function parseMocContent(content: string): { rawToolIds: string[], tagFilters: string[] } {
  const rawToolIds: string[] = [];
  const tagFilters: string[] = [];
  
  const lines = content.split(/\r?\n/);
  
  for (const line of lines) {
    const trimmedLine = line.trim();
    
    if (!trimmedLine || (!trimmedLine.startsWith('-') && !trimmedLine.startsWith('*'))) {
      continue;
    }
    
    const listItem = trimmedLine.replace(/^[-*]\s*/, '').trim();
    
    if (listItem.startsWith('tag:')) {
      // Extract tag filter
      const tag = listItem.substring(4).trim();
      if (tag) tagFilters.push(tag);
    } else {
      // Extract tool reference
      const backlinkMatch = listItem.match(/^\[\[(.*?)(?:\|(.*?))?\]\]$/);
      if (backlinkMatch) {
        const path = backlinkMatch[1].trim();
        const displayText = backlinkMatch[2]?.trim();
        rawToolIds.push(displayText || path);
      } else {
        rawToolIds.push(listItem);
      }
    }
  }
  
  return { rawToolIds, tagFilters };
}

export async function loadToolsFromMocToolingGallery(content: string, allTools: any[]): Promise<any[]> {
  const toolingGalleryMatch = content.match(/:::toolingGallery([\s\S]*?):::/i);
  if (!toolingGalleryMatch) return [];
  
  const { rawToolIds, tagFilters } = parseMocContent(toolingGalleryMatch[1]);
  const resolvedTools: any[] = [];
  
  // Resolve tool IDs
  for (const toolId of rawToolIds) {
    const resolvedId = await resolveToolId(toolId, allTools);
    if (resolvedId) {
      const tool = allTools.find(t => t.id === resolvedId);
      if (tool) resolvedTools.push(tool);
    }
  }
  
  // Apply tag filters
  if (tagFilters.length > 0) {
    const tagFilteredTools = allTools.filter(tool => 
      tool.data.tags?.some((tag: string) => 
        tagFilters.some(filter => 
          tag.toLowerCase().includes(filter.toLowerCase())
        )
      )
    );
    resolvedTools.push(...tagFilteredTools);
  }
  
  // Remove duplicates
  const uniqueTools = resolvedTools.filter((tool, index, self) => 
    index === self.findIndex(t => t.id === tool.id)
  );
  
  return uniqueTools;
}

:::tools
- [[Tool A]]
- [[Tool B]]
:::

:::integrations
- [[Service X]]
- [[Platform Y]]
:::

:::features[production]
- Reader
- Projects
:::

:::features[development]
- Reader
- Projects
- Debug
:::

:::inherit
- [[Base MOC]]
:::

:::override
- portfolio
:::

<!-- content/moc/Laerdal.md -->
:::features
- Reader
- Projects
- Portfolio
- Recommendations
:::

:::portfolio
- [[Aalo Atomics]]
- [[Pencil Spaces]]
:::

:::vocabulary
- [[Agile]]
- [[AI Models]]
- [[Coherence]]
- [[AI Avatars]]
- [[Automation]]
- [[Biotech]]
- [[Conversational AI]]
- [[Data Science]]
- [[Digital Transformation]]
- [[Healthcare]]
- [[Innovation]]
- [[Machine Learning]]
- [[Medical Devices]]
- [[Simulation]]
- [[Training]]
:::

:::concepts
- [[Coherence]]
- [[AI Avatars]]
- [[Conversational AI]]
- [[Digital Transformation]]
- [[Healthcare Innovation]]
- [[Medical Simulation]]
- [[Training Technology]]
:::

:::tool-showcase
- [[Flowise]]
- [[Wordware]]
- tag:AI Models
:::