@principal-ai/codebase-composition 0.1.0

package/src/types/layer-types.ts

@@ -0,0 +1,264 @@
+/**
+ * Core layer type system
+ * Minimal types needed for FileTypeLayerModule
+ */
+
+// Base file selection types
+export interface FilePattern {
+  type: 'glob' | 'regex' | 'exact';
+  pattern: string;
+  description?: string;
+}
+
+export interface FileSet {
+  id: string;
+  name: string;
+  description?: string;
+  patterns: FilePattern[];
+  // Results after pattern matching
+  matchedFiles?: string[];
+  fileCount?: number;
+}
+
+// Base layer that all other layers extend
+export interface BaseLayer {
+  id: string;
+  name: string;
+  type: string;
+  enabled: boolean;
+
+  // Workspace boundary information
+  workspaceId?: string;
+  workspaceRoot?: string;
+
+  // How this layer was derived
+  derivedFrom: {
+    fileSets: FileSet[];
+    derivationType:
+      | 'presence'
+      | 'content'
+      | 'aggregation'
+      | 'relationship'
+      | 'content+pattern'
+      | 'content+presence';
+    description: string;
+
+    // For content-derived layers
+    contentExtraction?: {
+      method: 'parse' | 'grep' | 'ast' | 'custom';
+
+      // For parsed content (JSON, YAML, etc)
+      parser?: {
+        format: 'json' | 'yaml' | 'toml' | 'xml';
+        paths?: string[]; // JSONPath, dot notation, etc
+        schema?: unknown; // Optional schema validation
+      };
+
+      // For pattern matching (grep)
+      patterns?: {
+        regex: string;
+        captureGroups?: string[];
+        multiline?: boolean;
+      }[];
+
+      // For AST-based extraction
+      ast?: {
+        language: string;
+        nodeTypes?: string[];
+        visitor?: string; // Function name to visit nodes
+      };
+    };
+  };
+
+  // Dependencies on other layers
+  dependsOn?: string[]; // layer IDs this layer depends on
+  enhances?: string; // layer ID this layer enhances/augments
+
+  // Visual properties
+  color?: string;
+  icon?: string;
+  pillar?: 'validation' | 'dataFlow' | 'foundationHealth' | 'viewLayers';
+}
+
+// Package command structure
+export interface PackageCommand {
+  name: string; // Display name (e.g., "test", "build")
+  command: string; // Full command to run (e.g., "npm run test")
+  description?: string; // Optional tooltip
+  type?: 'script' | 'standard'; // From manifest vs standard tool command
+  workingDirectory?: string; // Where to run the command (package path)
+}
+
+// Config file information
+export interface ConfigFile {
+  path: string;
+  exists: boolean;
+  type: 'json' | 'yaml' | 'toml' | 'js' | 'ts' | 'ini' | 'custom';
+  isInline?: boolean; // For configs inside package.json
+  inlineField?: string; // e.g., "eslintConfig" in package.json
+}
+
+// Filter layer - special type for exclusion rules
+export interface FileSystemFilterLayer extends BaseLayer {
+  type: 'filter';
+
+  filterData: {
+    purpose: 'performance' | 'security' | 'relevance';
+    scope: 'directory' | 'workspace'; // Removed 'global' - everything is directory-scoped
+    sourceDirectory: string; // Required: The directory this filter originates from ('' for root)
+
+    // What to exclude
+    excludedPatterns: FilePattern[];
+
+    // Statistics
+    stats?: {
+      totalFiltered: number;
+      bytesExcluded: number;
+      largestExcluded?: string;
+    };
+  };
+}
+
+// Package layer - derived from package.json presence
+export interface PackageLayer extends BaseLayer {
+  type: 'package' | 'node' | 'python' | 'cargo' | 'go';
+
+  // Package-specific data
+  packageData: {
+    name: string;
+    version?: string;
+    path: string;
+    packageManager: 'npm' | 'yarn' | 'pnpm' | 'pip' | 'poetry' | 'pipenv' | 'cargo' | 'unknown';
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    peerDependencies: Record<string, string>;
+
+    // Relationships
+    isMonorepoRoot: boolean;
+    isWorkspace: boolean;
+    parentPackage?: string;
+
+    // Available commands for this package
+    availableCommands?: PackageCommand[];
+  };
+
+  // Associated file sets (not part of derivation, but related)
+  lockFiles?: FileSet;
+
+  // Configuration files detected for this package
+  configFiles?: {
+    // JavaScript/TypeScript tool configs
+    knip?: ConfigFile;
+    eslint?: ConfigFile;
+    prettier?: ConfigFile;
+    typescript?: ConfigFile;
+    jest?: ConfigFile;
+    vitest?: ConfigFile;
+    webpack?: ConfigFile;
+    vite?: ConfigFile;
+    rollup?: ConfigFile;
+    babel?: ConfigFile;
+
+    // Python tool configs
+    pytest?: ConfigFile;
+    flake8?: ConfigFile;
+    mypy?: ConfigFile;
+    black?: ConfigFile;
+    ruff?: ConfigFile;
+    pylint?: ConfigFile;
+
+    // Rust tool configs
+    rustfmt?: ConfigFile;
+    clippy?: ConfigFile;
+
+    // General configs
+    dockerfile?: ConfigFile;
+    gitignore?: ConfigFile;
+    editorconfig?: ConfigFile;
+
+    // Allow for dynamic tool configs not in the predefined list
+    [key: string]: ConfigFile | undefined;
+  };
+
+  // Primary documentation folder detected for this package
+  docsFolder?: string;
+}
+
+// Dependency layer - derived from package dependencies
+export interface DependencyLayer extends BaseLayer {
+  type: 'dependency';
+
+  dependencyData: {
+    name: string;
+    version: string;
+    isDev: boolean;
+    isPeer: boolean;
+    declaredIn: string[]; // Package layer IDs where this dependency is declared
+    sourceFile: FileSet; // Package.json files declaring this dependency
+  };
+}
+
+// Framework layer - detected from specific dependencies
+export interface FrameworkLayer extends BaseLayer {
+  type: 'framework';
+
+  frameworkData: {
+    name: string;
+    category: 'ui' | 'backend' | 'testing' | 'build' | 'styling';
+    usedBy: string[]; // Package names using this framework
+  };
+}
+
+// Type extraction types
+export interface ExtractedType {
+  name: string;
+  kind: 'interface' | 'type' | 'class' | 'enum' | 'function';
+  text: string; // Full source text of the declaration
+  fileName: string; // Relative path from package root
+  isExported: boolean;
+  jsDoc?: string; // JSDoc comment if present
+}
+
+export interface PackageTypes {
+  packagePath: string;
+  packageName: string;
+  types: ExtractedType[];
+  exports: {
+    named: string[];
+    default?: string;
+  };
+}
+
+// Type extraction options
+export interface TypeExtractionOptions {
+  includeTests?: boolean;
+  includeInternal?: boolean;
+}
+
+// Type extractor abstraction
+export interface TypeExtractor {
+  name: string;
+  canHandle(packagePath: string, fileExtensions: string[]): boolean;
+  extractTypes(packagePath: string, options?: TypeExtractionOptions): Promise<PackageTypes>;
+  generateDefinitionFile?(packageTypes: PackageTypes): Promise<string>;
+}
+
+// Type definition layer - derived from TypeScript analysis
+export interface TypeDefinitionLayer extends BaseLayer {
+  type: 'type-definitions';
+
+  typeData: {
+    sourcePackageId: string; // PackageLayer ID this was extracted from
+    extractedTypes: ExtractedType[];
+    exports: {
+      named: string[];
+      default?: string;
+    };
+    hasTypeScript: boolean; // Whether the source package contains TypeScript files
+    definitionFile?: string; // Path to generated .d.ts file if created
+    extractionOptions?: {
+      includeTests: boolean;
+      includeInternal: boolean;
+    };
+  };
+}

package/src/types/version-control-layer.ts

@@ -0,0 +1,87 @@
+import { BaseLayer, FilePattern } from './layer-types';
+
+/**
+ * Version Control Layer - provides VCS-specific functionality
+ * including ignore patterns, tracked files, and VCS metadata
+ */
+export interface VersionControlLayer extends BaseLayer {
+  type: 'version-control';
+
+  vcsData: {
+    // Type of version control system
+    system: 'git' | 'svn' | 'mercurial' | 'perforce' | 'unknown';
+
+    // Root of the repository
+    repositoryRoot: string;
+
+    // Remote repository information
+    remotes?: Array<{
+      name: string;
+      url: string;
+      type: 'fetch' | 'push' | 'both';
+    }>;
+
+    // Current branch/revision
+    currentBranch?: string;
+    currentRevision?: string;
+
+    // Ignore patterns from VCS ignore files
+    ignorePatterns: VersionControlIgnorePattern[];
+
+    // Status information (optional, can be expensive to compute)
+    status?: {
+      trackedFiles?: string[];
+      untrackedFiles?: string[];
+      modifiedFiles?: string[];
+      stagedFiles?: string[];
+      conflictedFiles?: string[];
+    };
+  };
+}
+
+/**
+ * Represents an ignore pattern from version control
+ */
+export interface VersionControlIgnorePattern extends FilePattern {
+  // Source of the pattern (which .gitignore file, etc.)
+  source: string;
+
+  // Whether this pattern is negated (! prefix in gitignore)
+  negated?: boolean;
+
+  // Whether this pattern only applies to directories
+  directoryOnly?: boolean;
+
+  // Relative path from repository root where this pattern applies
+  scope?: string;
+}
+
+/**
+ * Interface for version control providers
+ */
+export interface VersionControlProvider {
+  // Detect if a directory is under version control
+  detect(directoryPath: string): Promise<boolean>;
+
+  // Get the repository root
+  getRepositoryRoot(directoryPath: string): Promise<string | null>;
+
+  // Create a version control layer for the repository
+  createLayer(repositoryRoot: string): Promise<VersionControlLayer>;
+
+  // Extract ignore patterns from the repository
+  extractIgnorePatterns(repositoryRoot: string): Promise<VersionControlIgnorePattern[]>;
+
+  // Get current branch/revision info
+  getCurrentBranch(repositoryRoot: string): Promise<string | null>;
+  getCurrentRevision(repositoryPath: string): Promise<string | null>;
+
+  // Get remote information
+  getRemotes(repositoryRoot: string): Promise<
+    Array<{
+      name: string;
+      url: string;
+      type: 'fetch' | 'push' | 'both';
+    }>
+  >;
+}

package/src/types/workspace-boundaries.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimal workspace boundary type for backwards compatibility
+ * This is a stub - the full implementation can be added later if needed
+ */
+
+export interface WorkspaceBoundary {
+  id: string;
+  name: string;
+  rootPath?: string;
+  packageJsonPath: string;
+  isRoot: boolean;
+  packageData?: {
+    name?: string;
+    version?: string;
+    workspaces?: string[];
+  };
+}