newo 2.0.4 → 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,60 +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 differences and show with 2 lines context before/after
-    const diffs = [];
-    // Simple diff algorithm to find changes
-    let localIdx = 0;
-    let remoteIdx = 0;
-    while (localIdx < localLines.length || remoteIdx < remoteLines.length) {
-        const localLine = localLines[localIdx];
-        const remoteLine = remoteLines[remoteIdx];
-        if (localLine !== remoteLine) {
-            if (localLine !== undefined && remoteLine !== undefined) {
-                diffs.push({ localIndex: localIdx, remoteIndex: remoteIdx, type: 'change' });
-            }
-            else if (localLine !== undefined) {
-                diffs.push({ localIndex: localIdx, remoteIndex: -1, type: 'remove' });
-            }
-            else if (remoteLine !== undefined) {
-                diffs.push({ localIndex: -1, remoteIndex: remoteIdx, type: 'add' });
-            }
-        }
-        if (localLine !== undefined)
-            localIdx++;
-        if (remoteLine !== undefined)
-            remoteIdx++;
+    // 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';
     }
-    // Show diffs with context (2 lines before/after each change)
-    let shown = 0;
-    const maxDiffGroups = 3;
-    for (const diff of diffs.slice(0, maxDiffGroups)) {
-        if (shown > 0)
-            console.log(''); // Separator between diff groups
-        // Show context before
-        const contextStart = Math.max(0, diff.localIndex - 2);
-        for (let i = contextStart; i < diff.localIndex && i < localLines.length; i++) {
-            console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
-        }
-        // Show the actual diff
-        if (diff.type === 'change' || diff.type === 'remove') {
-            console.log(`${redBg} -  ${String(diff.localIndex + 1).padStart(3)}      ${localLines[diff.localIndex]} ${reset}`);
+    // 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}`);
         }
-        if (diff.type === 'change' || diff.type === 'add') {
-            console.log(`${greenBg} +  ${String(diff.remoteIndex + 1).padStart(3)}      ${remoteLines[diff.remoteIndex]} ${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
-        const contextEnd = Math.min(localLines.length, diff.localIndex + 3);
-        for (let i = diff.localIndex + 1; i < contextEnd; i++) {
-            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}`);
         }
-        shown++;
     }
-    if (diffs.length > maxDiffGroups) {
-        console.log(`${gray}... (${diffs.length - maxDiffGroups} more diff groups)${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.4",
+  "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,67 +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 differences and show with 2 lines context before/after
-  const diffs: Array<{localIndex: number, remoteIndex: number, type: 'change' | 'add' | 'remove'}> = [];
-
-  // Simple diff algorithm to find changes
-  let localIdx = 0;
-  let remoteIdx = 0;
-
-  while (localIdx < localLines.length || remoteIdx < remoteLines.length) {
-    const localLine = localLines[localIdx];
-    const remoteLine = remoteLines[remoteIdx];
-
-    if (localLine !== remoteLine) {
-      if (localLine !== undefined && remoteLine !== undefined) {
-        diffs.push({localIndex: localIdx, remoteIndex: remoteIdx, type: 'change'});
-      } else if (localLine !== undefined) {
-        diffs.push({localIndex: localIdx, remoteIndex: -1, type: 'remove'});
-      } else if (remoteLine !== undefined) {
-        diffs.push({localIndex: -1, remoteIndex: remoteIdx, type: 'add'});
-      }
-    }
-
-    if (localLine !== undefined) localIdx++;
-    if (remoteLine !== undefined) remoteIdx++;
+  // 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';
   }
 
-  // Show diffs with context (2 lines before/after each change)
-  let shown = 0;
-  const maxDiffGroups = 3;
-
-  for (const diff of diffs.slice(0, maxDiffGroups)) {
-    if (shown > 0) console.log(''); // Separator between diff groups
-
-    // Show context before
-    const contextStart = Math.max(0, diff.localIndex - 2);
-    for (let i = contextStart; i < diff.localIndex && i < localLines.length; i++) {
-      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 the actual diff
-    if (diff.type === 'change' || diff.type === 'remove') {
-      console.log(`${redBg} -  ${String(diff.localIndex + 1).padStart(3)}      ${localLines[diff.localIndex]} ${reset}`);
-    }
-    if (diff.type === 'change' || diff.type === 'add') {
-      console.log(`${greenBg} +  ${String(diff.remoteIndex + 1).padStart(3)}      ${remoteLines[diff.remoteIndex]} ${reset}`);
-    }
-
-    // Show context after
-    const contextEnd = Math.min(localLines.length, diff.localIndex + 3);
-    for (let i = diff.localIndex + 1; i < contextEnd; i++) {
-      console.log(`    ${String(i + 1).padStart(3)}      ${localLines[i]}`);
-    }
-
-    shown++;
   }
 
-  if (diffs.length > maxDiffGroups) {
-    console.log(`${gray}... (${diffs.length - maxDiffGroups} more diff groups)${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) => {