spec-agent 1.0.3

package/src/types.ts

@@ -0,0 +1,161 @@
+// Core types for spec-agent
+
+export interface Chunk {
+  id: number;
+  sourceFiles: string[];
+  size: number;
+  content?: string;
+  contentPath?: string;
+  startLine?: number;
+  endLine?: number;
+}
+
+export interface Manifest {
+  version: string;
+  createdAt: string;
+  totalFiles: number;
+  totalSize: number;
+  chunkSize: number;
+  chunks: Chunk[];
+}
+
+export interface Feature {
+  id: string;
+  name: string;
+  description: string;
+  priority: 'P0' | 'P1' | 'P2' | 'P3';
+  dependencies: string[];
+  sourceChunk: number;
+}
+
+export interface DataModel {
+  name: string;
+  fields: string[];
+  relationships: string[];
+  sourceChunk: number;
+}
+
+export interface Page {
+  name: string;
+  route: string;
+  components: string[];
+  description?: string;
+  sourceChunk: number;
+}
+
+export interface Api {
+  method: string;
+  path: string;
+  description: string;
+  request?: object;
+  response?: object;
+  sourceChunk: number;
+}
+
+export interface ChunkSummary {
+  chunkId: number;
+  sourceFiles: string[];
+  size: string;
+  features: Feature[];
+  dataModels: DataModel[];
+  pages: Page[];
+  apis: Api[];
+  businessRules: string[];
+  extractedAt: string;
+  llmUsage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+export interface DependencyGraph {
+  [featureId: string]: string[];
+}
+
+export interface SpecSummary {
+  version: string;
+  createdAt: string;
+  sourceChunks: number;
+  deduplicatedFeatures: number;
+  features: Feature[];
+  dataModels: DataModel[];
+  pages: Page[];
+  apis: Api[];
+  businessRules: string[];
+  dependencyGraph: DependencyGraph;
+  conflicts?: string[];
+}
+
+export interface Task {
+  id: string;
+  name: string;
+  type: 'setup' | 'page' | 'component' | 'api' | 'feature' | 'test' | 'doc';
+  description?: string;
+  dependencies: string[];
+  priority: 'P0' | 'P1' | 'P2' | 'P3';
+  estimatedHours?: number;
+  assignedTo?: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+}
+
+export interface ParallelGroup {
+  group: number;
+  tasks: Task[];
+}
+
+export interface TaskPlan {
+  version: string;
+  createdAt: string;
+  totalTasks: number;
+  parallelGroups: ParallelGroup[];
+  outputDir: string;
+  framework: string;
+  type: string;
+}
+
+export interface AgentAssignment {
+  agentId: string;
+  type: string;
+  assignedTasks: string[];
+  workload: string;
+}
+
+export interface AgentPool {
+  [agentType: string]: AgentAssignment[];
+}
+
+export interface DispatchPlan {
+  version: string;
+  createdAt: string;
+  totalTasks: number;
+  agentPools: AgentPool;
+  unassigned: string[];
+  dispatchPlanPath: string;
+}
+
+export interface LearnedPattern {
+  name: string;
+  rule: string;
+  context: string;
+  confidence: number;
+  learnedAt: string;
+}
+
+export interface Patterns {
+  version: string;
+  workspace: string;
+  patterns: LearnedPattern[];
+}
+
+export interface WorkspaceStatus {
+  workspace: string;
+  phases: {
+    scan: { completed: boolean; output?: string };
+    analyze: { completed: boolean; chunksAnalyzed?: number; totalChunks?: number };
+    merge: { completed: boolean; output?: string };
+    plan: { completed: boolean; output?: string };
+    dispatch: { completed: boolean; output?: string };
+  };
+  canResumeFrom?: string;
+}

package/src/utils/file.ts

@@ -0,0 +1,60 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { glob } from 'glob';
+
+export async function ensureDir(dirPath: string): Promise<void> {
+  await fs.ensureDir(dirPath);
+}
+
+export async function readJson<T>(filePath: string): Promise<T> {
+  return await fs.readJson(filePath);
+}
+
+export async function writeJson(filePath: string, data: unknown): Promise<void> {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeJson(filePath, data, { spaces: 2 });
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  return await fs.pathExists(filePath);
+}
+
+export async function getFileSize(filePath: string): Promise<number> {
+  const stats = await fs.stat(filePath);
+  return stats.size;
+}
+
+export function formatSize(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(1)}${units[unitIndex]}`;
+}
+
+export function parseSize(sizeStr: string): number {
+  const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i);
+  if (!match) {
+    throw new Error(`Invalid size format: ${sizeStr}`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || 'b').toLowerCase();
+  const multipliers: Record<string, number> = {
+    b: 1,
+    kb: 1024,
+    mb: 1024 * 1024,
+    gb: 1024 * 1024 * 1024,
+  };
+  return value * multipliers[unit];
+}
+
+export async function findFiles(pattern: string, cwd?: string): Promise<string[]> {
+  return await glob(pattern, { cwd, absolute: true });
+}
+
+export async function readFileContent(filePath: string): Promise<string> {
+  return await fs.readFile(filePath, 'utf-8');
+}

package/src/utils/logger.ts

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+
+export class Logger {
+  private silent: boolean;
+  private verbose: boolean;
+
+  constructor(silent = false, verbose = false) {
+    this.silent = silent;
+    this.verbose = verbose;
+  }
+
+  debug(message: string): void {
+    if (!this.silent && this.verbose) {
+      console.log(chalk.gray('◆'), chalk.gray(message));
+    }
+  }
+
+  info(message: string): void {
+    if (!this.silent) {
+      console.log(chalk.blue('ℹ'), message);
+    }
+  }
+
+  success(message: string): void {
+    if (!this.silent) {
+      console.log(chalk.green('✔'), message);
+    }
+  }
+
+  warn(message: string): void {
+    if (!this.silent) {
+      console.log(chalk.yellow('⚠'), message);
+    }
+  }
+
+  error(message: string): void {
+    if (!this.silent) {
+      console.error(chalk.red('✖'), message);
+    }
+  }
+
+  progress(current: number, total: number, message: string): void {
+    if (!this.silent) {
+      const percent = Math.round((current / total) * 100);
+      const bar = '█'.repeat(Math.floor(percent / 5)) + '░'.repeat(20 - Math.floor(percent / 5));
+      process.stdout.write(`\r[${bar}] ${percent}% ${message}`);
+      if (current === total) {
+        process.stdout.write('\n');
+      }
+    }
+  }
+
+  json(data: unknown): void {
+    if (!this.silent) {
+      console.log(JSON.stringify(data, null, 2));
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}