newo 2.0.5 → 2.0.6

package/dist/sync/diff-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Proper diff algorithm for accurate content comparison
+ */
+export interface DiffLine {
+    type: 'context' | 'add' | 'remove';
+    localLineNum: number;
+    remoteLineNum: number;
+    content: string;
+}
+/**
+ * Generate a proper diff using LCS algorithm
+ */
+export declare function generateDiff(localContent: string, remoteContent: string): DiffLine[];
+/**
+ * Filter diff to show only relevant sections with context
+ */
+export declare function filterDiffWithContext(diff: DiffLine[], contextLines?: number): DiffLine[];
+//# sourceMappingURL=diff-utils.d.ts.map

package/dist/sync/diff-utils.js

@@ -0,0 +1,152 @@
+/**
+ * Proper diff algorithm for accurate content comparison
+ */
+/**
+ * Generate a proper diff using LCS algorithm
+ */
+export function generateDiff(localContent, remoteContent) {
+    const localLines = localContent.trim().split('\n');
+    const remoteLines = remoteContent.trim().split('\n');
+    // Simple LCS-based diff algorithm
+    const diff = [];
+    let localIdx = 0;
+    let remoteIdx = 0;
+    while (localIdx < localLines.length || remoteIdx < remoteLines.length) {
+        const localLine = localLines[localIdx];
+        const remoteLine = remoteLines[remoteIdx];
+        if (localIdx >= localLines.length) {
+            // Only remote lines left (additions)
+            diff.push({
+                type: 'add',
+                localLineNum: -1,
+                remoteLineNum: remoteIdx + 1,
+                content: remoteLine || ''
+            });
+            remoteIdx++;
+        }
+        else if (remoteIdx >= remoteLines.length) {
+            // Only local lines left (deletions)
+            diff.push({
+                type: 'remove',
+                localLineNum: localIdx + 1,
+                remoteLineNum: -1,
+                content: localLine || ''
+            });
+            localIdx++;
+        }
+        else if (localLine === remoteLine) {
+            // Lines match (context)
+            diff.push({
+                type: 'context',
+                localLineNum: localIdx + 1,
+                remoteLineNum: remoteIdx + 1,
+                content: localLine || ''
+            });
+            localIdx++;
+            remoteIdx++;
+        }
+        else {
+            // Lines differ - check if this is an insertion or substitution
+            // Look ahead to see if the local line appears later in remote
+            let foundInRemote = -1;
+            for (let j = remoteIdx + 1; j < Math.min(remoteIdx + 5, remoteLines.length); j++) {
+                if (localLine === remoteLines[j]) {
+                    foundInRemote = j;
+                    break;
+                }
+            }
+            // Look ahead to see if the remote line appears later in local
+            let foundInLocal = -1;
+            for (let j = localIdx + 1; j < Math.min(localIdx + 5, localLines.length); j++) {
+                if (remoteLine === localLines[j]) {
+                    foundInLocal = j;
+                    break;
+                }
+            }
+            if (foundInRemote !== -1 && (foundInLocal === -1 || foundInRemote - remoteIdx < foundInLocal - localIdx)) {
+                // Local line found later in remote - this is likely remote insertions
+                while (remoteIdx < foundInRemote) {
+                    diff.push({
+                        type: 'add',
+                        localLineNum: -1,
+                        remoteLineNum: remoteIdx + 1,
+                        content: remoteLines[remoteIdx] || ''
+                    });
+                    remoteIdx++;
+                }
+            }
+            else if (foundInLocal !== -1) {
+                // Remote line found later in local - this is likely local insertions (deletions in diff)
+                while (localIdx < foundInLocal) {
+                    diff.push({
+                        type: 'remove',
+                        localLineNum: localIdx + 1,
+                        remoteLineNum: -1,
+                        content: localLines[localIdx] || ''
+                    });
+                    localIdx++;
+                }
+            }
+            else {
+                // Lines are genuinely different (substitution)
+                diff.push({
+                    type: 'remove',
+                    localLineNum: localIdx + 1,
+                    remoteLineNum: -1,
+                    content: localLine || ''
+                });
+                diff.push({
+                    type: 'add',
+                    localLineNum: -1,
+                    remoteLineNum: remoteIdx + 1,
+                    content: remoteLine || ''
+                });
+                localIdx++;
+                remoteIdx++;
+            }
+        }
+    }
+    return diff;
+}
+/**
+ * Filter diff to show only relevant sections with context
+ */
+export function filterDiffWithContext(diff, contextLines = 2) {
+    const result = [];
+    // Find all non-context lines (changes)
+    const changeIndices = [];
+    diff.forEach((line, idx) => {
+        if (line.type !== 'context') {
+            changeIndices.push(idx);
+        }
+    });
+    if (changeIndices.length === 0) {
+        return []; // No changes
+    }
+    // Group nearby changes and add context
+    const groups = [];
+    let currentGroup = { start: changeIndices[0], end: changeIndices[0] };
+    for (let i = 1; i < changeIndices.length; i++) {
+        const idx = changeIndices[i];
+        if (idx - currentGroup.end <= contextLines * 2 + 1) {
+            // Close enough to current group, extend it
+            currentGroup.end = idx;
+        }
+        else {
+            // Start new group
+            groups.push(currentGroup);
+            currentGroup = { start: idx, end: idx };
+        }
+    }
+    groups.push(currentGroup);
+    // Build result with context
+    for (const group of groups) {
+        const start = Math.max(0, group.start - contextLines);
+        const end = Math.min(diff.length - 1, group.end + contextLines);
+        for (let i = start; i <= end; i++) {
+            result.push(diff[i]);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=diff-utils.js.map

package/dist/sync/skill-files.js

@@ -107,62 +107,35 @@ export async function askForOverwrite(skillIdn, existingContent, newContent, fil
     const greenBg = '\x1b[102m\x1b[30m'; // Light green background, black text (like GitHub)
     const gray = '\x1b[90m';
     const reset = '\x1b[0m';
-    // Show a GitHub-style colored diff with line numbers and context
-    const localLines = existingContent.trim().split('\n');
-    const remoteLines = newContent.trim().split('\n');
-    // Find the first differing section and show it with context
-    let diffStart = -1;
-    let diffEnd = -1;
-    // Find first difference
-    for (let i = 0; i < Math.max(localLines.length, remoteLines.length); i++) {
-        if (localLines[i] !== remoteLines[i]) {
-            diffStart = i;
-            break;
-        }
-    }
-    if (diffStart === -1) {
-        // No differences found (shouldn't happen, but handle gracefully)
+    // Generate proper diff using LCS algorithm
+    const { generateDiff, filterDiffWithContext } = await import('./diff-utils.js');
+    const fullDiff = generateDiff(existingContent, newContent);
+    const contextDiff = filterDiffWithContext(fullDiff, 2);
+    if (contextDiff.length === 0) {
         console.log(`${gray}   No differences found${reset}`);
         return 'no';
     }
-    // Find end of difference section
-    diffEnd = diffStart;
-    while (diffEnd < Math.max(localLines.length, remoteLines.length) &&
-        (localLines[diffEnd] !== remoteLines[diffEnd] ||
-            localLines[diffEnd] === undefined ||
-            remoteLines[diffEnd] === undefined)) {
-        diffEnd++;
-    }
-    // Show context before (2 lines)
-    const contextStart = Math.max(0, diffStart - 2);
-    for (let i = contextStart; i < diffStart; i++) {
-        if (localLines[i] !== undefined) {
-            console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
+    // Display the diff with proper GitHub-style formatting
+    for (const line of contextDiff) {
+        if (line.type === 'context') {
+            // Show context lines in gray
+            const lineNum = line.localLineNum !== -1 ? line.localLineNum : line.remoteLineNum;
+            console.log(`    ${String(lineNum).padStart(3)}      ${line.content}`);
         }
-    }
-    // Show the differences
-    const maxDiffLine = Math.min(diffEnd, Math.max(localLines.length, remoteLines.length));
-    for (let i = diffStart; i < maxDiffLine; i++) {
-        const localLine = localLines[i];
-        const remoteLine = remoteLines[i];
-        if (localLine !== undefined && (remoteLine === undefined || localLine !== remoteLine)) {
-            console.log(`${redBg} -  ${String(i + 1).padStart(3)}      ${localLine} ${reset}`);
-        }
-        if (remoteLine !== undefined && (localLine === undefined || localLine !== remoteLine)) {
-            console.log(`${greenBg} +  ${String(i + 1).padStart(3)}      ${remoteLine} ${reset}`);
+        else if (line.type === 'remove') {
+            // Show local content being removed (red background)
+            console.log(`${redBg} -  ${String(line.localLineNum).padStart(3)}      ${line.content} ${reset}`);
         }
-    }
-    // Show context after (2 lines)
-    const contextEnd = Math.min(localLines.length, diffEnd + 2);
-    for (let i = diffEnd; i < contextEnd; i++) {
-        if (localLines[i] !== undefined) {
-            console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
+        else if (line.type === 'add') {
+            // Show remote content being added (green background)
+            console.log(`${greenBg} +  ${String(line.remoteLineNum).padStart(3)}      ${line.content} ${reset}`);
         }
     }
-    // Show if there are more differences
-    const totalDiffs = Math.abs(localLines.length - remoteLines.length) + (diffEnd - diffStart);
-    if (totalDiffs > (diffEnd - diffStart)) {
-        console.log(`${gray}... (${totalDiffs - (diffEnd - diffStart)} more differences)${reset}`);
+    // Show if there are more changes beyond what we're displaying
+    const totalChanges = fullDiff.filter(line => line.type !== 'context').length;
+    const displayedChanges = contextDiff.filter(line => line.type !== 'context').length;
+    if (totalChanges > displayedChanges) {
+        console.log(`${gray}... (${totalChanges - displayedChanges} more changes)${reset}`);
     }
     const answer = await new Promise((resolve) => {
         rl.question(`\nReplace local with remote? (y)es/(n)o/(a)ll/(q)uit: `, resolve);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/sync/diff-utils.ts

@@ -0,0 +1,168 @@
+/**
+ * Proper diff algorithm for accurate content comparison
+ */
+
+export interface DiffLine {
+  type: 'context' | 'add' | 'remove';
+  localLineNum: number;
+  remoteLineNum: number;
+  content: string;
+}
+
+/**
+ * Generate a proper diff using LCS algorithm
+ */
+export function generateDiff(localContent: string, remoteContent: string): DiffLine[] {
+  const localLines = localContent.trim().split('\n');
+  const remoteLines = remoteContent.trim().split('\n');
+
+  // Simple LCS-based diff algorithm
+  const diff: DiffLine[] = [];
+
+  let localIdx = 0;
+  let remoteIdx = 0;
+
+  while (localIdx < localLines.length || remoteIdx < remoteLines.length) {
+    const localLine = localLines[localIdx];
+    const remoteLine = remoteLines[remoteIdx];
+
+    if (localIdx >= localLines.length) {
+      // Only remote lines left (additions)
+      diff.push({
+        type: 'add',
+        localLineNum: -1,
+        remoteLineNum: remoteIdx + 1,
+        content: remoteLine || ''
+      });
+      remoteIdx++;
+    } else if (remoteIdx >= remoteLines.length) {
+      // Only local lines left (deletions)
+      diff.push({
+        type: 'remove',
+        localLineNum: localIdx + 1,
+        remoteLineNum: -1,
+        content: localLine || ''
+      });
+      localIdx++;
+    } else if (localLine === remoteLine) {
+      // Lines match (context)
+      diff.push({
+        type: 'context',
+        localLineNum: localIdx + 1,
+        remoteLineNum: remoteIdx + 1,
+        content: localLine || ''
+      });
+      localIdx++;
+      remoteIdx++;
+    } else {
+      // Lines differ - check if this is an insertion or substitution
+      // Look ahead to see if the local line appears later in remote
+      let foundInRemote = -1;
+      for (let j = remoteIdx + 1; j < Math.min(remoteIdx + 5, remoteLines.length); j++) {
+        if (localLine === remoteLines[j]) {
+          foundInRemote = j;
+          break;
+        }
+      }
+
+      // Look ahead to see if the remote line appears later in local
+      let foundInLocal = -1;
+      for (let j = localIdx + 1; j < Math.min(localIdx + 5, localLines.length); j++) {
+        if (remoteLine === localLines[j]) {
+          foundInLocal = j;
+          break;
+        }
+      }
+
+      if (foundInRemote !== -1 && (foundInLocal === -1 || foundInRemote - remoteIdx < foundInLocal - localIdx)) {
+        // Local line found later in remote - this is likely remote insertions
+        while (remoteIdx < foundInRemote) {
+          diff.push({
+            type: 'add',
+            localLineNum: -1,
+            remoteLineNum: remoteIdx + 1,
+            content: remoteLines[remoteIdx] || ''
+          });
+          remoteIdx++;
+        }
+      } else if (foundInLocal !== -1) {
+        // Remote line found later in local - this is likely local insertions (deletions in diff)
+        while (localIdx < foundInLocal) {
+          diff.push({
+            type: 'remove',
+            localLineNum: localIdx + 1,
+            remoteLineNum: -1,
+            content: localLines[localIdx] || ''
+          });
+          localIdx++;
+        }
+      } else {
+        // Lines are genuinely different (substitution)
+        diff.push({
+          type: 'remove',
+          localLineNum: localIdx + 1,
+          remoteLineNum: -1,
+          content: localLine || ''
+        });
+        diff.push({
+          type: 'add',
+          localLineNum: -1,
+          remoteLineNum: remoteIdx + 1,
+          content: remoteLine || ''
+        });
+        localIdx++;
+        remoteIdx++;
+      }
+    }
+  }
+
+  return diff;
+}
+
+/**
+ * Filter diff to show only relevant sections with context
+ */
+export function filterDiffWithContext(diff: DiffLine[], contextLines: number = 2): DiffLine[] {
+  const result: DiffLine[] = [];
+
+  // Find all non-context lines (changes)
+  const changeIndices: number[] = [];
+  diff.forEach((line, idx) => {
+    if (line.type !== 'context') {
+      changeIndices.push(idx);
+    }
+  });
+
+  if (changeIndices.length === 0) {
+    return []; // No changes
+  }
+
+  // Group nearby changes and add context
+  const groups: Array<{start: number, end: number}> = [];
+  let currentGroup = { start: changeIndices[0]!, end: changeIndices[0]! };
+
+  for (let i = 1; i < changeIndices.length; i++) {
+    const idx = changeIndices[i]!;
+    if (idx - currentGroup.end <= contextLines * 2 + 1) {
+      // Close enough to current group, extend it
+      currentGroup.end = idx;
+    } else {
+      // Start new group
+      groups.push(currentGroup);
+      currentGroup = { start: idx, end: idx };
+    }
+  }
+  groups.push(currentGroup);
+
+  // Build result with context
+  for (const group of groups) {
+    const start = Math.max(0, group.start - contextLines);
+    const end = Math.min(diff.length - 1, group.end + contextLines);
+
+    for (let i = start; i <= end; i++) {
+      result.push(diff[i]!);
+    }
+  }
+
+  return result;
+}

package/src/sync/skill-files.ts

@@ -162,71 +162,36 @@ export async function askForOverwrite(skillIdn: string, existingContent: string,
   const gray = '\x1b[90m';
   const reset = '\x1b[0m';
 
-  // Show a GitHub-style colored diff with line numbers and context
-  const localLines = existingContent.trim().split('\n');
-  const remoteLines = newContent.trim().split('\n');
-
-  // Find the first differing section and show it with context
-  let diffStart = -1;
-  let diffEnd = -1;
-
-  // Find first difference
-  for (let i = 0; i < Math.max(localLines.length, remoteLines.length); i++) {
-    if (localLines[i] !== remoteLines[i]) {
-      diffStart = i;
-      break;
-    }
-  }
+  // Generate proper diff using LCS algorithm
+  const { generateDiff, filterDiffWithContext } = await import('./diff-utils.js');
+  const fullDiff = generateDiff(existingContent, newContent);
+  const contextDiff = filterDiffWithContext(fullDiff, 2);
 
-  if (diffStart === -1) {
-    // No differences found (shouldn't happen, but handle gracefully)
+  if (contextDiff.length === 0) {
     console.log(`${gray}   No differences found${reset}`);
     return 'no';
   }
 
-  // Find end of difference section
-  diffEnd = diffStart;
-  while (diffEnd < Math.max(localLines.length, remoteLines.length) &&
-         (localLines[diffEnd] !== remoteLines[diffEnd] ||
-          localLines[diffEnd] === undefined ||
-          remoteLines[diffEnd] === undefined)) {
-    diffEnd++;
-  }
-
-  // Show context before (2 lines)
-  const contextStart = Math.max(0, diffStart - 2);
-  for (let i = contextStart; i < diffStart; i++) {
-    if (localLines[i] !== undefined) {
-      console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
-    }
-  }
-
-  // Show the differences
-  const maxDiffLine = Math.min(diffEnd, Math.max(localLines.length, remoteLines.length));
-  for (let i = diffStart; i < maxDiffLine; i++) {
-    const localLine = localLines[i];
-    const remoteLine = remoteLines[i];
-
-    if (localLine !== undefined && (remoteLine === undefined || localLine !== remoteLine)) {
-      console.log(`${redBg} -  ${String(i + 1).padStart(3)}      ${localLine} ${reset}`);
-    }
-    if (remoteLine !== undefined && (localLine === undefined || localLine !== remoteLine)) {
-      console.log(`${greenBg} +  ${String(i + 1).padStart(3)}      ${remoteLine} ${reset}`);
-    }
-  }
-
-  // Show context after (2 lines)
-  const contextEnd = Math.min(localLines.length, diffEnd + 2);
-  for (let i = diffEnd; i < contextEnd; i++) {
-    if (localLines[i] !== undefined) {
-      console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
+  // Display the diff with proper GitHub-style formatting
+  for (const line of contextDiff) {
+    if (line.type === 'context') {
+      // Show context lines in gray
+      const lineNum = line.localLineNum !== -1 ? line.localLineNum : line.remoteLineNum;
+      console.log(`    ${String(lineNum).padStart(3)}      ${line.content}`);
+    } else if (line.type === 'remove') {
+      // Show local content being removed (red background)
+      console.log(`${redBg} -  ${String(line.localLineNum).padStart(3)}      ${line.content} ${reset}`);
+    } else if (line.type === 'add') {
+      // Show remote content being added (green background)
+      console.log(`${greenBg} +  ${String(line.remoteLineNum).padStart(3)}      ${line.content} ${reset}`);
     }
   }
 
-  // Show if there are more differences
-  const totalDiffs = Math.abs(localLines.length - remoteLines.length) + (diffEnd - diffStart);
-  if (totalDiffs > (diffEnd - diffStart)) {
-    console.log(`${gray}... (${totalDiffs - (diffEnd - diffStart)} more differences)${reset}`);
+  // Show if there are more changes beyond what we're displaying
+  const totalChanges = fullDiff.filter(line => line.type !== 'context').length;
+  const displayedChanges = contextDiff.filter(line => line.type !== 'context').length;
+  if (totalChanges > displayedChanges) {
+    console.log(`${gray}... (${totalChanges - displayedChanges} more changes)${reset}`);
   }
 
   const answer = await new Promise<string>((resolve) => {