pi-harness-runtime 1.1.350 → 1.1.351

package/packages/contracts/src/delegation-store.ts

@@ -0,0 +1,204 @@
+/**
+ * Delegation Store
+ * 
+ * Durable storage for delegation receipts.
+ * Stores in ignored harness state directory.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { DelegationReceipt } from "./delegation.js";
+
+/**
+ * Store directory path
+ */
+const STORE_DIR = join(process.env.HOME || "/home/frappe", ".pi-harness-runtime", "delegation-state");
+
+/**
+ * Ensure store directory exists
+ */
+function ensureStoreDir(): void {
+  if (!existsSync(STORE_DIR)) {
+    mkdirSync(STORE_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get receipt file path for workspace + task
+ */
+function getReceiptPath(workspacePath: string, taskId: string): string {
+  // Sanitize path for use as filename
+  const safePath = workspacePath.replace(/[^a-zA-Z0-9_-]/g, "_").slice(-100);
+  const safeTask = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join(STORE_DIR, `${safePath}__${safeTask}.json`);
+}
+
+/**
+ * Save delegation receipt
+ */
+export function saveDelegationReceipt(receipt: DelegationReceipt): void {
+  ensureStoreDir();
+  const path = getReceiptPath(receipt.workspacePath, receipt.parentTaskId);
+  
+  // Atomic write: write to temp, then rename
+  const tempPath = path + ".tmp";
+  writeFileSync(tempPath, JSON.stringify(receipt, null, 2), "utf8");
+  
+  // Rename is atomic on POSIX
+  try {
+    const { renameSync } = require("fs");
+    renameSync(tempPath, path);
+  } catch {
+    // Fallback: just move the file
+    try {
+      writeFileSync(path, JSON.stringify(receipt, null, 2), "utf8");
+    } catch {
+      // Ignore write errors
+    }
+  }
+}
+
+/**
+ * Load delegation receipt
+ */
+export function loadDelegationReceipt(
+  workspacePath: string,
+  taskId: string
+): DelegationReceipt | null {
+  const path = getReceiptPath(workspacePath, taskId);
+  
+  if (!existsSync(path)) {
+    return null;
+  }
+  
+  try {
+    const content = readFileSync(path, "utf8");
+    const receipt = JSON.parse(content) as DelegationReceipt;
+    
+    // Validate version
+    if (receipt.version !== 1) {
+      // Future migration logic would go here
+      return null;
+    }
+    
+    return receipt;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Delete delegation receipt
+ */
+export function deleteDelegationReceipt(
+  workspacePath: string,
+  taskId: string
+): void {
+  const path = getReceiptPath(workspacePath, taskId);
+  
+  if (existsSync(path)) {
+    try {
+      const { unlinkSync } = require("fs");
+      unlinkSync(path);
+    } catch {
+      // Ignore delete errors
+    }
+  }
+}
+
+/**
+ * List all receipts for a workspace
+ */
+export function listDelegationReceipts(workspacePath: string): DelegationReceipt[] {
+  ensureStoreDir();
+  const receipts: DelegationReceipt[] = [];
+  
+  try {
+    const { readdirSync } = require("fs");
+    const files = readdirSync(STORE_DIR);
+    
+    const safePathPrefix = workspacePath.replace(/[^a-zA-Z0-9_-]/g, "_").slice(-100) + "__";
+    
+    for (const file of files) {
+      if (!file.startsWith(safePathPrefix) || !file.endsWith(".json")) {
+        continue;
+      }
+      
+      try {
+        const content = readFileSync(join(STORE_DIR, file), "utf8");
+        const receipt = JSON.parse(content) as DelegationReceipt;
+        if (receipt.workspacePath === workspacePath) {
+          receipts.push(receipt);
+        }
+      } catch {
+        // Skip invalid files
+      }
+    }
+  } catch {
+    // Directory doesn't exist or not readable
+  }
+  
+  return receipts;
+}
+
+/**
+ * Update receipt status
+ */
+export function updateReceiptStatus(
+  workspacePath: string,
+  taskId: string,
+  status: DelegationReceipt["status"],
+  updates?: Partial<DelegationReceipt>
+): DelegationReceipt | null {
+  const receipt = loadDelegationReceipt(workspacePath, taskId);
+  
+  if (!receipt) {
+    return null;
+  }
+  
+  const updated: DelegationReceipt = {
+    ...receipt,
+    ...updates,
+    status,
+    updatedAt: Date.now(),
+  };
+  
+  saveDelegationReceipt(updated);
+  return updated;
+}
+
+/**
+ * Check if receipt exists for task
+ */
+export function hasReceipt(workspacePath: string, taskId: string): boolean {
+  const path = getReceiptPath(workspacePath, taskId);
+  return existsSync(path);
+}
+
+/**
+ * Compact receipt for storage after compaction
+ */
+export function compactReceipt(receipt: DelegationReceipt): DelegationReceipt {
+  return {
+    version: receipt.version,
+    workspacePath: receipt.workspacePath,
+    sessionId: receipt.sessionId,
+    parentTaskId: receipt.parentTaskId,
+    scopeFingerprint: receipt.scopeFingerprint,
+    decision: {
+      strategy: receipt.decision.strategy,
+      reason: receipt.decision.reason,
+      workGroups: receipt.decision.workGroups.filter((g) => g.status === "pending" || g.status === "dispatched" || g.status === "running"),
+      validationExpectations: receipt.decision.validationExpectations,
+      confidence: receipt.decision.confidence,
+      jevUsed: receipt.decision.jevUsed,
+      reassessmentTriggers: receipt.decision.reassessmentTriggers,
+    },
+    createdAt: receipt.createdAt,
+    updatedAt: Date.now(),
+    status: receipt.status,
+    childIds: receipt.childIds,
+    pendingValidation: receipt.pendingValidation,
+    userConstraints: receipt.userConstraints,
+  };
+}

package/packages/contracts/src/index.ts

@@ -21,4 +21,6 @@ export * from './notifications.js';
 export * from './approvals.js';
 export * from './delegation.js';
 export * from './delegation-assessor.js';
+export * from './delegation-store.js';
 export * from './scope-discovery.js';
+export * from './work-partitioner.js';

package/packages/contracts/src/work-partitioner.ts

@@ -0,0 +1,251 @@
+/**
+ * Work Partitioner
+ * 
+ * Partitions work into disjoint file ownership groups.
+ */
+
+import type { WorkGroup, ScopeFacts } from "./delegation.js";
+
+/**
+ * File dependency info
+ */
+export interface FileDependency {
+  path: string;
+  imports: string[];
+  exports: string[];
+}
+
+/**
+ * Partition configuration
+ */
+export interface PartitionConfig {
+  /** Maximum files per group */
+  maxFilesPerGroup: number;
+  /** Whether to group by directory */
+  groupByDirectory: boolean;
+  /** Shared files that shouldn't be partitioned */
+  sharedPaths: string[];
+}
+
+/**
+ * Default partition config
+ */
+export const DEFAULT_PARTITION_CONFIG: PartitionConfig = {
+  maxFilesPerGroup: 15,
+  groupByDirectory: true,
+  sharedPaths: [
+    "index.ts",
+    "index.js",
+    "main.ts",
+    "main.js",
+    "package.json",
+    "tsconfig.json",
+  ],
+};
+
+/**
+ * Partition files into ownership groups
+ */
+export function partitionWork(
+  files: string[],
+  facts: ScopeFacts,
+  config: Partial<PartitionConfig> = {}
+): WorkGroup[] {
+  const cfg = { ...DEFAULT_PARTITION_CONFIG, ...config };
+
+  // Filter out shared paths
+  const ownedFiles = files.filter(
+    (f) => !cfg.sharedPaths.some((s) => f.endsWith(s))
+  );
+
+  // Group files by directory
+  const dirGroups = groupByDirectory(ownedFiles);
+
+  // Further partition large groups
+  const groups: WorkGroup[] = [];
+  let groupId = 1;
+
+  for (const [dir, dirFiles] of Object.entries(dirGroups)) {
+    if (dirFiles.length <= cfg.maxFilesPerGroup) {
+      groups.push(createGroup(groupId++, dir, dirFiles, facts.isMechanical));
+    } else {
+      // Split large directories
+      const subGroups = splitGroup(dirFiles, cfg.maxFilesPerGroup);
+      for (const subFiles of subGroups) {
+        groups.push(createGroup(groupId++, dir, subFiles, facts.isMechanical));
+      }
+    }
+  }
+
+  return groups;
+}
+
+/**
+ * Group files by directory
+ */
+function groupByDirectory(files: string[]): Record<string, string[]> {
+  const groups: Record<string, string[]> = {};
+
+  for (const file of files) {
+    // Get directory part of path
+    const parts = file.split("/");
+    const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+
+    if (!groups[dir]) {
+      groups[dir] = [];
+    }
+    groups[dir].push(file);
+  }
+
+  return groups;
+}
+
+/**
+ * Create a work group
+ */
+function createGroup(
+  id: number,
+  description: string,
+  files: string[],
+  isMechanical: boolean
+): WorkGroup {
+  return {
+    groupId: `group-${id}`,
+    description: `${description} (${files.length} files)`,
+    ownedPaths: files,
+    isMechanical,
+    status: "pending",
+  };
+}
+
+/**
+ * Split a group into smaller subgroups
+ */
+function splitGroup(files: string[], maxSize: number): string[][] {
+  const subgroups: string[][] = [];
+
+  for (let i = 0; i < files.length; i += maxSize) {
+    subgroups.push(files.slice(i, i + maxSize));
+  }
+
+  return subgroups;
+}
+
+/**
+ * Detect ownership conflicts
+ */
+export function detectOwnershipConflicts(
+  groups: WorkGroup[],
+  newPaths: string[]
+): string[] {
+  const conflicts: string[] = [];
+
+  for (const path of newPaths) {
+    for (const group of groups) {
+      if (
+        group.status !== "cancelled" &&
+        group.status !== "failed" &&
+        group.ownedPaths.includes(path)
+      ) {
+        conflicts.push(`${path} already owned by ${group.groupId}`);
+      }
+    }
+  }
+
+  return conflicts;
+}
+
+/**
+ * Assign work to group
+ */
+export function assignWorkToGroup(
+  groups: WorkGroup[],
+  groupId: string,
+  paths: string[]
+): WorkGroup | null {
+  const group = groups.find((g) => g.groupId === groupId);
+
+  if (!group) {
+    return null;
+  }
+
+  // Check for conflicts
+  const conflicts = detectOwnershipConflicts(
+    groups.filter((g) => g.groupId !== groupId),
+    paths
+  );
+
+  if (conflicts.length > 0) {
+    // Return group with conflict info
+    return {
+      ...group,
+      status: "failed",
+    };
+  }
+
+  return {
+    ...group,
+    ownedPaths: [...new Set([...group.ownedPaths, ...paths])],
+  };
+}
+
+/**
+ * Get unowned files
+ */
+export function getUnownedFiles(
+  allFiles: string[],
+  groups: WorkGroup[]
+): string[] {
+  const ownedFiles = new Set<string>();
+
+  for (const group of groups) {
+    if (group.status !== "cancelled" && group.status !== "failed") {
+      for (const path of group.ownedPaths) {
+        ownedFiles.add(path);
+      }
+    }
+  }
+
+  return allFiles.filter((f) => !ownedFiles.has(f));
+}
+
+/**
+ * Update group status
+ */
+export function updateGroupStatus(
+  groups: WorkGroup[],
+  groupId: string,
+  status: WorkGroup["status"],
+  childId?: string
+): WorkGroup[] {
+  return groups.map((g) => {
+    if (g.groupId !== groupId) {
+      return g;
+    }
+
+    return {
+      ...g,
+      status,
+      childId: childId || g.childId,
+    };
+  });
+}
+
+/**
+ * Check if all groups are complete
+ */
+export function areAllGroupsComplete(groups: WorkGroup[]): boolean {
+  return groups.every(
+    (g) =>
+      g.status === "completed" ||
+      g.status === "failed" ||
+      g.status === "cancelled"
+  );
+}
+
+/**
+ * Get pending groups
+ */
+export function getPendingGroups(groups: WorkGroup[]): WorkGroup[] {
+  return groups.filter((g) => g.status === "pending");
+}