This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

690 lines
22 KiB
TypeScript

/**
* Gitgram Backend — Database Seed Script
* --------------------------------------
* Idempotent development seed. Safe to run repeatedly:
* - Clears all seeded content tables (delete-all) in FK-safe order.
* - Upserts keyed entities (users, accounts, repositories) on unique fields.
*
* Run with: npx prisma db seed
*
* Models referenced (field names mirror prisma/schema.prisma exactly):
* User, Account, Repository, Post, Follow, RepositoryFollow,
* SavedCollection, SavedPost, SavedPostCollection, Story,
* Hashtag, PostHashtag
*
* NOTE: Account is the universal social profile. Every User and every
* Repository must have a backing Account because Post/Story/Follow all
* reference Account via accountId.
*
* eslint-disable no-console — console output is the intended UX for a CLI seed.
*/
/* eslint-disable no-console */
import { PrismaClient, AccountType, PostType, UserRole } from '@prisma/client';
import * as bcrypt from 'bcryptjs';
const prisma = new PrismaClient();
// ----------------------------------------------------------------------------
// Static seed data
// ----------------------------------------------------------------------------
const SEED_PASSWORD = 'Password123!'; // dev-only password for all seeded users
interface SeedUser {
username: string;
email: string;
displayName: string;
avatarUrl: string;
bio: string;
tier: string; // marketing tier — stored in bio + drives verified/role
verified: boolean;
role: UserRole;
interests: string[];
}
const USERS: SeedUser[] = [
{
username: 'caelum0x',
email: 'caelum0x@gitgram.dev',
displayName: 'Caelum',
avatarUrl: 'https://avatars.gitgram.dev/caelum0x.png',
bio: 'Founder @ Gitgram. Making open source great again. [tier: founder]',
tier: 'founder',
verified: true,
role: UserRole.SUPER_ADMIN,
interests: ['typescript', 'distributed-systems', 'open-source'],
},
{
username: 'mxvoid',
email: 'mxvoid@gitgram.dev',
displayName: 'MX Void',
avatarUrl: 'https://avatars.gitgram.dev/mxvoid.png',
bio: 'Low-level wizard. Compilers, kernels, and void pointers. [tier: pro]',
tier: 'pro',
verified: true,
role: UserRole.MODERATOR,
interests: ['rust', 'c', 'compilers'],
},
{
username: 'natalie_dev',
email: 'natalie@gitgram.dev',
displayName: 'Natalie',
avatarUrl: 'https://avatars.gitgram.dev/natalie_dev.png',
bio: 'Full-stack dev. React, Node, and good coffee. [tier: pro]',
tier: 'pro',
verified: true,
role: UserRole.USER,
interests: ['react', 'nodejs', 'design-systems'],
},
{
username: 'rustlord',
email: 'rustlord@gitgram.dev',
displayName: 'Rust Lord',
avatarUrl: 'https://avatars.gitgram.dev/rustlord.png',
bio: 'Borrow checker enthusiast. Zero-cost abstractions only. [tier: free]',
tier: 'free',
verified: false,
role: UserRole.USER,
interests: ['rust', 'wasm', 'performance'],
},
{
username: 'aibuilder',
email: 'aibuilder@gitgram.dev',
displayName: 'AI Builder',
avatarUrl: 'https://avatars.gitgram.dev/aibuilder.png',
bio: 'Building agents that ship 35 PRs a day. [tier: free]',
tier: 'free',
verified: false,
role: UserRole.USER,
interests: ['ai', 'llm', 'agents'],
},
];
interface SeedRepo {
owner: string;
name: string;
description: string;
language: string;
stars: number;
forks: number;
watchers: number;
topics: string[];
}
const REPOS: SeedRepo[] = [
{
owner: 'caelum0x',
name: 'gitgram',
description: 'The social network for repositories. Every repo is a profile.',
language: 'TypeScript',
stars: 12450,
forks: 980,
watchers: 12450,
topics: ['social', 'github', 'typescript', 'nextjs'],
},
{
owner: 'caelum0x',
name: 'aitimemachine',
description: 'Deterministic restore system for AI coding agents.',
language: 'Rust',
stars: 8230,
forks: 410,
watchers: 8230,
topics: ['ai', 'rust', 'cli', 'agents'],
},
{
owner: 'mxvoid',
name: 'voidlang',
description: 'A tiny systems language that compiles to native code.',
language: 'C',
stars: 5600,
forks: 320,
watchers: 5600,
topics: ['compiler', 'language', 'c'],
},
{
owner: 'mxvoid',
name: 'nanokernel',
description: 'A minimal microkernel for learning OS internals.',
language: 'C',
stars: 2100,
forks: 145,
watchers: 2100,
topics: ['kernel', 'os', 'c'],
},
{
owner: 'natalie_dev',
name: 'react-flux-ui',
description: 'A headless, accessible React component library.',
language: 'TypeScript',
stars: 9870,
forks: 720,
watchers: 9870,
topics: ['react', 'ui', 'accessibility', 'typescript'],
},
{
owner: 'natalie_dev',
name: 'node-edge-cache',
description: 'Edge-first caching layer for Node.js APIs.',
language: 'JavaScript',
stars: 3340,
forks: 210,
watchers: 3340,
topics: ['nodejs', 'cache', 'edge'],
},
{
owner: 'rustlord',
name: 'borrow-bench',
description: 'Benchmark suite for Rust borrow-checker stress tests.',
language: 'Rust',
stars: 4420,
forks: 188,
watchers: 4420,
topics: ['rust', 'benchmark', 'performance'],
},
{
owner: 'rustlord',
name: 'wasm-forge',
description: 'Toolkit for building WASM modules from Rust.',
language: 'Rust',
stars: 6710,
forks: 402,
watchers: 6710,
topics: ['rust', 'wasm', 'tooling'],
},
{
owner: 'aibuilder',
name: 'agentswarm',
description: 'Orchestrate fleets of coding agents in parallel.',
language: 'Python',
stars: 15230,
forks: 1340,
watchers: 15230,
topics: ['ai', 'agents', 'python', 'llm'],
},
{
owner: 'aibuilder',
name: 'promptforge',
description: 'Versioned prompt management for LLM apps.',
language: 'Python',
stars: 7890,
forks: 560,
watchers: 7890,
topics: ['ai', 'llm', 'prompts', 'python'],
},
];
// Posts: mix of TEXT, snippet-style, and REPOSITORY shares. authorIndex maps
// into USERS; repoIndex (optional) maps into REPOS for repo-share posts.
interface SeedPost {
authorIndex: number;
type: PostType;
content: string;
hashtags: string[];
repoIndex?: number;
}
const POSTS: SeedPost[] = [
{ authorIndex: 0, type: PostType.TEXT, content: 'Just shipped the new feed ranking. Engagement is up 30%. #gitgram #buildinpublic', hashtags: ['gitgram', 'buildinpublic'] },
{ authorIndex: 0, type: PostType.REPOSITORY, content: 'Check out the repo powering all of this 👇', hashtags: ['opensource'], repoIndex: 0 },
{ authorIndex: 0, type: PostType.TEXT, content: 'Open source needs better social discovery. That is the whole thesis. #opensource', hashtags: ['opensource'] },
{ authorIndex: 1, type: PostType.TEXT, content: 'Spent the night chasing a use-after-free. Valgrind is my best friend. #c #debugging', hashtags: ['c', 'debugging'] },
{ authorIndex: 1, type: PostType.TEXT, content: 'fn parse(tok: &mut Lexer) -> Ast { /* recursive descent, the GOAT */ } #compilers', hashtags: ['compilers', 'rust'] },
{ authorIndex: 1, type: PostType.REPOSITORY, content: 'voidlang now self-hosts. Bootstrapped compiler unlocked.', hashtags: ['compilers'], repoIndex: 2 },
{ authorIndex: 2, type: PostType.TEXT, content: 'Accessibility is not optional. Shipping ARIA-complete dialogs today. #a11y #react', hashtags: ['a11y', 'react'] },
{ authorIndex: 2, type: PostType.TEXT, content: 'const useToggle = (init = false) => { const [on, set] = useState(init); return [on, () => set(v => !v)]; } #react', hashtags: ['react', 'hooks'] },
{ authorIndex: 2, type: PostType.REPOSITORY, content: 'react-flux-ui v2 is out. Headless + accessible. Try it!', hashtags: ['react', 'ui'], repoIndex: 4 },
{ authorIndex: 2, type: PostType.TEXT, content: 'Good coffee + good types = good code. #typescript', hashtags: ['typescript'] },
{ authorIndex: 3, type: PostType.TEXT, content: 'The borrow checker is not your enemy, it is your pair programmer. #rust', hashtags: ['rust'] },
{ authorIndex: 3, type: PostType.TEXT, content: 'impl<T: Clone> Forge<T> { fn build(&self) -> Module { /* zero-cost */ } } #rust #wasm', hashtags: ['rust', 'wasm'] },
{ authorIndex: 3, type: PostType.REPOSITORY, content: 'wasm-forge hit 6.7k stars. Thank you all! 🦀', hashtags: ['rust', 'wasm'], repoIndex: 7 },
{ authorIndex: 3, type: PostType.TEXT, content: 'Benchmarks or it did not happen. #performance', hashtags: ['performance'] },
{ authorIndex: 4, type: PostType.TEXT, content: 'My agent swarm just opened 35 PRs while I slept. The future is here. #ai #agents', hashtags: ['ai', 'agents'] },
{ authorIndex: 4, type: PostType.TEXT, content: 'async def run(agent): tasks = plan(agent); return await gather(*tasks) #python #llm', hashtags: ['python', 'llm'] },
{ authorIndex: 4, type: PostType.REPOSITORY, content: 'agentswarm crossed 15k stars. Orchestration is eating the world.', hashtags: ['ai', 'agents'], repoIndex: 8 },
{ authorIndex: 4, type: PostType.TEXT, content: 'Versioning your prompts is just good engineering. #llm #prompts', hashtags: ['llm', 'prompts'] },
{ authorIndex: 0, type: PostType.TEXT, content: 'Welcome to Gitgram. Make open source great again. #gitgram', hashtags: ['gitgram'] },
{ authorIndex: 1, type: PostType.TEXT, content: 'Microkernels are underrated. Fight me. #os #kernel', hashtags: ['os', 'kernel'] },
];
// Follow graph by username pairs: follower follows following.
const FOLLOWS: Array<[string, string]> = [
['mxvoid', 'caelum0x'],
['natalie_dev', 'caelum0x'],
['rustlord', 'caelum0x'],
['aibuilder', 'caelum0x'],
['caelum0x', 'mxvoid'],
['caelum0x', 'natalie_dev'],
['natalie_dev', 'mxvoid'],
['rustlord', 'mxvoid'],
['aibuilder', 'rustlord'],
['rustlord', 'aibuilder'],
];
// Starred repos: username stars "owner/name".
const STARS: Array<[string, string]> = [
['mxvoid', 'caelum0x/gitgram'],
['natalie_dev', 'caelum0x/gitgram'],
['rustlord', 'caelum0x/aitimemachine'],
['aibuilder', 'caelum0x/aitimemachine'],
['caelum0x', 'aibuilder/agentswarm'],
['natalie_dev', 'rustlord/wasm-forge'],
['mxvoid', 'rustlord/borrow-bench'],
['rustlord', 'mxvoid/voidlang'],
];
// Collections: owner username + name + post indexes (into POSTS) to include.
interface SeedCollection {
ownerUsername: string;
name: string;
description: string;
isPrivate: boolean;
postIndexes: number[];
}
const COLLECTIONS: SeedCollection[] = [
{ ownerUsername: 'caelum0x', name: 'Inspiration', description: 'Posts that fire me up.', isPrivate: false, postIndexes: [14, 16] },
{ ownerUsername: 'mxvoid', name: 'Compiler Notes', description: 'Compiler tricks worth saving.', isPrivate: false, postIndexes: [4, 5] },
{ ownerUsername: 'natalie_dev', name: 'React Gems', description: 'Reusable React patterns.', isPrivate: true, postIndexes: [7, 8] },
{ ownerUsername: 'rustlord', name: 'Rust Reads', description: 'Rust posts to revisit.', isPrivate: false, postIndexes: [10, 11, 12] },
{ ownerUsername: 'aibuilder', name: 'Agent Ideas', description: 'Agent orchestration ideas.', isPrivate: false, postIndexes: [14, 17] },
];
// Stories: owner username + media.
interface SeedStory {
ownerUsername: string;
mediaUrl: string;
mediaType: string;
caption: string;
}
const STORIES: SeedStory[] = [
{ ownerUsername: 'caelum0x', mediaUrl: 'https://media.gitgram.dev/stories/launch.png', mediaType: 'image', caption: 'Launch day!' },
{ ownerUsername: 'natalie_dev', mediaUrl: 'https://media.gitgram.dev/stories/uikit.png', mediaType: 'image', caption: 'New UI kit preview' },
{ ownerUsername: 'aibuilder', mediaUrl: 'https://media.gitgram.dev/stories/swarm.mp4', mediaType: 'video', caption: '35 PRs in one night' },
];
// ----------------------------------------------------------------------------
// Helpers
// ----------------------------------------------------------------------------
const STORY_TTL_MS = 24 * 60 * 60 * 1000;
/** Clear all seeded content tables in FK-safe order (children before parents). */
async function clearAll(): Promise<void> {
await prisma.savedPostCollection.deleteMany({});
await prisma.savedPost.deleteMany({});
await prisma.savedCollection.deleteMany({});
await prisma.postHashtag.deleteMany({});
await prisma.hashtag.deleteMany({});
await prisma.story.deleteMany({});
await prisma.post.deleteMany({});
await prisma.repositoryFollow.deleteMany({});
await prisma.follow.deleteMany({});
// Accounts, Users and Repositories are upserted (kept), not deleted.
}
// ----------------------------------------------------------------------------
// Seed steps
// ----------------------------------------------------------------------------
/** 1. Users + their USER accounts. Returns maps keyed by username. */
async function seedUsers(): Promise<{
userByName: Map<string, { id: string }>;
accountByName: Map<string, { id: string }>;
}> {
const userByName = new Map<string, { id: string }>();
const accountByName = new Map<string, { id: string }>();
const passwordHash = await bcrypt.hash(SEED_PASSWORD, 10);
for (const u of USERS) {
const user = await prisma.user.upsert({
where: { email: u.email },
update: {
username: u.username,
displayName: u.displayName,
avatar: u.avatarUrl,
avatarUrl: u.avatarUrl,
bio: u.bio,
verified: u.verified,
role: u.role,
interests: u.interests,
emailVerified: true,
},
create: {
email: u.email,
password: passwordHash,
username: u.username,
displayName: u.displayName,
avatar: u.avatarUrl,
avatarUrl: u.avatarUrl,
bio: u.bio,
verified: u.verified,
role: u.role,
interests: u.interests,
emailVerified: true,
},
});
const account = await prisma.account.upsert({
where: { username: u.username },
update: {
type: AccountType.USER,
displayName: u.displayName,
avatar: u.avatarUrl,
bio: u.bio,
verified: u.verified,
userId: user.id,
},
create: {
type: AccountType.USER,
username: u.username,
displayName: u.displayName,
avatar: u.avatarUrl,
bio: u.bio,
verified: u.verified,
userId: user.id,
},
});
userByName.set(u.username, user);
accountByName.set(u.username, account);
}
return { userByName, accountByName };
}
/** 2. Repositories + their REPOSITORY accounts. Keyed by "owner/name". */
async function seedRepositories(): Promise<{
repoByFullName: Map<string, { id: string }>;
}> {
const repoByFullName = new Map<string, { id: string }>();
for (const r of REPOS) {
const fullName = `${r.owner}/${r.name}`;
const htmlUrl = `https://github.com/${fullName}`;
const repo = await prisma.repository.upsert({
where: { fullName },
update: {
owner: r.owner,
name: r.name,
description: r.description,
language: r.language,
stars: r.stars,
forks: r.forks,
watchers: r.watchers,
topics: r.topics,
htmlUrl,
},
create: {
owner: r.owner,
name: r.name,
fullName,
description: r.description,
language: r.language,
stars: r.stars,
forks: r.forks,
watchers: r.watchers,
topics: r.topics,
htmlUrl,
},
});
// Repo account handle is the full "owner/name" to stay unique.
await prisma.account.upsert({
where: { username: fullName },
update: {
type: AccountType.REPOSITORY,
displayName: r.name,
bio: r.description,
repositoryId: repo.id,
},
create: {
type: AccountType.REPOSITORY,
username: fullName,
displayName: r.name,
bio: r.description,
repositoryId: repo.id,
},
});
repoByFullName.set(fullName, repo);
}
return { repoByFullName };
}
/** 3. Posts + hashtags. Returns post ids in declaration order. */
async function seedPosts(
accountByName: Map<string, { id: string }>,
userByName: Map<string, { id: string }>,
repoByFullName: Map<string, { id: string }>,
): Promise<string[]> {
const postIds: string[] = [];
for (const p of POSTS) {
const author = USERS[p.authorIndex];
const account = accountByName.get(author.username)!;
const user = userByName.get(author.username)!;
let repositoryId: string | undefined;
let repoUrl: string | undefined;
if (p.repoIndex !== undefined) {
const r = REPOS[p.repoIndex];
const fullName = `${r.owner}/${r.name}`;
repositoryId = repoByFullName.get(fullName)?.id;
repoUrl = `https://github.com/${fullName}`;
}
const post = await prisma.post.create({
data: {
accountId: account.id,
userId: user.id,
repositoryId,
repoUrl,
content: p.content,
type: p.type,
status: 'PUBLISHED',
},
});
postIds.push(post.id);
// Hashtags: upsert the tag (bump count), then link via PostHashtag.
for (const tag of p.hashtags) {
const hashtag = await prisma.hashtag.upsert({
where: { name: tag },
update: { count: { increment: 1 } },
create: { name: tag, count: 1 },
});
await prisma.postHashtag.upsert({
where: { postId_hashtagId: { postId: post.id, hashtagId: hashtag.id } },
update: {},
create: { postId: post.id, hashtagId: hashtag.id },
});
}
}
return postIds;
}
/** 4. Follow relationships (Account-level + User-level). */
async function seedFollows(
accountByName: Map<string, { id: string }>,
userByName: Map<string, { id: string }>,
): Promise<void> {
for (const [followerName, followingName] of FOLLOWS) {
const followerAccount = accountByName.get(followerName)!;
const followingAccount = accountByName.get(followingName)!;
const followerUser = userByName.get(followerName)!;
const followingUser = userByName.get(followingName)!;
await prisma.follow.upsert({
where: {
followerId_followingId: {
followerId: followerAccount.id,
followingId: followingAccount.id,
},
},
update: {},
create: {
followerId: followerAccount.id,
followingId: followingAccount.id,
followerUserId: followerUser.id,
followingUserId: followingUser.id,
},
});
}
}
/** 5. Starred repos via RepositoryFollow (user-level). */
async function seedStars(
accountByName: Map<string, { id: string }>,
userByName: Map<string, { id: string }>,
repoByFullName: Map<string, { id: string }>,
): Promise<void> {
for (const [username, fullName] of STARS) {
const account = accountByName.get(username)!;
const user = userByName.get(username)!;
const repo = repoByFullName.get(fullName)!;
await prisma.repositoryFollow.upsert({
where: { userId_repositoryId: { userId: user.id, repositoryId: repo.id } },
update: {},
create: {
accountId: account.id,
userId: user.id,
repositoryId: repo.id,
},
});
}
}
/** 6. Collections + saved posts (with many-to-many junction links). */
async function seedCollections(
accountByName: Map<string, { id: string }>,
userByName: Map<string, { id: string }>,
postIds: string[],
): Promise<void> {
for (const c of COLLECTIONS) {
const account = accountByName.get(c.ownerUsername)!;
const user = userByName.get(c.ownerUsername)!;
const collection = await prisma.savedCollection.upsert({
where: { userId_name: { userId: user.id, name: c.name } },
update: {
description: c.description,
isPrivate: c.isPrivate,
accountId: account.id,
},
create: {
accountId: account.id,
userId: user.id,
name: c.name,
description: c.description,
isPrivate: c.isPrivate,
},
});
for (const idx of c.postIndexes) {
const postId = postIds[idx];
if (!postId) continue;
const savedPost = await prisma.savedPost.upsert({
where: { userId_postId: { userId: user.id, postId } },
update: { collectionId: collection.id, accountId: account.id },
create: {
accountId: account.id,
userId: user.id,
postId,
collectionId: collection.id,
},
});
await prisma.savedPostCollection.upsert({
where: {
savedPostId_collectionId: {
savedPostId: savedPost.id,
collectionId: collection.id,
},
},
update: {},
create: { savedPostId: savedPost.id, collectionId: collection.id },
});
}
}
}
/** 7. Stories (24h TTL). */
async function seedStoriesStep(
accountByName: Map<string, { id: string }>,
userByName: Map<string, { id: string }>,
): Promise<void> {
const expiresAt = new Date(Date.now() + STORY_TTL_MS);
for (const s of STORIES) {
const account = accountByName.get(s.ownerUsername)!;
const user = userByName.get(s.ownerUsername)!;
await prisma.story.create({
data: {
accountId: account.id,
userId: user.id,
mediaUrl: s.mediaUrl,
mediaType: s.mediaType,
caption: s.caption,
expiresAt,
},
});
}
}
// ----------------------------------------------------------------------------
// Main
// ----------------------------------------------------------------------------
async function main(): Promise<void> {
console.log('🌱 Seeding Gitgram database...');
console.log(' • clearing seeded content tables');
await clearAll();
console.log(' • users + accounts');
const { userByName, accountByName } = await seedUsers();
console.log(' • repositories + accounts');
const { repoByFullName } = await seedRepositories();
console.log(' • posts + hashtags');
const postIds = await seedPosts(accountByName, userByName, repoByFullName);
console.log(' • follows');
await seedFollows(accountByName, userByName);
console.log(' • starred repos');
await seedStars(accountByName, userByName, repoByFullName);
console.log(' • collections + saved posts');
await seedCollections(accountByName, userByName, postIds);
console.log(' • stories');
await seedStoriesStep(accountByName, userByName);
console.log(
`✅ Seed complete: ${USERS.length} users, ${REPOS.length} repos, ` +
`${POSTS.length} posts, ${FOLLOWS.length} follows, ${STARS.length} stars, ` +
`${COLLECTIONS.length} collections, ${STORIES.length} stories.`,
);
}
main()
.catch((err) => {
console.error('❌ Seed failed:', err);
process.exit(1);
})
.finally(async () => {
await prisma.$disconnect();
});