@matt82198/aesop 0.1.0 → 0.3.1

package/tools/portability_check.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Portability gate: scan shipped surface for hardcoded personal/environment paths.
+
+Detects absolute Windows user paths (C:\\Users\\<name> / C:/Users/<name>),
+POSIX home paths (/home/<name>, /Users/<name>), and private-machine tokens
+('conductor3', 'matt8'). Allows clearly-marked examples/defaults (lines containing
+'example', 'default', or 'e.g.').
+
+Exit 0 clean, 1 with numbered file:line findings.
+Supports --json output and --root for base directory.
+"""
+
+import sys
+import os
+import json
+import re
+import glob
+import argparse
+from pathlib import Path
+
+
+def read_package_json(root):
+    """Read package.json and extract 'files' array."""
+    pkg_path = os.path.join(root, 'package.json')
+    try:
+        with open(pkg_path, 'r') as f:
+            content = json.load(f)
+        return content.get('files', [])
+    except (FileNotFoundError, json.JSONDecodeError):
+        return []
+
+
+def expand_globs(root, patterns):
+    """Expand glob patterns from package.json 'files' array."""
+    files = set()
+    for pattern in patterns:
+        # Normalize pattern to use forward slashes for glob
+        pattern = pattern.replace('\\', '/')
+        full_pattern = os.path.join(root, pattern).replace('\\', '/')
+
+        matches = glob.glob(full_pattern, recursive=True)
+        for match in matches:
+            # Use Path to normalize, convert back to string
+            normalized = str(Path(match))
+            files.add(normalized)
+
+    return sorted(files)
+
+
+def is_text_file(filepath):
+    """Check if file is likely text (not binary)."""
+    binary_extensions = {
+        '.bin', '.exe', '.dll', '.so', '.dylib',
+        '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp',
+        '.pdf', '.zip', '.tar', '.gz', '.rar',
+        '.woff', '.woff2', '.ttf', '.eot',
+        '.mp3', '.mp4', '.wav', '.mov'
+    }
+    _, ext = os.path.splitext(filepath.lower())
+    return ext not in binary_extensions
+
+
+def read_file_lines(filepath):
+    """Read file lines, handling encoding issues gracefully."""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return f.readlines()
+    except UnicodeDecodeError:
+        try:
+            with open(filepath, 'r', encoding='latin-1') as f:
+                return f.readlines()
+        except Exception:
+            return []
+    except Exception:
+        return []
+
+
+def is_exception_line(line):
+    """Check if line is marked as example/default."""
+    line_lower = line.lower()
+    return any(marker in line_lower for marker in ['example', 'default', 'e.g.'])
+
+
+def scan_line_for_paths(line):
+    """Scan a line for problematic paths and tokens."""
+    findings = []
+
+    # Windows absolute paths: C:\Users\<name> or C:/Users/<name>
+    windows_user_patterns = [
+        r'C:\\Users\\[a-zA-Z0-9_\-\.]+',
+        r'C:/Users/[a-zA-Z0-9_\-\.]+'
+    ]
+    for pattern in windows_user_patterns:
+        matches = re.finditer(pattern, line)
+        for match in matches:
+            findings.append({
+                'type': 'windows_user_path',
+                'path': match.group(0)
+            })
+
+    # POSIX home paths: /home/<name> or /Users/<name>
+    posix_patterns = [
+        r'/home/[a-zA-Z0-9_\-\.]+',
+        r'/Users/[a-zA-Z0-9_\-\.]+'
+    ]
+    for pattern in posix_patterns:
+        matches = re.finditer(pattern, line)
+        for match in matches:
+            findings.append({
+                'type': 'posix_home_path',
+                'path': match.group(0)
+            })
+
+    # Private machine tokens: 'conductor3' and 'matt8'
+    # These are simple word boundary matches (whole word)
+    for token in ['conductor3', 'matt8']:
+        # Use word boundaries to avoid false positives in longer identifiers
+        pattern = r'\b' + re.escape(token) + r'\b'
+        matches = re.finditer(pattern, line)
+        for match in matches:
+            findings.append({
+                'type': 'private_token',
+                'token': token
+            })
+
+    return findings
+
+
+def scan_shipped_surface(root, json_output=False):
+    """Scan shipped surface for portability issues."""
+    patterns = read_package_json(root)
+    if not patterns:
+        print("Warning: Could not read package.json 'files' array", file=sys.stderr)
+        return []
+
+    files = expand_globs(root, patterns)
+    all_findings = []
+
+    for filepath in files:
+        if not os.path.isfile(filepath) or not is_text_file(filepath):
+            continue
+
+        lines = read_file_lines(filepath)
+        for line_num, line in enumerate(lines, 1):
+            # Skip exception lines (marked as example/default)
+            if is_exception_line(line):
+                continue
+
+            # Scan for issues
+            issues = scan_line_for_paths(line)
+            for issue in issues:
+                relative_path = os.path.relpath(filepath, root)
+                finding = {
+                    'file': relative_path,
+                    'line': line_num,
+                    'content': line.rstrip()[:100],  # First 100 chars
+                    **issue
+                }
+                all_findings.append(finding)
+
+    return all_findings
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Portability gate: scan for hardcoded personal paths'
+    )
+    parser.add_argument(
+        '--root',
+        default='.',
+        help='Root directory to scan (default: current directory)'
+    )
+    parser.add_argument(
+        '--json',
+        action='store_true',
+        help='Output findings as JSON'
+    )
+
+    args = parser.parse_args()
+    root = os.path.abspath(args.root)
+
+    findings = scan_shipped_surface(root, json_output=args.json)
+
+    if args.json:
+        print(json.dumps(findings, indent=2))
+    else:
+        if findings:
+            print(f"Found {len(findings)} portability issue(s):", file=sys.stderr)
+            for i, finding in enumerate(findings, 1):
+                print(
+                    f"{i}. {finding['file']}:{finding['line']}: "
+                    f"{finding.get('type', 'unknown')}",
+                    file=sys.stderr
+                )
+                if finding.get('path'):
+                    print(f"   Path: {finding['path']}", file=sys.stderr)
+                if finding.get('token'):
+                    print(f"   Token: {finding['token']}", file=sys.stderr)
+                print(f"   {finding['content']}", file=sys.stderr)
+
+    return 1 if findings else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/tools/proposals.mjs

@@ -19,6 +19,47 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { acquireLock, releaseLock } from './lock.mjs';
 
+// === Windows-portable atomic rename with EPERM/EBUSY retry ===
+// On Windows, renaming over a file that another process has open throws EPERM.
+// This wrapper provides bounded retry with exponential backoff and cleanup.
+function atomicRename(tmpPath, targetPath) {
+  const maxRetries = 20;
+  const baseDelayMs = 50;
+
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      fs.renameSync(tmpPath, targetPath);
+      return true; // Success
+    } catch (e) {
+      if ((e.code === 'EPERM' || e.code === 'EACCES' || e.code === 'EBUSY') && i < maxRetries - 1) {
+        // Retry on Windows EPERM/EACCES/EBUSY (file held by reader)
+        // Exponential backoff: 50ms, 100ms, 150ms, ..., 950ms (max ~9.5s total)
+        const delayMs = baseDelayMs * (i + 1);
+        const start = Date.now();
+        while (Date.now() - start < delayMs) {
+          // Busy-wait to avoid scheduling overhead
+        }
+      } else {
+        // Final failure or non-retryable error; clean up .tmp file and return false
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch {
+          // Cleanup failed; best effort
+        }
+        return false;
+      }
+    }
+  }
+
+  // Final failure after all retries; clean up and return false
+  try {
+    fs.unlinkSync(tmpPath);
+  } catch {
+    // Cleanup failed; best effort
+  }
+  return false;
+}
+
 // === Arg parsing ===
 const args = process.argv.slice(2);
 let command = '';
@@ -193,11 +234,15 @@ function moveProposal(status) {
       return b.trim();
     }).filter(b => b).join('\n\n---\n\n');
 
-    // ATOMIC WRITE: write to temp file, then rename (atomic on all platforms)
+    // ATOMIC WRITE: write to temp file, then rename with retry (Windows-safe)
     const tmpFile = proposalsFile + '.tmp';
     try {
       fs.writeFileSync(tmpFile, updatedContent.trim() ? updatedContent + '\n' : '', 'utf8');
-      fs.renameSync(tmpFile, proposalsFile);
+      // Use atomicRename for Windows-safe atomic replace (handles EPERM/EBUSY retries)
+      if (!atomicRename(tmpFile, proposalsFile)) {
+        console.error(`Error: Could not write ${proposalsFile} after retry`);
+        process.exit(1);
+      }
     } catch (e) {
       // Clean up temp file if it exists
       try { fs.unlinkSync(tmpFile); } catch { }

package/tools/reconcile.py

@@ -60,9 +60,11 @@ manufacturing a false "in sync".
 
 ## Usage
 
-    python tools/reconcile.py --state-md STATE.md --db state/events.db
-    python tools/reconcile.py --state-md STATE.md --db state/events.db --resolve
-    python tools/reconcile.py --state-md STATE.md --db state/events.db --json
+    python tools/reconcile.py --state-md STATE.md
+    python tools/reconcile.py --state-md STATE.md --resolve
+    python tools/reconcile.py --state-md STATE.md --json
+
+(DB path defaults to state/tracker_events.db; override with --db if needed.)
 
 Exit codes: 0 = no drift (or drift cleanly resolved), 1 = drift detected and
 NOT resolved (report mode), 2 = usage/file error.
@@ -81,6 +83,7 @@ if str(ROOT) not in sys.path:
     sys.path.insert(0, str(ROOT))
 
 from state_store.store import EventStore  # noqa: E402
+from tools.common import get_state_db_path  # noqa: E402
 
 PHASE_RE = re.compile(r"^##\s*Phase:\s*`([^`]+)`", re.MULTILINE)
 
@@ -251,7 +254,7 @@ def _format_human(report: dict) -> str:
 def main(argv=None) -> int:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("--state-md", default="STATE.md", help="Path to STATE.md (default: ./STATE.md)")
-    parser.add_argument("--db", default="state/events.db", help="Path to state_store SQLite db")
+    parser.add_argument("--db", default=str(get_state_db_path()), help="Path to state_store SQLite db (default: state/tracker_events.db)")
     parser.add_argument("--resolve", action="store_true", help="Fix drift by writing the authoritative value to the non-authoritative side (opt-in; default is detect+report only)")
     parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON instead of human text")
     args = parser.parse_args(argv)