ai-devkit 0.2.0 → 0.4.0

package/web/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

package/web/lib/GitHubContext.tsx

@@ -0,0 +1,57 @@
+'use client';
+
+import { createContext, useContext, useState, useEffect, ReactNode } from 'react';
+
+interface GitHubContextType {
+  stars: number | null;
+  loading: boolean;
+}
+
+const GitHubContext = createContext<GitHubContextType>({
+  stars: null,
+  loading: true,
+});
+
+export function GitHubProvider({ 
+  children, 
+  repo 
+}: { 
+  children: ReactNode; 
+  repo: string;
+}) {
+  const [stars, setStars] = useState<number | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    async function fetchStars() {
+      try {
+        const response = await fetch(`https://api.github.com/repos/${repo}`);
+        if (response.ok) {
+          const data = await response.json();
+          setStars(data.stargazers_count);
+        }
+      } catch (error) {
+        console.error('Failed to fetch GitHub stars:', error);
+      } finally {
+        setLoading(false);
+      }
+    }
+
+    fetchStars();
+  }, [repo]);
+
+  return (
+    <GitHubContext.Provider value={{ stars, loading }}>
+      {children}
+    </GitHubContext.Provider>
+  );
+}
+
+export function useGitHubStars() {
+  const context = useContext(GitHubContext);
+  if (!context) {
+    throw new Error('useGitHubStars must be used within a GitHubProvider');
+  }
+  return context;
+}
+

package/web/lib/content/loader.ts

@@ -0,0 +1,152 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+import { Page, PageMetadata, RoadmapItem, RoadmapItemMetadata } from './types';
+
+const contentDirectory = path.join(process.cwd(), 'content');
+const docsDirectory = path.join(contentDirectory, 'docs');
+const pagesDirectory = path.join(contentDirectory, 'pages');
+
+/**
+ * Get all Markdown files from a directory
+ */
+function getMarkdownFiles(dir: string): string[] {
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  
+  const files = fs.readdirSync(dir);
+  return files
+    .filter(file => file.endsWith('.md') || file.endsWith('.mdx'))
+    .map(file => path.join(dir, file));
+}
+
+/**
+ * Parse a Markdown file with frontmatter
+ */
+function parseMarkdownFile<T>(filePath: string): { metadata: T; content: string } {
+  const fileContents = fs.readFileSync(filePath, 'utf8');
+  const { data, content } = matter(fileContents);
+  
+  return {
+    metadata: data as T,
+    content: content.trim(),
+  };
+}
+
+/**
+ * Get a single page by slug
+ */
+export function getPage(slug: string): Page | null {
+  const filePath = path.join(pagesDirectory, `${slug}.md`);
+  
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  
+  const parsed = parseMarkdownFile<PageMetadata>(filePath);
+  
+  return {
+    metadata: {
+      ...parsed.metadata,
+      slug,
+    },
+    content: parsed.content,
+  };
+}
+
+/**
+ * Get all pages
+ */
+export function getAllPages(): Page[] {
+  const files = getMarkdownFiles(pagesDirectory);
+  
+  const pages = files.map(filePath => {
+    const slug = path.basename(filePath, path.extname(filePath));
+    const parsed = parseMarkdownFile<PageMetadata>(filePath);
+    
+    return {
+      metadata: {
+        ...parsed.metadata,
+        slug,
+      },
+      content: parsed.content,
+    };
+  });
+  
+  // Sort by order if specified
+  return pages.sort((a, b) => {
+    const orderA = a.metadata.order ?? 999;
+    const orderB = b.metadata.order ?? 999;
+    return orderA - orderB;
+  });
+}
+
+/**
+ * Get a single documentation page by slug
+ */
+export function getDocPage(slug: string): Page | null {
+  const filePath = path.join(docsDirectory, `${slug}.md`);
+  
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  
+  const parsed = parseMarkdownFile<PageMetadata>(filePath);
+  
+  return {
+    metadata: {
+      ...parsed.metadata,
+      slug,
+    },
+    content: parsed.content,
+  };
+}
+
+/**
+ * Get all documentation pages
+ */
+export function getAllDocPages(): Page[] {
+  const files = getMarkdownFiles(docsDirectory);
+  
+  const pages = files.map(filePath => {
+    const slug = path.basename(filePath, path.extname(filePath));
+    const parsed = parseMarkdownFile<PageMetadata>(filePath);
+    
+    return {
+      metadata: {
+        ...parsed.metadata,
+        slug,
+      },
+      content: parsed.content,
+    };
+  });
+  
+  // Sort by order if specified
+  return pages.sort((a, b) => {
+    const orderA = a.metadata.order ?? 999;
+    const orderB = b.metadata.order ?? 999;
+    return orderA - orderB;
+  });
+}
+
+/**
+ * Get all roadmap items
+ */
+export function getRoadmap(): RoadmapItem[] {
+  const roadmapDir = path.join(contentDirectory, 'roadmap');
+  const files = getMarkdownFiles(roadmapDir);
+  
+  const items = files.map(filePath => {
+    const parsed = parseMarkdownFile<RoadmapItemMetadata>(filePath);
+    return parsed as RoadmapItem;
+  });
+  
+  // Sort by order if specified, then by priority
+  return items.sort((a, b) => {
+    const orderA = a.metadata.order ?? 999;
+    const orderB = b.metadata.order ?? 999;
+    return orderA - orderB;
+  });
+}
+

package/web/lib/content/types.ts

@@ -0,0 +1,37 @@
+export interface PageMetadata {
+  title: string;
+  description: string;
+  slug: string;
+  heroImage?: string;
+  order?: number;
+}
+
+export interface Page {
+  metadata: PageMetadata;
+  content: string;
+}
+
+export interface RoadmapItemMetadata {
+  title: string;
+  status: 'planned' | 'in-progress' | 'completed' | 'on-hold';
+  timeframe?: string;
+  priority?: 'low' | 'medium' | 'high';
+  order?: number;
+}
+
+export interface RoadmapItem {
+  metadata: RoadmapItemMetadata;
+  content: string;
+}
+
+export interface NavigationLink {
+  label: string;
+  href: string;
+  external?: boolean;
+}
+
+export interface NavigationSection {
+  title: string;
+  links: NavigationLink[];
+}
+

package/web/lib/utils.ts

@@ -0,0 +1,12 @@
+/**
+ * Format star count for display
+ * @param count - The number of stars
+ * @returns Formatted string (e.g., "1.5k" for 1500)
+ */
+export function formatStars(count: number): string {
+  if (count >= 1000) {
+    return `${(count / 1000).toFixed(1)}k`;
+  }
+  return count.toString();
+}
+

package/web/next.config.ts

@@ -0,0 +1,11 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  output: 'export',
+  images: {
+    unoptimized: true,
+  },
+  trailingSlash: true,
+};
+
+export default nextConfig;