neuronlayer 0.1.0

package/src/types/index.ts

@@ -0,0 +1,222 @@
+// Core types for MemoryLayer
+
+export interface Position {
+  line: number;
+  column: number;
+}
+
+export interface ActiveFile {
+  path: string;
+  content: string;
+  cursorPosition?: Position;
+  language: string;
+}
+
+export interface Session {
+  startTime: Date;
+  filesViewed: string[];
+  currentGoal?: string;
+}
+
+export interface ContextSnippet {
+  file: string;
+  content: string;
+  timestamp: Date;
+}
+
+export interface Tier1Context {
+  activeFile: ActiveFile | null;
+  recentDecisions: Decision[];
+  session: Session;
+  immediateContext: ContextSnippet[];
+}
+
+export interface Decision {
+  id: string;
+  title: string;
+  description: string;
+  files: string[];
+  tags: string[];
+  createdAt: Date;
+  // Phase 4: Team features
+  author?: string;
+  status?: 'proposed' | 'accepted' | 'deprecated' | 'superseded';
+  supersededBy?: string;
+}
+
+export interface SearchResult {
+  file: string;
+  preview: string;
+  similarity: number;
+  lineStart: number;
+  lineEnd: number;
+  lastModified: number;
+  score?: number;
+}
+
+export interface FileMetadata {
+  id: number;
+  path: string;
+  contentHash: string;
+  preview: string;
+  language: string;
+  sizeBytes: number;
+  lastModified: number;
+  indexedAt: number;
+}
+
+export interface AssemblyOptions {
+  maxTokens?: number;
+  currentFile?: string;
+}
+
+export interface AssembledContext {
+  context: string;
+  sources: string[];
+  tokenCount: number;
+  decisions: Decision[];
+}
+
+export interface ProjectSummary {
+  name: string;
+  description: string;
+  languages: string[];
+  totalFiles: number;
+  totalLines: number;
+  keyDirectories: string[];
+  recentDecisions: Decision[];
+  dependencies: string[];
+  architectureNotes: string;
+}
+
+export interface ContextParts {
+  working: {
+    activeFile: ActiveFile | null;
+  };
+  relevant: SearchResult[];
+  archive: string[];
+  decisions: Decision[];
+}
+
+export interface TokenBudgetAllocation {
+  tier1: number;
+  tier2: number;
+  tier3: number;
+  decisions: number;
+}
+
+export interface DependencyRelation {
+  sourceFileId: number;
+  targetFileId: number;
+  relationship: 'imports' | 'exports' | 'calls' | 'type_reference';
+}
+
+export interface IndexingProgress {
+  total: number;
+  indexed: number;
+  current?: string;
+}
+
+export interface MemoryLayerConfig {
+  projectPath: string;
+  dataDir: string;
+  maxTokens: number;
+  embeddingModel: string;
+  watchIgnore: string[];
+}
+
+// Phase 2: AST & Symbol types
+
+export type SymbolKind = 'function' | 'class' | 'interface' | 'type' | 'variable' | 'method' | 'property' | 'enum' | 'constant';
+
+export interface CodeSymbol {
+  id?: number;
+  fileId: number;
+  filePath: string;
+  kind: SymbolKind;
+  name: string;
+  signature?: string;
+  docstring?: string;
+  lineStart: number;
+  lineEnd: number;
+  exported: boolean;
+}
+
+export interface Import {
+  fileId: number;
+  filePath: string;
+  importedFrom: string;       // The module/file being imported
+  importedSymbols: string[];  // What's being imported (* for all)
+  isDefault: boolean;
+  isNamespace: boolean;
+  lineNumber: number;
+}
+
+export interface Export {
+  fileId: number;
+  filePath: string;
+  exportedName: string;
+  localName?: string;         // If renamed: export { foo as bar }
+  isDefault: boolean;
+  lineNumber: number;
+}
+
+export interface FileDependency {
+  sourceFile: string;
+  targetFile: string;
+  imports: string[];          // What symbols are imported
+}
+
+export interface SymbolSearchResult {
+  symbol: CodeSymbol;
+  file: string;
+  preview: string;
+  relevance: number;
+}
+
+// Phase 5: Active Feature Context types
+
+export interface FeatureFile {
+  path: string;
+  lastTouched: Date;
+  touchCount: number;
+  recentLines: number[];
+}
+
+export interface FeatureChange {
+  file: string;
+  timestamp: Date;
+  diff: string;
+  linesChanged: number[];
+}
+
+export interface FeatureQuery {
+  query: string;
+  timestamp: Date;
+  filesUsed: string[];
+}
+
+export interface ActiveFeatureContext {
+  id: string;
+  name: string;
+  files: FeatureFile[];
+  changes: FeatureChange[];
+  queries: FeatureQuery[];
+  startedAt: Date;
+  lastActiveAt: Date;
+  status: 'active' | 'paused' | 'completed';
+}
+
+export interface HotContext {
+  files: Array<{
+    path: string;
+    content: string | null;
+    touchCount: number;
+  }>;
+  changes: FeatureChange[];
+  queries: FeatureQuery[];
+  summary: string;
+}
+
+// Re-export documentation types
+export * from './documentation.js';

package/src/utils/config.ts

@@ -0,0 +1,193 @@
+import { join, resolve } from 'path';
+import type { MemoryLayerConfig } from '../types/index.js';
+
+export function getDefaultConfig(projectPath: string): MemoryLayerConfig {
+  const normalizedPath = resolve(projectPath);
+
+  return {
+    projectPath: normalizedPath,
+    // Store in project directory (standard practice like .git/, .vscode/)
+    dataDir: join(normalizedPath, '.memorylayer'),
+    maxTokens: 6000,
+    embeddingModel: 'Xenova/all-MiniLM-L6-v2', // Fallback model, faster and smaller
+    watchIgnore: [
+      // ===== MemoryLayer =====
+      '**/.memorylayer/**',
+
+      // ===== Version Control =====
+      '**/.git/**',
+      '**/.svn/**',
+      '**/.hg/**',
+
+      // ===== Node.js / JavaScript =====
+      '**/node_modules/**',
+      '**/bower_components/**',
+      '**/.npm/**',
+      '**/.yarn/**',
+      '**/.pnp.*',
+
+      // ===== Build Outputs =====
+      '**/dist/**',
+      '**/build/**',
+      '**/out/**',
+      '**/output/**',
+      '**/_build/**',
+      '**/public/build/**',
+
+      // ===== Next.js =====
+      '**/.next/**',
+      '**/.vercel/**',
+
+      // ===== Nuxt.js =====
+      '**/.nuxt/**',
+      '**/.output/**',
+
+      // ===== Vite / Rollup / Parcel =====
+      '**/.vite/**',
+      '**/.cache/**',
+      '**/.parcel-cache/**',
+      '**/.turbo/**',
+      '**/.svelte-kit/**',
+
+      // ===== Python =====
+      '**/.venv/**',
+      '**/venv/**',
+      '**/env/**',
+      '**/.env/**',
+      '**/virtualenv/**',
+      '**/__pycache__/**',
+      '**/*.pyc',
+      '**/*.pyo',
+      '**/*.pyd',
+      '**/.Python',
+      '**/*.egg-info/**',
+      '**/*.egg/**',
+      '**/eggs/**',
+      '**/.eggs/**',
+      '**/pip-wheel-metadata/**',
+      '**/.pytest_cache/**',
+      '**/.mypy_cache/**',
+      '**/.ruff_cache/**',
+      '**/.tox/**',
+      '**/.nox/**',
+      '**/htmlcov/**',
+      '**/.coverage',
+      '**/.hypothesis/**',
+
+      // ===== Django =====
+      '**/staticfiles/**',
+      '**/static_collected/**',
+      '**/media/**',
+      '**/*.sqlite3',
+      '**/db.sqlite3',
+
+      // ===== FastAPI / Flask =====
+      '**/instance/**',
+
+      // ===== Ruby / Rails =====
+      '**/vendor/bundle/**',
+      '**/.bundle/**',
+      '**/tmp/**',
+      '**/log/**',
+
+      // ===== Go =====
+      '**/vendor/**',
+
+      // ===== Rust =====
+      '**/target/**',
+      '**/*.rlib',
+
+      // ===== Java / Kotlin / Gradle / Maven =====
+      '**/.gradle/**',
+      '**/.mvn/**',
+      '**/target/**',
+      '**/*.class',
+      '**/*.jar',
+      '**/*.war',
+
+      // ===== .NET / C# =====
+      '**/bin/**',
+      '**/obj/**',
+      '**/packages/**',
+      '**/*.dll',
+      '**/*.exe',
+
+      // ===== iOS / macOS =====
+      '**/Pods/**',
+      '**/.build/**',
+      '**/DerivedData/**',
+      '**/*.xcworkspace/**',
+
+      // ===== Android =====
+      '**/.gradle/**',
+      '**/local.properties',
+
+      // ===== IDE / Editor =====
+      '**/.idea/**',
+      '**/.vscode/**',
+      '**/*.swp',
+      '**/*.swo',
+      '**/*.sublime-*',
+      '**/.project',
+      '**/.classpath',
+      '**/.settings/**',
+
+      // ===== Testing / Coverage =====
+      '**/coverage/**',
+      '**/.nyc_output/**',
+      '**/test-results/**',
+      '**/jest-cache/**',
+
+      // ===== Misc Generated / Cache =====
+      '**/.DS_Store',
+      '**/Thumbs.db',
+      '**/*.min.js',
+      '**/*.min.css',
+      '**/*.map',
+      '**/*.chunk.js',
+      '**/*.bundle.js',
+
+      // ===== Lock Files =====
+      '**/package-lock.json',
+      '**/yarn.lock',
+      '**/pnpm-lock.yaml',
+      '**/Pipfile.lock',
+      '**/poetry.lock',
+      '**/Gemfile.lock',
+      '**/Cargo.lock',
+      '**/composer.lock',
+      '**/go.sum',
+
+      // ===== Environment / Secrets =====
+      '**/.env',
+      '**/.env.*',
+      '**/*.env',
+      '**/.envrc',
+      '**/secrets/**',
+      '**/*.pem',
+      '**/*.key',
+
+      // ===== Logs / Temp =====
+      '**/*.log',
+      '**/logs/**',
+      '**/*.tmp',
+      '**/*.temp',
+      '**/temp/**'
+    ]
+  };
+}
+
+export function parseArgs(args: string[]): { projectPath: string } {
+  let projectPath = process.cwd();
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const nextArg = args[i + 1];
+    if (arg === '--project' && nextArg) {
+      projectPath = nextArg;
+      break;
+    }
+  }
+
+  return { projectPath: resolve(projectPath) };
+}

package/src/utils/files.ts

@@ -0,0 +1,117 @@
+import { createHash } from 'crypto';
+import { extname } from 'path';
+
+const LANGUAGE_MAP: Record<string, string> = {
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.mjs': 'javascript',
+  '.cjs': 'javascript',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.java': 'java',
+  '.kt': 'kotlin',
+  '.scala': 'scala',
+  '.cs': 'csharp',
+  '.cpp': 'cpp',
+  '.cc': 'cpp',
+  '.c': 'c',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.m': 'objectivec',
+  '.mm': 'objectivec',
+  '.vue': 'vue',
+  '.svelte': 'svelte',
+  '.astro': 'astro',
+  '.md': 'markdown',
+  '.mdx': 'mdx',
+  '.json': 'json',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.toml': 'toml',
+  '.xml': 'xml',
+  '.html': 'html',
+  '.htm': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.sass': 'sass',
+  '.less': 'less',
+  '.sql': 'sql',
+  '.sh': 'bash',
+  '.bash': 'bash',
+  '.zsh': 'zsh',
+  '.fish': 'fish',
+  '.ps1': 'powershell',
+  '.dockerfile': 'dockerfile',
+  '.prisma': 'prisma',
+  '.graphql': 'graphql',
+  '.gql': 'graphql',
+  '.proto': 'protobuf',
+  '.tf': 'terraform',
+  '.lua': 'lua',
+  '.r': 'r',
+  '.R': 'r',
+  '.jl': 'julia',
+  '.ex': 'elixir',
+  '.exs': 'elixir',
+  '.erl': 'erlang',
+  '.hrl': 'erlang',
+  '.clj': 'clojure',
+  '.cljs': 'clojure',
+  '.cljc': 'clojure',
+  '.hs': 'haskell',
+  '.ml': 'ocaml',
+  '.mli': 'ocaml',
+  '.fs': 'fsharp',
+  '.fsi': 'fsharp',
+  '.fsx': 'fsharp',
+  '.dart': 'dart',
+  '.nim': 'nim',
+  '.zig': 'zig',
+  '.v': 'v',
+  '.odin': 'odin',
+};
+
+const CODE_EXTENSIONS = new Set(Object.keys(LANGUAGE_MAP));
+
+export function detectLanguage(filePath: string): string {
+  const ext = extname(filePath).toLowerCase();
+
+  // Handle special filenames
+  const filename = filePath.split(/[/\\]/).pop()?.toLowerCase() || '';
+  if (filename === 'dockerfile') return 'dockerfile';
+  if (filename === 'makefile') return 'makefile';
+  if (filename === 'cmakelists.txt') return 'cmake';
+
+  return LANGUAGE_MAP[ext] || 'plaintext';
+}
+
+export function isCodeFile(filePath: string): boolean {
+  const ext = extname(filePath).toLowerCase();
+  const filename = filePath.split(/[/\\]/).pop()?.toLowerCase() || '';
+
+  return CODE_EXTENSIONS.has(ext) ||
+    filename === 'dockerfile' ||
+    filename === 'makefile';
+}
+
+export function hashContent(content: string): string {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+export function getPreview(content: string, maxLength: number = 1000): string {
+  if (content.length <= maxLength) {
+    return content;
+  }
+  return content.slice(0, maxLength) + '\n... [truncated]';
+}
+
+export function countLines(content: string): number {
+  if (!content) return 0;
+  return content.split('\n').length;
+}

package/src/utils/time.ts

@@ -0,0 +1,37 @@
+/**
+ * Time utilities
+ */
+
+/**
+ * Format a date as a human-readable "time ago" string
+ */
+export function formatTimeAgo(date: Date): string {
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / (1000 * 60));
+  const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  const diffWeeks = Math.floor(diffDays / 7);
+  const diffMonths = Math.floor(diffDays / 30);
+
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins} minute${diffMins > 1 ? 's' : ''} ago`;
+  if (diffHours < 24) return `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+  if (diffDays === 1) return 'yesterday';
+  if (diffDays < 7) return `${diffDays} days ago`;
+  if (diffWeeks === 1) return '1 week ago';
+  if (diffWeeks < 4) return `${diffWeeks} weeks ago`;
+  if (diffMonths === 1) return '1 month ago';
+  if (diffMonths < 12) return `${diffMonths} months ago`;
+
+  return date.toLocaleDateString();
+}
+
+/**
+ * Format a date as "time ago" with an action and file context
+ */
+export function formatTimeAgoWithContext(date: Date, action: string, file: string): string {
+  const timeAgo = formatTimeAgo(date);
+  const fileName = file.split(/[/\\]/).pop() || file;
+  return `You ${action} in ${fileName} ${timeAgo === 'just now' ? 'just now' : timeAgo}`;
+}

package/src/utils/tokens.ts

@@ -0,0 +1,52 @@
+// Simple token estimation
+// For more accurate counting, consider using tiktoken or similar
+// This approximation is sufficient for budget management
+
+const AVG_CHARS_PER_TOKEN = 4;
+
+export function estimateTokens(text: string): number {
+  if (!text) return 0;
+  // Rough approximation: 1 token ≈ 4 characters for English/code
+  // This is a simplification but works well enough for budgeting
+  return Math.ceil(text.length / AVG_CHARS_PER_TOKEN);
+}
+
+export class TokenBudget {
+  private total: number;
+  private allocations: Map<string, number> = new Map();
+
+  constructor(total: number) {
+    this.total = total;
+  }
+
+  used(): number {
+    let sum = 0;
+    for (const tokens of this.allocations.values()) {
+      sum += tokens;
+    }
+    return sum;
+  }
+
+  remaining(): number {
+    return this.total - this.used();
+  }
+
+  canFit(text: string): boolean {
+    return estimateTokens(text) <= this.remaining();
+  }
+
+  allocate(text: string, category: string): boolean {
+    const tokens = estimateTokens(text);
+    if (tokens > this.remaining()) {
+      return false;
+    }
+
+    const current = this.allocations.get(category) || 0;
+    this.allocations.set(category, current + tokens);
+    return true;
+  }
+
+  getAllocations(): Record<string, number> {
+    return Object.fromEntries(this.allocations);
+  }
+}