prjct-cli 0.10.14 → 0.11.1

package/packages/shared/dist/index.js

@@ -0,0 +1,204 @@
+// src/schemas.ts
+import { z } from "zod";
+var SessionMetricsSchema = z.object({
+  filesChanged: z.number().default(0),
+  linesAdded: z.number().default(0),
+  linesRemoved: z.number().default(0),
+  commits: z.number().default(0),
+  snapshots: z.array(z.string()).default([])
+});
+var TimelineEventSchema = z.object({
+  type: z.enum(["start", "pause", "resume", "complete", "snapshot"]),
+  at: z.string().datetime(),
+  data: z.record(z.unknown()).optional()
+});
+var SessionSchema = z.object({
+  id: z.string().regex(/^sess_[a-z0-9]{8}$/),
+  projectId: z.string(),
+  task: z.string().min(1),
+  status: z.enum(["active", "paused", "completed"]),
+  startedAt: z.string().datetime(),
+  pausedAt: z.string().datetime().nullable(),
+  completedAt: z.string().datetime().nullable(),
+  duration: z.number().min(0),
+  metrics: SessionMetricsSchema,
+  timeline: z.array(TimelineEventSchema)
+});
+var TaskSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  status: z.enum(["pending", "in_progress", "completed", "blocked"]),
+  priority: z.enum(["low", "medium", "high", "critical"]),
+  createdAt: z.string().datetime(),
+  completedAt: z.string().datetime().optional(),
+  duration: z.number().optional(),
+  tags: z.array(z.string()).optional()
+});
+var IdeaSchema = z.object({
+  id: z.string(),
+  content: z.string().min(1),
+  capturedAt: z.string().datetime(),
+  source: z.string().optional(),
+  promoted: z.boolean().optional(),
+  promotedTo: z.string().optional()
+});
+var FeatureSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  status: z.enum(["planned", "in_progress", "shipped", "cancelled"]),
+  priority: z.number().min(1),
+  createdAt: z.string().datetime(),
+  shippedAt: z.string().datetime().optional(),
+  tasks: z.array(TaskSchema).optional(),
+  version: z.string().optional()
+});
+var ProjectConfigSchema = z.object({
+  projectId: z.string(),
+  name: z.string().optional(),
+  plugins: z.array(z.string()).optional()
+}).passthrough();
+var WSInputMessageSchema = z.object({
+  type: z.literal("input"),
+  payload: z.object({
+    data: z.string()
+  }),
+  timestamp: z.string().datetime()
+});
+var WSResizeMessageSchema = z.object({
+  type: z.literal("resize"),
+  payload: z.object({
+    cols: z.number().min(1),
+    rows: z.number().min(1)
+  }),
+  timestamp: z.string().datetime()
+});
+var WSMessageSchema = z.discriminatedUnion("type", [
+  WSInputMessageSchema,
+  WSResizeMessageSchema
+]);
+var CreateSessionRequestSchema = z.object({
+  task: z.string().min(1).max(200),
+  projectId: z.string()
+});
+var CreateTaskRequestSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(1e3).optional(),
+  priority: z.enum(["low", "medium", "high", "critical"]).default("medium")
+});
+var CaptureIdeaRequestSchema = z.object({
+  content: z.string().min(1).max(500),
+  source: z.string().optional()
+});
+
+// src/utils.ts
+function generateSessionId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "sess_";
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+function generateId(prefix = "id") {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = `${prefix}_`;
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return id;
+}
+function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.round(seconds % 3600 / 60);
+  if (minutes === 0) return `${hours}h`;
+  return `${hours}h ${minutes}m`;
+}
+function parseDuration(duration) {
+  const match = duration.match(/(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?/);
+  if (!match) return 0;
+  const hours = parseInt(match[1] || "0", 10);
+  const minutes = parseInt(match[2] || "0", 10);
+  const secs = parseInt(match[3] || "0", 10);
+  return hours * 3600 + minutes * 60 + secs;
+}
+function getRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const then = typeof date === "string" ? new Date(date) : date;
+  const diffMs = now.getTime() - then.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return then.toLocaleDateString();
+}
+function getTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function getYearMonth() {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+}
+function safeJsonParse(json, fallback) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return fallback;
+  }
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function isNode() {
+  return typeof process !== "undefined" && process.versions?.node != null;
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+export {
+  CaptureIdeaRequestSchema,
+  CreateSessionRequestSchema,
+  CreateTaskRequestSchema,
+  FeatureSchema,
+  IdeaSchema,
+  ProjectConfigSchema,
+  SessionMetricsSchema,
+  SessionSchema,
+  TaskSchema,
+  TimelineEventSchema,
+  WSInputMessageSchema,
+  WSMessageSchema,
+  WSResizeMessageSchema,
+  deepClone,
+  formatDuration,
+  generateId,
+  generateSessionId,
+  getDate,
+  getRelativeTime,
+  getTimestamp,
+  getYearMonth,
+  isBrowser,
+  isNode,
+  parseDuration,
+  safeJsonParse,
+  slugify,
+  truncate
+};

package/packages/shared/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@prjct/shared",
+  "version": "0.1.0",
+  "description": "Shared types and utilities for prjct",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  }
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @prjct/shared - Shared Types and Utilities
+ *
+ * Types and schemas shared between CLI, server, and web.
+ */
+
+export * from './types'
+export * from './schemas'
+export * from './utils'

package/packages/shared/src/schemas.ts

@@ -0,0 +1,124 @@
+/**
+ * Zod Schemas for validation
+ */
+
+import { z } from 'zod'
+
+// Session Schemas
+export const SessionMetricsSchema = z.object({
+  filesChanged: z.number().default(0),
+  linesAdded: z.number().default(0),
+  linesRemoved: z.number().default(0),
+  commits: z.number().default(0),
+  snapshots: z.array(z.string()).default([])
+})
+
+export const TimelineEventSchema = z.object({
+  type: z.enum(['start', 'pause', 'resume', 'complete', 'snapshot']),
+  at: z.string().datetime(),
+  data: z.record(z.unknown()).optional()
+})
+
+export const SessionSchema = z.object({
+  id: z.string().regex(/^sess_[a-z0-9]{8}$/),
+  projectId: z.string(),
+  task: z.string().min(1),
+  status: z.enum(['active', 'paused', 'completed']),
+  startedAt: z.string().datetime(),
+  pausedAt: z.string().datetime().nullable(),
+  completedAt: z.string().datetime().nullable(),
+  duration: z.number().min(0),
+  metrics: SessionMetricsSchema,
+  timeline: z.array(TimelineEventSchema)
+})
+
+// Task Schemas
+export const TaskSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  status: z.enum(['pending', 'in_progress', 'completed', 'blocked']),
+  priority: z.enum(['low', 'medium', 'high', 'critical']),
+  createdAt: z.string().datetime(),
+  completedAt: z.string().datetime().optional(),
+  duration: z.number().optional(),
+  tags: z.array(z.string()).optional()
+})
+
+// Idea Schemas
+export const IdeaSchema = z.object({
+  id: z.string(),
+  content: z.string().min(1),
+  capturedAt: z.string().datetime(),
+  source: z.string().optional(),
+  promoted: z.boolean().optional(),
+  promotedTo: z.string().optional()
+})
+
+// Feature Schemas
+export const FeatureSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  status: z.enum(['planned', 'in_progress', 'shipped', 'cancelled']),
+  priority: z.number().min(1),
+  createdAt: z.string().datetime(),
+  shippedAt: z.string().datetime().optional(),
+  tasks: z.array(TaskSchema).optional(),
+  version: z.string().optional()
+})
+
+// Project Config Schema
+export const ProjectConfigSchema = z.object({
+  projectId: z.string(),
+  name: z.string().optional(),
+  plugins: z.array(z.string()).optional()
+}).passthrough()
+
+// WebSocket Message Schemas
+export const WSInputMessageSchema = z.object({
+  type: z.literal('input'),
+  payload: z.object({
+    data: z.string()
+  }),
+  timestamp: z.string().datetime()
+})
+
+export const WSResizeMessageSchema = z.object({
+  type: z.literal('resize'),
+  payload: z.object({
+    cols: z.number().min(1),
+    rows: z.number().min(1)
+  }),
+  timestamp: z.string().datetime()
+})
+
+export const WSMessageSchema = z.discriminatedUnion('type', [
+  WSInputMessageSchema,
+  WSResizeMessageSchema
+])
+
+// API Request Schemas
+export const CreateSessionRequestSchema = z.object({
+  task: z.string().min(1).max(200),
+  projectId: z.string()
+})
+
+export const CreateTaskRequestSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(1000).optional(),
+  priority: z.enum(['low', 'medium', 'high', 'critical']).default('medium')
+})
+
+export const CaptureIdeaRequestSchema = z.object({
+  content: z.string().min(1).max(500),
+  source: z.string().optional()
+})
+
+// Inferred Types
+export type SessionInput = z.infer<typeof SessionSchema>
+export type TaskInput = z.infer<typeof TaskSchema>
+export type IdeaInput = z.infer<typeof IdeaSchema>
+export type FeatureInput = z.infer<typeof FeatureSchema>
+export type ProjectConfigInput = z.infer<typeof ProjectConfigSchema>
+export type WSMessageInput = z.infer<typeof WSMessageSchema>

package/packages/shared/src/types.ts

@@ -0,0 +1,187 @@
+/**
+ * Core Types for prjct
+ */
+
+// Session Types
+export interface Session {
+  id: string
+  projectId: string
+  task: string
+  status: 'active' | 'paused' | 'completed'
+  startedAt: string
+  pausedAt: string | null
+  completedAt: string | null
+  duration: number
+  metrics: SessionMetrics
+  timeline: TimelineEvent[]
+}
+
+export interface SessionMetrics {
+  filesChanged: number
+  linesAdded: number
+  linesRemoved: number
+  commits: number
+  snapshots: string[]
+}
+
+export interface TimelineEvent {
+  type: 'start' | 'pause' | 'resume' | 'complete' | 'snapshot'
+  at: string
+  data?: Record<string, unknown>
+}
+
+// Snapshot Types
+export interface Snapshot {
+  hash: string
+  shortHash: string
+  message: string
+  timestamp: string
+  files: string[]
+}
+
+// Task Types
+export interface Task {
+  id: string
+  title: string
+  description?: string
+  status: 'pending' | 'in_progress' | 'completed' | 'blocked'
+  priority: 'low' | 'medium' | 'high' | 'critical'
+  createdAt: string
+  completedAt?: string
+  duration?: number
+  tags?: string[]
+}
+
+// Idea Types
+export interface Idea {
+  id: string
+  content: string
+  capturedAt: string
+  source?: string
+  promoted?: boolean
+  promotedTo?: string
+}
+
+// Feature Types
+export interface Feature {
+  id: string
+  title: string
+  description?: string
+  status: 'planned' | 'in_progress' | 'shipped' | 'cancelled'
+  priority: number
+  createdAt: string
+  shippedAt?: string
+  tasks?: Task[]
+  version?: string
+}
+
+// Project Types
+export interface Project {
+  id: string
+  name: string
+  path: string
+  createdAt: string
+  lastActiveAt: string
+  config: ProjectConfig
+}
+
+export interface ProjectConfig {
+  projectId: string
+  name?: string
+  plugins?: string[]
+  [key: string]: unknown
+}
+
+// Metrics Types
+export interface DailyMetrics {
+  date: string
+  sessions: number
+  duration: number
+  commits: number
+  filesChanged: number
+  linesAdded: number
+  linesRemoved: number
+}
+
+export interface WeeklyMetrics {
+  weekStart: string
+  weekEnd: string
+  totalSessions: number
+  totalDuration: number
+  averageDuration: number
+  tasksCompleted: number
+  featuresShipped: number
+  productivityScore: number
+  streak: number
+  byDay: Record<string, DailyMetrics>
+}
+
+// WebSocket Message Types
+export interface WSMessage {
+  type: string
+  payload?: unknown
+  timestamp: string
+}
+
+export interface WSInputMessage extends WSMessage {
+  type: 'input'
+  payload: {
+    data: string
+  }
+}
+
+export interface WSOutputMessage extends WSMessage {
+  type: 'output'
+  payload: {
+    data: string
+  }
+}
+
+export interface WSResizeMessage extends WSMessage {
+  type: 'resize'
+  payload: {
+    cols: number
+    rows: number
+  }
+}
+
+export interface WSStatusMessage extends WSMessage {
+  type: 'status'
+  payload: {
+    status: 'connected' | 'disconnected' | 'error'
+    message?: string
+  }
+}
+
+// API Response Types
+export interface ApiResponse<T = unknown> {
+  success: boolean
+  data?: T
+  error?: string
+  timestamp: string
+}
+
+// Event Types (for event bus)
+export type EventType =
+  | 'session.started'
+  | 'session.paused'
+  | 'session.resumed'
+  | 'session.completed'
+  | 'task.created'
+  | 'task.completed'
+  | 'feature.added'
+  | 'feature.shipped'
+  | 'idea.captured'
+  | 'snapshot.created'
+  | 'snapshot.restored'
+  | 'git.commit'
+  | 'git.push'
+  | 'project.init'
+  | 'project.sync'
+
+export interface EventPayload {
+  type: EventType
+  timestamp: string
+  projectId: string
+  data: Record<string, unknown>
+}

package/packages/shared/src/utils.ts

@@ -0,0 +1,148 @@
+/**
+ * Shared Utilities
+ */
+
+/**
+ * Generate a unique session ID
+ */
+export function generateSessionId(): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = 'sess_'
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length))
+  }
+  return id
+}
+
+/**
+ * Generate a unique ID with prefix
+ */
+export function generateId(prefix: string = 'id'): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = `${prefix}_`
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length))
+  }
+  return id
+}
+
+/**
+ * Format duration in seconds to human readable
+ */
+export function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`
+
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.round((seconds % 3600) / 60)
+
+  if (minutes === 0) return `${hours}h`
+  return `${hours}h ${minutes}m`
+}
+
+/**
+ * Parse duration string to seconds
+ */
+export function parseDuration(duration: string): number {
+  const match = duration.match(/(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?/)
+  if (!match) return 0
+
+  const hours = parseInt(match[1] || '0', 10)
+  const minutes = parseInt(match[2] || '0', 10)
+  const secs = parseInt(match[3] || '0', 10)
+
+  return hours * 3600 + minutes * 60 + secs
+}
+
+/**
+ * Get relative time string
+ */
+export function getRelativeTime(date: Date | string): string {
+  const now = new Date()
+  const then = typeof date === 'string' ? new Date(date) : date
+  const diffMs = now.getTime() - then.getTime()
+  const diffSecs = Math.floor(diffMs / 1000)
+  const diffMins = Math.floor(diffSecs / 60)
+  const diffHours = Math.floor(diffMins / 60)
+  const diffDays = Math.floor(diffHours / 24)
+
+  if (diffSecs < 60) return 'just now'
+  if (diffMins < 60) return `${diffMins}m ago`
+  if (diffHours < 24) return `${diffHours}h ago`
+  if (diffDays === 1) return 'yesterday'
+  if (diffDays < 7) return `${diffDays}d ago`
+
+  return then.toLocaleDateString()
+}
+
+/**
+ * Get ISO timestamp
+ */
+export function getTimestamp(): string {
+  return new Date().toISOString()
+}
+
+/**
+ * Get date in YYYY-MM-DD format
+ */
+export function getDate(): string {
+  return new Date().toISOString().split('T')[0]
+}
+
+/**
+ * Get year-month in YYYY-MM format
+ */
+export function getYearMonth(): string {
+  const now = new Date()
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`
+}
+
+/**
+ * Safely parse JSON
+ */
+export function safeJsonParse<T>(json: string, fallback: T): T {
+  try {
+    return JSON.parse(json) as T
+  } catch {
+    return fallback
+  }
+}
+
+/**
+ * Truncate string with ellipsis
+ */
+export function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str
+  return str.slice(0, maxLength - 3) + '...'
+}
+
+/**
+ * Slugify string
+ */
+export function slugify(str: string): string {
+  return str
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+/**
+ * Deep clone object
+ */
+export function deepClone<T>(obj: T): T {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+/**
+ * Check if running in Node.js
+ */
+export function isNode(): boolean {
+  return typeof process !== 'undefined' && process.versions?.node != null
+}
+
+/**
+ * Check if running in browser
+ */
+export function isBrowser(): boolean {
+  return typeof window !== 'undefined'
+}