memcore-ai 1.0.2

package/.cursorrules

@@ -0,0 +1,7 @@
+# Project Rules — generated by memcore
+
+## Project Context
+
+- **arquitectura base**: usamos TypeScript con tsx, sin compilar, Node 24
+- **stack del proyecto**: Node 24, TypeScript, tsx, sin compilar, chalk para colores
+

package/CLAUDE.md

@@ -0,0 +1,12 @@
+# MEMCORE — Project Memory
+
+_Auto-generated by [memcore](https://github.com/your-username/memcore). Do not edit manually._
+
+## Project Context
+
+### arquitectura base
+usamos TypeScript con tsx, sin compilar, Node 24
+
+### stack del proyecto
+Node 24, TypeScript, tsx, sin compilar, chalk para colores
+

package/README.md

@@ -0,0 +1,175 @@
+# MEMCORE — Universal AI Memory Layer
+
+> **Git for AI memory.** Give every AI tool persistent memory across sessions.
+
+[![npm](https://img.shields.io/npm/v/memcore)](https://www.npmjs.com/package/memcore)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## The problem
+
+Every time you open Claude Code, Cursor, or ChatGPT — it forgets everything.
+Your architecture decisions. Your team conventions. Your project context.
+You explain the same things over and over. Every session. Every developer.
+
+**No AI tool has real persistent memory. Until now.**
+
+---
+
+## What is MEMCORE?
+
+MEMCORE is a universal memory layer that works with any AI tool.
+Save context once. Every AI remembers it forever.
+`ash
+npm install -g memcore
+`
+
+---
+
+## How it works
+`ash
+# 1. Initialize in your project
+memcore init
+
+# 2. Save what matters
+memcore save
+# > Memory name: auth system
+# > Type: project
+# > Content: we use JWT, not sessions — compliance requirement
+
+# 3. Inject into your AI tools
+memcore inject          # → writes CLAUDE.md for Claude Code
+memcore inject-cursor   # → writes .cursorrules for Cursor
+memcore inject-chatgpt  # → exports context for ChatGPT
+
+# 4. Your AI now knows everything — without you explaining anything
+claude  # Claude Code reads CLAUDE.md automatically
+`
+
+---
+
+## Team sharing
+`ash
+# Dev 1 — save and share
+memcore save
+memcore push
+git add memcore-sync.json && git commit -m "chore: update team memory"
+
+# Dev 2 — get all context instantly
+git pull
+memcore pull
+memcore inject
+# Done. Full project context in seconds.
+`
+
+---
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| memcore init | Initialize in current project |
+| memcore save | Save a new memory |
+| memcore list | List all memories |
+| memcore search query | Search memories |
+| memcore delete id | Delete a memory |
+| memcore inject | Inject into CLAUDE.md |
+| memcore inject-cursor | Inject into .cursorrules |
+| memcore inject-chatgpt | Export for ChatGPT |
+| memcore push | Export team memories |
+| memcore pull | Import team memories |
+| memcore export | Export to memcore.json |
+| memcore import | Import from memcore.json |
+
+---
+
+## Memory types
+
+| Type | What to save |
+|---|---|
+| project | Architecture decisions, tech stack, constraints |
+| feedback | How to work with you, what to avoid |
+| user | Your role, expertise level, preferences |
+| reference | Where info lives — Linear, Jira, Slack, Grafana |
+
+---
+
+## SDK
+`	ypescript
+import { memcore } from 'memcore'
+
+// Get full project context as string
+const context = memcore.getContext()
+
+// Save a memory programmatically
+memcore.save('auth system', 'project', 'we use JWT — compliance requirement')
+
+// Search memories
+const results = memcore.search('auth')
+
+// Inject into AI tools
+memcore.inject()        // Claude Code
+memcore.injectCursor()  // Cursor
+`
+
+---
+
+## The memcore.json protocol
+
+MEMCORE defines an open standard for AI memory.
+Any tool can read and write it.
+`json
+{
+  "version": "1.0",
+  "project": { "name": "my-project" },
+  "memories": [
+    {
+      "name": "auth system",
+      "type": "project",
+      "content": "we use JWT, not sessions"
+    }
+  ],
+  "rules": ["never touch legacy/payments.ts"],
+  "references": { "bugs": "Linear project INGEST" },
+  "integrations": { "claude": true, "cursor": true, "chatgpt": true }
+}
+`
+
+---
+
+## AI tools supported
+
+| Tool | How | Status |
+|---|---|---|
+| Claude Code | Writes CLAUDE.md | Live |
+| Cursor | Writes .cursorrules | Live |
+| ChatGPT | Exports .txt | Live |
+| Gemini CLI | Coming soon | Planned |
+| GitHub Copilot | Coming soon | Planned |
+
+---
+
+## Roadmap
+
+- [x] Core memory system
+- [x] Claude Code integration
+- [x] Cursor integration
+- [x] ChatGPT integration
+- [x] Team sync via Git
+- [x] Open protocol (memcore.json)
+- [x] SDK
+- [ ] Daemon (auto-injection)
+- [ ] MEMCORE Cloud (team SaaS)
+- [ ] Memory Graph
+- [ ] Notion, Slack, Jira connectors
+
+---
+
+## License
+
+MIT — free forever for individuals.
+
+---
+
+Built with the belief that AI tools should remember what matters.

package/bin/memcore.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const cli = join(__dirname, '..', 'src', 'cli', 'index.ts')
+const args = process.argv.slice(2)
+
+const child = spawn('npx', ['tsx', cli, ...args], { stdio: 'inherit', shell: true })
+child.on('exit', code => process.exit(code))

package/memcore-sync.json

@@ -0,0 +1,27 @@
+{
+  "teamId": "memcore",
+  "version": 1775348293616,
+  "updatedAt": "2026-04-05T00:18:13.616Z",
+  "memories": [
+    {
+      "id": "1775330220683-arquitectura-base",
+      "name": "arquitectura base",
+      "type": "project",
+      "description": "decisiones de arquitectura del proyecto",
+      "content": "usamos TypeScript con tsx, sin compilar, Node 24",
+      "author": "Roy",
+      "createdAt": "2026-04-04T19:17:00.683Z",
+      "hash": "21b5c5e1"
+    },
+    {
+      "id": "1775331355076-stack-del-proyecto",
+      "name": "stack del proyecto",
+      "type": "project",
+      "description": "tecnologías que usamos",
+      "content": "Node 24, TypeScript, tsx, sin compilar, chalk para colores",
+      "author": "Roy",
+      "createdAt": "2026-04-04T19:35:55.076Z",
+      "hash": "e5f0bd01"
+    }
+  ]
+}

package/memcore.json

@@ -0,0 +1,40 @@
+{
+  "version": "1.0",
+  "project": {
+    "name": "memcore",
+    "description": ""
+  },
+  "memories": [
+    {
+      "name": "arquitectura base",
+      "type": "project",
+      "description": "decisiones de arquitectura del proyecto",
+      "content": "usamos TypeScript con tsx, sin compilar, Node 24"
+    },
+    {
+      "name": "stack del proyecto",
+      "type": "project",
+      "description": "tecnologías que usamos",
+      "content": "Node 24, TypeScript, tsx, sin compilar, chalk para colores"
+    },
+    {
+      "name": "arquitectura base",
+      "type": "project",
+      "description": "decisiones de arquitectura del proyecto",
+      "content": "usamos TypeScript con tsx, sin compilar, Node 24"
+    },
+    {
+      "name": "stack del proyecto",
+      "type": "project",
+      "description": "tecnologías que usamos",
+      "content": "Node 24, TypeScript, tsx, sin compilar, chalk para colores"
+    }
+  ],
+  "rules": [],
+  "references": {},
+  "integrations": {
+    "claude": true,
+    "cursor": true,
+    "chatgpt": true
+  }
+}

package/memcore.schema.json

@@ -0,0 +1,30 @@
+{
+  "": "https://memcore.dev/schema/v1",
+  "version": "1.0",
+  "project": {
+    "name": "mi-proyecto",
+    "description": "descripción del proyecto"
+  },
+  "memories": [
+    {
+      "name": "ejemplo",
+      "type": "project",
+      "description": "decisión de arquitectura",
+      "content": "usamos PostgreSQL por compliance"
+    }
+  ],
+  "rules": [
+    "nunca tocar legacy/payments.ts",
+    "siempre escribir tests antes del código"
+  ],
+  "references": {
+    "bugs": "Linear proyecto INGEST",
+    "deploy": "GitHub Actions",
+    "docs": "Notion"
+  },
+  "integrations": {
+    "claude": true,
+    "cursor": true,
+    "chatgpt": true
+  }
+}

package/memoryTypes.ts

@@ -0,0 +1,20 @@
+export const MEMORY_TYPES = ['user', 'feedback', 'project', 'reference'] as const
+
+export type MemoryType = typeof MEMORY_TYPES[number]
+
+export type Memory = {
+  id: string
+  name: string
+  description: string
+  type: MemoryType
+  content: string
+  createdAt: Date
+  updatedAt: Date
+  projectPath: string
+  isTeam: boolean
+}
+
+export function parseMemoryType(raw: unknown): MemoryType | undefined {
+  if (typeof raw !== 'string') return undefined
+  return MEMORY_TYPES.find(t => t === raw)
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "memcore-ai",
+  "version": "1.0.2",
+  "description": "Universal AI memory layer for Claude, ChatGPT, Cursor and more",
+  "type": "module",
+  "bin": {
+    "memcore": "./bin/memcore.js"
+  },
+  "scripts": {
+    "start": "tsx src/cli/index.ts",
+    "dev": "tsx watch src/cli/index.ts"
+  },
+  "keywords": [
+    "ai",
+    "memory",
+    "claude",
+    "cursor",
+    "copilot",
+    "chatgpt"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.6.0",
+    "commander": "^12.0.0",
+    "gray-matter": "^4.0.3"
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,100 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+import * as readline from 'readline'
+import { deleteMemory, initMemoryDir, loadMemories, saveMemory, searchMemories } from '../core/memory-store.js'
+import { injectMemories } from '../core/injector.js'
+import { injectCursor, injectChatGPT } from '../core/connectors.js'
+import { exportToSync, importFromSync } from '../sync/teamSync.js'
+import { exportToSchema, importFromSchema } from '../sync/protocol.js'
+
+const program = new Command()
+const PROJECT_PATH = process.cwd()
+
+program.name('memcore').description('Universal AI memory layer').version('1.0.0')
+
+program.command('init').description('Initialize memcore').action(() => {
+  initMemoryDir(PROJECT_PATH)
+  console.log(chalk.green('✓ Ready! Use: memcore save'))
+})
+
+program.command('save').description('Save a memory').action(async () => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  const ask = (q) => new Promise(res => rl.question(q, res))
+  const name = await ask('Memory name: ')
+  const type = await ask('Type (user/feedback/project/reference): ')
+  const description = await ask('Short description: ')
+  const content = await ask('Content: ')
+  rl.close()
+  const memory = saveMemory(PROJECT_PATH, name, type, content, description, false)
+  console.log(chalk.green('✓ Saved: ' + memory.name))
+})
+
+program.command('list').description('List memories').action(() => {
+  const memories = loadMemories(PROJECT_PATH, false)
+  if (memories.length === 0) { console.log(chalk.yellow('No memories yet.')); return }
+  console.log(chalk.bold('Memories (' + memories.length + '):'))
+  for (const m of memories) {
+    console.log(chalk.green('▸ ' + m.name) + chalk.gray(' [' + m.type + ']'))
+    console.log(chalk.gray('  ' + m.description))
+  }
+})
+
+program.command('search <query>').description('Search memories').action((query) => {
+  const results = searchMemories(PROJECT_PATH, query)
+  if (results.length === 0) { console.log(chalk.yellow('No results for: ' + query)); return }
+  console.log(chalk.bold('Results (' + results.length + '):'))
+  for (const m of results) {
+    console.log(chalk.green('▸ ' + m.name) + chalk.gray(' [' + m.type + ']'))
+    console.log(chalk.gray('  ' + m.description))
+    console.log(chalk.white('  ' + m.content.slice(0, 100)))
+  }
+})
+
+program.command('delete <id>').description('Delete a memory').action((id) => {
+  const deleted = deleteMemory(PROJECT_PATH, id)
+  if (deleted) { console.log(chalk.green('✓ Deleted: ' + id)) }
+  else { console.log(chalk.red('✗ Not found: ' + id)) }
+})
+
+program.command('inject').description('Inject into CLAUDE.md').action(() => {
+  injectMemories(PROJECT_PATH)
+})
+
+program.command('inject-cursor').description('Inject into .cursorrules').action(() => {
+  injectCursor(PROJECT_PATH)
+})
+
+program.command('inject-chatgpt').description('Export for ChatGPT').action(() => {
+  injectChatGPT(PROJECT_PATH)
+})
+
+program.command('push').description('Export memories for team').action(() => {
+  const manifest = exportToSync(PROJECT_PATH)
+  console.log(chalk.green('✓ Exported ' + manifest.memories.length + ' memories to memcore-sync.json'))
+  console.log(chalk.gray('  Commit this file to Git so your team can pull it.'))
+})
+
+program.command('pull').description('Import memories from team').action(() => {
+  const imported = importFromSync(PROJECT_PATH)
+  if (imported === 0) {
+    console.log(chalk.yellow('No new memories to import.'))
+  } else {
+    console.log(chalk.green('✓ Imported ' + imported + ' new team memories.'))
+  }
+})
+
+program.command('export').description('Export to memcore.json protocol').action(() => {
+  const memories = [...loadMemories(PROJECT_PATH, false), ...loadMemories(PROJECT_PATH, true)]
+  exportToSchema(PROJECT_PATH, memories)
+})
+
+program.command('import').description('Import from memcore.json protocol').action(() => {
+  const imported = importFromSchema(PROJECT_PATH)
+  if (imported === 0) {
+    console.log(chalk.yellow('Nothing imported.'))
+  } else {
+    console.log(chalk.green('✓ Imported ' + imported + ' items from memcore.json'))
+  }
+})
+
+program.parse()

package/src/core/connectors.ts

@@ -0,0 +1,76 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { loadMemories } from './memory-store.js'
+
+export function injectCursor(projectPath) {
+  const all = [...loadMemories(projectPath, false), ...loadMemories(projectPath, true)]
+
+  if (all.length === 0) {
+    console.log('No memories to inject.')
+    return
+  }
+
+  let content = '# Project Rules — generated by memcore\n\n'
+
+  const byType = { user: [], feedback: [], project: [], reference: [] }
+  for (const m of all) {
+    if (byType[m.type]) byType[m.type].push(m)
+  }
+
+  if (byType.project.length > 0) {
+    content += '## Project Context\n\n'
+    for (const m of byType.project) {
+      content += '- **' + m.name + '**: ' + m.content + '\n'
+    }
+    content += '\n'
+  }
+
+  if (byType.feedback.length > 0) {
+    content += '## How to work with me\n\n'
+    for (const m of byType.feedback) {
+      content += '- **' + m.name + '**: ' + m.content + '\n'
+    }
+    content += '\n'
+  }
+
+  if (byType.user.length > 0) {
+    content += '## About the developer\n\n'
+    for (const m of byType.user) {
+      content += '- **' + m.name + '**: ' + m.content + '\n'
+    }
+    content += '\n'
+  }
+
+  if (byType.reference.length > 0) {
+    content += '## References\n\n'
+    for (const m of byType.reference) {
+      content += '- **' + m.name + '**: ' + m.content + '\n'
+    }
+    content += '\n'
+  }
+
+  const cursorRules = path.join(projectPath, '.cursorrules')
+  fs.writeFileSync(cursorRules, content, 'utf-8')
+  console.log('✓ Injected ' + all.length + ' memories into .cursorrules')
+  console.log('  Cursor will now read this automatically.')
+}
+
+export function injectChatGPT(projectPath) {
+  const all = [...loadMemories(projectPath, false), ...loadMemories(projectPath, true)]
+
+  if (all.length === 0) {
+    console.log('No memories to inject.')
+    return
+  }
+
+  let content = 'CONTEXT FOR THIS PROJECT:\n\n'
+  for (const m of all) {
+    content += '- ' + m.name + ': ' + m.content + '\n'
+  }
+  content += '\nPlease keep this context in mind for all responses.'
+
+  const outFile = path.join(projectPath, 'memcore-chatgpt.txt')
+  fs.writeFileSync(outFile, content, 'utf-8')
+  console.log('✓ Injected ' + all.length + ' memories into memcore-chatgpt.txt')
+  console.log('  Copy and paste this file content into ChatGPT as your first message.')
+}

package/src/core/index.ts

@@ -0,0 +1,100 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+import * as readline from 'readline'
+import {
+    deleteMemory,
+    initMemoryDir,
+    loadMemories,
+    saveMemory,
+    searchMemories,
+} from '../core/memory-store.js'
+import { MEMORY_TYPES, type MemoryType } from '../core/memory-types.js'
+
+const program = new Command()
+const PROJECT_PATH = process.cwd()
+
+program
+  .name('memcore')
+  .description('Universal AI memory layer')
+  .version('1.0.0')
+
+program
+  .command('init')
+  .description('Initialize memcore in current project')
+  .action(() => {
+    initMemoryDir(PROJECT_PATH)
+    console.log(chalk.green('\n✓ Ready. Start saving memories with: memcore save'))
+  })
+
+program
+  .command('save')
+  .description('Save a new memory')
+  .option('-n, --name <name>', 'Memory name')
+  .option('-t, --type <type>', 'Memory type (user/feedback/project/reference)')
+  .option('-d, --desc <description>', 'Short description')
+  .option('-c, --content <content>', 'Memory content')
+  .option('--team', 'Save as team memory (shared)')
+  .action(async (opts) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    const ask = (q: string) => new Promise<string>(res => rl.question(q, res))
+
+    const name = opts.name || await ask(chalk.cyan('Memory name: '))
+    const rawType = opts.type || await ask(chalk.cyan(`Type (${MEMORY_TYPES.join('/')}): `))
+    const type = (MEMORY_TYPES.includes(rawType as MemoryType) ? rawType : 'project') as MemoryType
+    const description = opts.desc || await ask(chalk.cyan('Short description: '))
+    const content = opts.content || await ask(chalk.cyan('Content: '))
+    rl.close()
+
+    const memory = saveMemory(PROJECT_PATH, name, type, content, description, opts.team ?? false)
+    console.log(chalk.green(`\n✓ Memory saved: ${memory.name} [${memory.type}]`))
+  })
+
+program
+  .command('list')
+  .description('List all memories')
+  .option('--team', 'Show team memories')
+  .action((opts) => {
+    const memories = loadMemories(PROJECT_PATH, opts.team ?? false)
+    if (memories.length === 0) {
+      console.log(chalk.yellow('No memories found. Run: memcore save'))
+      return
+    }
+    console.log(chalk.bold(`\n📦 ${opts.team ? 'Team' : 'Private'} memories (${memories.length}):\n`))
+    for (const m of memories) {
+      console.log(chalk.green(`▸ ${m.name}`) + chalk.gray(` [${m.type}]`))
+      console.log(chalk.gray(`  ${m.description}`))
+      console.log()
+    }
+  })
+
+program
+  .command('search <query>')
+  .description('Search memories by keyword')
+  .action((query) => {
+    const results = searchMemories(PROJECT_PATH, query)
+    if (results.length === 0) {
+      console.log(chalk.yellow(`No memories found for: "${query}"`))
+      return
+    }
+    console.log(chalk.bold(`\n🔍 Results for "${query}" (${results.length}):\n`))
+    for (const m of results) {
+      console.log(chalk.green(`▸ ${m.name}`) + chalk.gray(` [${m.type}]`))
+      console.log(chalk.gray(`  ${m.description}`))
+      console.log(chalk.white(`  ${m.content.slice(0, 100)}...`))
+      console.log()
+    }
+  })
+
+program
+  .command('delete <id>')
+  .description('Delete a memory by ID')
+  .action((id) => {
+    const deleted = deleteMemory(PROJECT_PATH, id)
+    if (deleted) {
+      console.log(chalk.green(`✓ Memory deleted: ${id}`))
+    } else {
+      console.log(chalk.red(`✗ Memory not found: ${id}`))
+    }
+  })
+
+program.parse()

package/src/core/injector.ts

@@ -0,0 +1,59 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { loadMemories } from './memory-store.js'
+
+export function injectMemories(projectPath) {
+  const private_memories = loadMemories(projectPath, false)
+  const team_memories = loadMemories(projectPath, true)
+  const all = [...private_memories, ...team_memories]
+
+  if (all.length === 0) {
+    console.log('No memories to inject.')
+    return
+  }
+
+  let content = '# MEMCORE — Project Memory\n\n'
+  content += '_Auto-generated by [memcore](https://github.com/your-username/memcore). Do not edit manually._\n\n'
+
+  const byType = { user: [], feedback: [], project: [], reference: [] }
+  for (const m of all) {
+    if (byType[m.type]) byType[m.type].push(m)
+  }
+
+  if (byType.project.length > 0) {
+    content += '## Project Context\n\n'
+    for (const m of byType.project) {
+      content += '### ' + m.name + '\n'
+      content += m.content + '\n\n'
+    }
+  }
+
+  if (byType.feedback.length > 0) {
+    content += '## How to work with me\n\n'
+    for (const m of byType.feedback) {
+      content += '### ' + m.name + '\n'
+      content += m.content + '\n\n'
+    }
+  }
+
+  if (byType.user.length > 0) {
+    content += '## About the developer\n\n'
+    for (const m of byType.user) {
+      content += '### ' + m.name + '\n'
+      content += m.content + '\n\n'
+    }
+  }
+
+  if (byType.reference.length > 0) {
+    content += '## References\n\n'
+    for (const m of byType.reference) {
+      content += '### ' + m.name + '\n'
+      content += m.content + '\n\n'
+    }
+  }
+
+  const claudeMd = path.join(projectPath, 'CLAUDE.md')
+  fs.writeFileSync(claudeMd, content, 'utf-8')
+  console.log('✓ Injected ' + all.length + ' memories into CLAUDE.md')
+  console.log('  Claude Code will now read this automatically.')
+}

package/src/core/memory-store.ts

@@ -0,0 +1,58 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import matter from 'gray-matter'
+import { parseMemoryType } from './memory-types.js'
+
+const MEMCORE_DIR = '.memcore'
+
+export function getMemoryDir(projectPath) {
+  return path.join(projectPath, MEMCORE_DIR)
+}
+
+export function initMemoryDir(projectPath) {
+  const memDir = getMemoryDir(projectPath)
+  if (!fs.existsSync(memDir)) {
+    fs.mkdirSync(memDir, { recursive: true })
+    fs.mkdirSync(path.join(memDir, 'team'), { recursive: true })
+    console.log('✓ Memcore initialized at ' + memDir)
+  } else {
+    console.log('✓ Memcore already initialized')
+  }
+}
+
+export function saveMemory(projectPath, name, type, content, description, isTeam) {
+  const memDir = getMemoryDir(projectPath)
+  const folder = isTeam ? path.join(memDir, 'team') : memDir
+  const id = Date.now() + '-' + name.toLowerCase().replace(/\s+/g, '-')
+  const filePath = path.join(folder, id + '.md')
+  const fileContent = matter.stringify(content, { name, description, type, createdAt: new Date().toISOString(), isTeam })
+  fs.writeFileSync(filePath, fileContent, 'utf-8')
+  return { id, name, description, type, content, createdAt: new Date(), updatedAt: new Date(), projectPath, isTeam }
+}
+
+export function loadMemories(projectPath, isTeam) {
+  const memDir = getMemoryDir(projectPath)
+  const folder = isTeam ? path.join(memDir, 'team') : memDir
+  if (!fs.existsSync(folder)) return []
+  const files = fs.readdirSync(folder).filter(f => f.endsWith('.md'))
+  return files.map(file => {
+    const raw = fs.readFileSync(path.join(folder, file), 'utf-8')
+    const { data, content } = matter(raw)
+    return { id: file.replace('.md', ''), name: data.name ?? file, description: data.description ?? '', type: parseMemoryType(data.type) ?? 'project', content: content.trim(), createdAt: new Date(data.createdAt ?? Date.now()), updatedAt: new Date(data.updatedAt ?? Date.now()), projectPath, isTeam: data.isTeam ?? false }
+  })
+}
+
+export function deleteMemory(projectPath, id) {
+  const memDir = getMemoryDir(projectPath)
+  const candidates = [path.join(memDir, id + '.md'), path.join(memDir, 'team', id + '.md')]
+  for (const p of candidates) {
+    if (fs.existsSync(p)) { fs.unlinkSync(p); return true }
+  }
+  return false
+}
+
+export function searchMemories(projectPath, query) {
+  const all = [...loadMemories(projectPath, false), ...loadMemories(projectPath, true)]
+  const q = query.toLowerCase()
+  return all.filter(m => m.name.toLowerCase().includes(q) || m.description.toLowerCase().includes(q) || m.content.toLowerCase().includes(q))
+}

package/src/core/memory-types.ts

@@ -0,0 +1,6 @@
+export const MEMORY_TYPES = ['user', 'feedback', 'project', 'reference']
+
+export function parseMemoryType(raw) {
+  if (typeof raw !== 'string') return undefined
+  return MEMORY_TYPES.find(t => t === raw)
+}

package/src/index.ts

@@ -0,0 +1,68 @@
+import { loadMemories, saveMemory, searchMemories, initMemoryDir } from './core/memory-store.js'
+import { injectMemories } from './core/injector.js'
+import { injectCursor, injectChatGPT } from './core/connectors.js'
+import { exportToSync, importFromSync } from './sync/teamSync.js'
+import { exportToSchema, importFromSchema } from './sync/protocol.js'
+
+export class Memcore {
+  private projectPath: string
+
+  constructor(projectPath: string = process.cwd()) {
+    this.projectPath = projectPath
+    initMemoryDir(projectPath)
+  }
+
+  getContext(): string {
+    const memories = [...loadMemories(this.projectPath, false), ...loadMemories(this.projectPath, true)]
+    if (memories.length === 0) return ''
+    let context = 'PROJECT CONTEXT:\n\n'
+    for (const m of memories) {
+      context += '- ' + m.name + ': ' + m.content + '\n'
+    }
+    return context
+  }
+
+  getMemories() {
+    return [...loadMemories(this.projectPath, false), ...loadMemories(this.projectPath, true)]
+  }
+
+  save(name: string, type: string, content: string, description: string = '', team: boolean = false) {
+    return saveMemory(this.projectPath, name, type as any, content, description, team)
+  }
+
+  search(query: string) {
+    return searchMemories(this.projectPath, query)
+  }
+
+  inject() {
+    injectMemories(this.projectPath)
+  }
+
+  injectCursor() {
+    injectCursor(this.projectPath)
+  }
+
+  injectChatGPT() {
+    injectChatGPT(this.projectPath)
+  }
+
+  push() {
+    return exportToSync(this.projectPath)
+  }
+
+  pull() {
+    return importFromSync(this.projectPath)
+  }
+
+  export() {
+    const memories = this.getMemories()
+    exportToSchema(this.projectPath, memories)
+  }
+
+  import() {
+    return importFromSchema(this.projectPath)
+  }
+}
+
+export const memcore = new Memcore()
+export { loadMemories, saveMemory, searchMemories, initMemoryDir }

package/src/sync/protocol.ts

@@ -0,0 +1,69 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { saveMemory, initMemoryDir } from '../core/memory-store.js'
+
+export type MemcoreSchema = {
+  version: string
+  project: { name: string; description: string }
+  memories: { name: string; type: string; description: string; content: string }[]
+  rules: string[]
+  references: Record<string, string>
+  integrations: Record<string, boolean>
+}
+
+export function validateSchema(data: any): boolean {
+  if (!data.version) { console.error('Missing: version'); return false }
+  if (!data.project?.name) { console.error('Missing: project.name'); return false }
+  if (!Array.isArray(data.memories)) { console.error('Missing: memories[]'); return false }
+  return true
+}
+
+export function importFromSchema(projectPath: string): number {
+  const schemaPath = path.join(projectPath, 'memcore.json')
+  if (!fs.existsSync(schemaPath)) {
+    console.error('No memcore.json found in this project.')
+    return 0
+  }
+
+  const raw = fs.readFileSync(schemaPath, 'utf-8')
+  const data: MemcoreSchema = JSON.parse(raw)
+
+  if (!validateSchema(data)) return 0
+
+  initMemoryDir(projectPath)
+  let imported = 0
+
+  for (const m of data.memories) {
+    saveMemory(projectPath, m.name, m.type as any, m.content, m.description, true)
+    imported++
+  }
+
+  for (const rule of data.rules ?? []) {
+    saveMemory(projectPath, rule, 'feedback', rule, 'project rule', true)
+    imported++
+  }
+
+  for (const [key, value] of Object.entries(data.references ?? {})) {
+    saveMemory(projectPath, key, 'reference', value, 'external reference', true)
+    imported++
+  }
+
+  return imported
+}
+
+export function exportToSchema(projectPath: string, memories: any[]): void {
+  const schema: MemcoreSchema = {
+    version: '1.0',
+    project: { name: path.basename(projectPath), description: '' },
+    memories: memories.filter(m => m.type === 'project' || m.type === 'user').map(m => ({
+      name: m.name, type: m.type, description: m.description, content: m.content
+    })),
+    rules: memories.filter(m => m.type === 'feedback').map(m => m.content),
+    references: Object.fromEntries(memories.filter(m => m.type === 'reference').map(m => [m.name, m.content])),
+    integrations: { claude: true, cursor: true, chatgpt: true }
+  }
+
+  const schemaPath = path.join(projectPath, 'memcore.json')
+  fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), 'utf-8')
+  console.log('✓ memcore.json created — this is your portable memory protocol file.')
+}

package/src/sync/teamSync.ts

@@ -0,0 +1,80 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as crypto from 'crypto'
+import { loadMemories, saveMemory } from '../core/memory-store.js'
+
+const SYNC_FILE = 'memcore-sync.json'
+
+export type SyncMemory = {
+  id: string
+  name: string
+  type: string
+  description: string
+  content: string
+  author: string
+  createdAt: string
+  hash: string
+}
+
+export type SyncManifest = {
+  teamId: string
+  version: number
+  updatedAt: string
+  memories: SyncMemory[]
+}
+
+function hashContent(content: string): string {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 8)
+}
+
+function getAuthor(): string {
+  return process.env.USERNAME || process.env.USER || 'unknown'
+}
+
+export function exportToSync(projectPath: string): SyncManifest {
+  const memories = loadMemories(projectPath, false)
+  const teamMemories = loadMemories(projectPath, true)
+  const all = [...memories, ...teamMemories]
+
+  const manifest: SyncManifest = {
+    teamId: path.basename(projectPath),
+    version: Date.now(),
+    updatedAt: new Date().toISOString(),
+    memories: all.map(m => ({
+      id: m.id,
+      name: m.name,
+      type: m.type,
+      description: m.description,
+      content: m.content,
+      author: getAuthor(),
+      createdAt: m.createdAt.toISOString(),
+      hash: hashContent(m.content),
+    }))
+  }
+
+  const syncPath = path.join(projectPath, SYNC_FILE)
+  fs.writeFileSync(syncPath, JSON.stringify(manifest, null, 2), 'utf-8')
+  return manifest
+}
+
+export function importFromSync(projectPath: string): number {
+  const syncPath = path.join(projectPath, SYNC_FILE)
+  if (!fs.existsSync(syncPath)) {
+    console.log('No memcore-sync.json found. Ask your team to run: memcore sync push')
+    return 0
+  }
+
+  const manifest: SyncManifest = JSON.parse(fs.readFileSync(syncPath, 'utf-8'))
+  const existing = loadMemories(projectPath, true)
+  const existingHashes = new Set(existing.map(m => hashContent(m.content)))
+
+  let imported = 0
+  for (const m of manifest.memories) {
+    if (!existingHashes.has(m.hash)) {
+      saveMemory(projectPath, m.name, m.type as any, m.content, m.description, true)
+      imported++
+    }
+  }
+
+  return imported
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    // "rootDir": "./src",
+    // "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}