specdrive-cli 0.1.9 → 0.1.12

package/scripts/anti-redundancy.js

@@ -1,177 +1,177 @@
-const fs = require("fs");
-const path = require("path");
-
-const projectRoot = process.cwd();
-
-function readJson(filePath) {
-  try {
-    if (fs.existsSync(filePath)) {
-      return JSON.parse(fs.readFileSync(filePath, "utf8"));
-    }
-  } catch (error) {
-    console.error(`⚠️  Could not parse ${filePath}: ${error.message}`);
-  }
-  return null;
-}
-
-function getInstalledDependencies() {
-  const packageJson = readJson(path.join(projectRoot, "package.json"));
-  if (!packageJson) return [];
-
-  return [
-    ...Object.keys(packageJson.dependencies || {}),
-    ...Object.keys(packageJson.devDependencies || {})
-  ];
-}
-
-function listFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]) {
-  if (!fs.existsSync(dir)) return [];
-
-  let results = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results = results.concat(listFiles(fullPath, extensions));
-    } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
-      results.push(fullPath);
-    }
-  }
-
-  return results;
-}
-
-function detectExistingAssets() {
-  const srcDir = path.join(projectRoot, "src");
-  const files = listFiles(srcDir);
-
-  const assets = {
-    components: [],
-    services: [],
-    hooks: [],
-    utils: [],
-    api: [],
-    models: [],
-    constants: []
-  };
-
-  files.forEach((file) => {
-    const relative = path.relative(projectRoot, file).replace(/\\/g, "/");
-
-    if (relative.includes("/components/") || relative.includes("/ui/")) {
-      assets.components.push(relative);
-    }
-
-    if (relative.includes("/services/") || relative.includes("/api/")) {
-      assets.services.push(relative);
-    }
-
-    if (relative.includes("/hooks/") || relative.startsWith("use-")) {
-      assets.hooks.push(relative);
-    }
-
-    if (relative.includes("/utils/") || relative.includes("/helpers/")) {
-      assets.utils.push(relative);
-    }
-
-    if (relative.includes("/models/") || relative.includes("/entities/")) {
-      assets.models.push(relative);
-    }
-
-    if (relative.includes("/constants/") || relative.includes("/config/")) {
-      assets.constants.push(relative);
-    }
-  });
-
-  return assets;
-}
-
-function checkRedundancy(plannedItems) {
-  const existingAssets = detectExistingAssets();
-  const installedDependencies = getInstalledDependencies();
-
-  const report = plannedItems.map((item) => {
-    let exists = false;
-    let location = null;
-
-    switch (item.type) {
-      case "component":
-        exists = existingAssets.components.some((p) => p.includes(item.name));
-        if (exists) {
-          location = existingAssets.components.find((p) => p.includes(item.name));
-        }
-        break;
-      case "service":
-      case "api":
-        exists = existingAssets.services.some((p) => p.includes(item.name));
-        if (exists) {
-          location = existingAssets.services.find((p) => p.includes(item.name));
-        }
-        break;
-      case "hook":
-        exists = existingAssets.hooks.some((p) => p.includes(item.name));
-        if (exists) {
-          location = existingAssets.hooks.find((p) => p.includes(item.name));
-        }
-        break;
-      case "utility":
-        exists = existingAssets.utils.some((p) => p.includes(item.name));
-        if (exists) {
-          location = existingAssets.utils.find((p) => p.includes(item.name));
-        }
-        break;
-      case "model":
-      case "entity":
-        exists = existingAssets.models.some((p) => p.includes(item.name));
-        if (exists) {
-          location = existingAssets.models.find((p) => p.includes(item.name));
-        }
-        break;
-      case "package":
-      case "dependency":
-        exists = installedDependencies.includes(item.name);
-        location = exists ? "package.json" : null;
-        break;
-      default:
-        exists = false;
-        location = null;
-    }
-
-    return {
-      name: item.name,
-      type: item.type,
-      exists,
-      action: exists ? "reuse" : "create",
-      location
-    };
-  });
-
-  return {
-    feature: "current",
-    items: report,
-    existingAssets,
-    installedDependencies
-  };
-}
-
-function main() {
-  const plannedItemsPath = process.argv[2];
-
-  if (!plannedItemsPath) {
-    console.error("❌ Usage: node anti-redundancy.js <planned-items.json>");
-    process.exit(1);
-  }
-
-  const plannedItems = readJson(path.resolve(plannedItemsPath));
-
-  if (!plannedItems || !Array.isArray(plannedItems)) {
-    console.error("❌ planned-items.json must contain an array of items.");
-    process.exit(1);
-  }
-
-  const report = checkRedundancy(plannedItems);
-  console.log(JSON.stringify(report, null, 2));
-}
-
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function readJson(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+  } catch (error) {
+    console.error(`⚠️  Could not parse ${filePath}: ${error.message}`);
+  }
+  return null;
+}
+
+function getInstalledDependencies() {
+  const packageJson = readJson(path.join(projectRoot, "package.json"));
+  if (!packageJson) return [];
+
+  return [
+    ...Object.keys(packageJson.dependencies || {}),
+    ...Object.keys(packageJson.devDependencies || {})
+  ];
+}
+
+function listFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs"]) {
+  if (!fs.existsSync(dir)) return [];
+
+  let results = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results = results.concat(listFiles(fullPath, extensions));
+    } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+function detectExistingAssets() {
+  const srcDir = path.join(projectRoot, "src");
+  const files = listFiles(srcDir);
+
+  const assets = {
+    components: [],
+    services: [],
+    hooks: [],
+    utils: [],
+    api: [],
+    models: [],
+    constants: []
+  };
+
+  files.forEach((file) => {
+    const relative = path.relative(projectRoot, file).replace(/\\/g, "/");
+
+    if (relative.includes("/components/") || relative.includes("/ui/")) {
+      assets.components.push(relative);
+    }
+
+    if (relative.includes("/services/") || relative.includes("/api/")) {
+      assets.services.push(relative);
+    }
+
+    if (relative.includes("/hooks/") || relative.startsWith("use-")) {
+      assets.hooks.push(relative);
+    }
+
+    if (relative.includes("/utils/") || relative.includes("/helpers/")) {
+      assets.utils.push(relative);
+    }
+
+    if (relative.includes("/models/") || relative.includes("/entities/")) {
+      assets.models.push(relative);
+    }
+
+    if (relative.includes("/constants/") || relative.includes("/config/")) {
+      assets.constants.push(relative);
+    }
+  });
+
+  return assets;
+}
+
+function checkRedundancy(plannedItems) {
+  const existingAssets = detectExistingAssets();
+  const installedDependencies = getInstalledDependencies();
+
+  const report = plannedItems.map((item) => {
+    let exists = false;
+    let location = null;
+
+    switch (item.type) {
+      case "component":
+        exists = existingAssets.components.some((p) => p.includes(item.name));
+        if (exists) {
+          location = existingAssets.components.find((p) => p.includes(item.name));
+        }
+        break;
+      case "service":
+      case "api":
+        exists = existingAssets.services.some((p) => p.includes(item.name));
+        if (exists) {
+          location = existingAssets.services.find((p) => p.includes(item.name));
+        }
+        break;
+      case "hook":
+        exists = existingAssets.hooks.some((p) => p.includes(item.name));
+        if (exists) {
+          location = existingAssets.hooks.find((p) => p.includes(item.name));
+        }
+        break;
+      case "utility":
+        exists = existingAssets.utils.some((p) => p.includes(item.name));
+        if (exists) {
+          location = existingAssets.utils.find((p) => p.includes(item.name));
+        }
+        break;
+      case "model":
+      case "entity":
+        exists = existingAssets.models.some((p) => p.includes(item.name));
+        if (exists) {
+          location = existingAssets.models.find((p) => p.includes(item.name));
+        }
+        break;
+      case "package":
+      case "dependency":
+        exists = installedDependencies.includes(item.name);
+        location = exists ? "package.json" : null;
+        break;
+      default:
+        exists = false;
+        location = null;
+    }
+
+    return {
+      name: item.name,
+      type: item.type,
+      exists,
+      action: exists ? "reuse" : "create",
+      location
+    };
+  });
+
+  return {
+    feature: "current",
+    items: report,
+    existingAssets,
+    installedDependencies
+  };
+}
+
+function main() {
+  const plannedItemsPath = process.argv[2];
+
+  if (!plannedItemsPath) {
+    console.error("❌ Usage: node anti-redundancy.js <planned-items.json>");
+    process.exit(1);
+  }
+
+  const plannedItems = readJson(path.resolve(plannedItemsPath));
+
+  if (!plannedItems || !Array.isArray(plannedItems)) {
+    console.error("❌ planned-items.json must contain an array of items.");
+    process.exit(1);
+  }
+
+  const report = checkRedundancy(plannedItems);
+  console.log(JSON.stringify(report, null, 2));
+}
+
 main();

package/scripts/audit-log.js

@@ -1,47 +1,47 @@
-const fs = require("fs");
-const path = require("path");
-
-const projectRoot = process.cwd();
-const auditLogPath = path.join(projectRoot, ".sdrive", "audit-log.json");
-
-function loadAuditLog() {
-  if (!fs.existsSync(auditLogPath)) {
-    return { events: [] };
-  }
-
-  try {
-    return JSON.parse(fs.readFileSync(auditLogPath, "utf8"));
-  } catch (error) {
-    console.error(`⚠️  Could not parse audit log: ${error.message}`);
-    return { events: [] };
-  }
-}
-
-function saveAuditLog(log) {
-  fs.writeFileSync(auditLogPath, JSON.stringify(log, null, 2));
-}
-
-function logEvent(event, details = {}) {
-  const log = loadAuditLog();
-
-  log.events.push({
-    timestamp: new Date().toISOString(),
-    ...details,
-    event
-  });
-
-  saveAuditLog(log);
-  console.log(`📝 Audit: ${event}`);
-}
-
-function getRecentEvents(count = 10) {
-  const log = loadAuditLog();
-  return log.events.slice(-count).reverse();
-}
-
-module.exports = {
-  logEvent,
-  loadAuditLog,
-  saveAuditLog,
-  getRecentEvents
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const auditLogPath = path.join(projectRoot, ".sdrive", "audit-log.json");
+
+function loadAuditLog() {
+  if (!fs.existsSync(auditLogPath)) {
+    return { events: [] };
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(auditLogPath, "utf8"));
+  } catch (error) {
+    console.error(`⚠️  Could not parse audit log: ${error.message}`);
+    return { events: [] };
+  }
+}
+
+function saveAuditLog(log) {
+  fs.writeFileSync(auditLogPath, JSON.stringify(log, null, 2));
+}
+
+function logEvent(event, details = {}) {
+  const log = loadAuditLog();
+
+  log.events.push({
+    timestamp: new Date().toISOString(),
+    ...details,
+    event
+  });
+
+  saveAuditLog(log);
+  console.log(`📝 Audit: ${event}`);
+}
+
+function getRecentEvents(count = 10) {
+  const log = loadAuditLog();
+  return log.events.slice(-count).reverse();
+}
+
+module.exports = {
+  logEvent,
+  loadAuditLog,
+  saveAuditLog,
+  getRecentEvents
 };

package/scripts/check-permission.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function getCurrentUser() {
+  try {
+    return execSync("git config user.name", { encoding: "utf8" }).trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+function loadTeam() {
+  const teamPath = path.join(projectRoot, ".sdrive", "team.json");
+
+  if (!fs.existsSync(teamPath)) {
+    console.error("❌ team.json not found.");
+    process.exit(1);
+  }
+
+  return JSON.parse(fs.readFileSync(teamPath, "utf8"));
+}
+
+function loadPermissions() {
+  const permPath = path.join(projectRoot, ".sdrive", "commands", "permissions.json");
+
+  if (!fs.existsSync(permPath)) {
+    console.error("❌ permissions.json not found.");
+    process.exit(1);
+  }
+
+  return JSON.parse(fs.readFileSync(permPath, "utf8"));
+}
+
+function getUserRole(username) {
+  const team = loadTeam();
+  const member = team.members?.find((m) => m.username === username);
+  return member ? member.role : null;
+}
+
+function checkPermission(commandType, commandName) {
+  const username = getCurrentUser();
+
+  if (!username) {
+    console.error("❌ Could not detect Git user. Set git config user.name.");
+    process.exit(1);
+  }
+
+  const role = getUserRole(username);
+
+  if (!role) {
+    console.error(`❌ User "${username}" is not in team.json.`);
+    process.exit(1);
+  }
+
+  const permissions = loadPermissions();
+  const rules = commandType === "cli" ? permissions.cli : permissions.rules;
+  const allowedRoles = rules[commandName];
+
+  if (!allowedRoles) {
+    console.log(`⚠️  No permission rule for ${commandType}:${commandName}. Allowing by default.`);
+    process.exit(0);
+  }
+
+  if (!allowedRoles.includes(role)) {
+    console.error(`❌ User "${username}" (${role}) is not allowed to run ${commandType}:${commandName}.`);
+    console.error(`   Allowed roles: ${allowedRoles.join(", ")}`);
+    process.exit(1);
+  }
+
+  console.log(`✅ User "${username}" (${role}) is allowed.`);
+  process.exit(0);
+}
+
+const commandType = process.argv[2];
+const commandName = process.argv[3];
+
+if (!commandType || !commandName) {
+  console.error("❌ Usage: node check-permission.js <cli|slash> <command>");
+  process.exit(1);
+}
+
+checkPermission(commandType, commandName);

package/scripts/diff-spec.js

@@ -0,0 +1,51 @@
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+
+function readLines(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+  return fs.readFileSync(filePath, "utf8").split("\n");
+}
+
+function simpleDiff(oldFile, newFile) {
+  const oldLines = readLines(oldFile);
+  const newLines = readLines(newFile);
+
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+
+  const added = newLines.filter((line) => !oldSet.has(line));
+  const removed = oldLines.filter((line) => !newSet.has(line));
+
+  console.log(`\n📄 Diff between:`);
+  console.log(`  Old: ${path.basename(oldFile)}`);
+  console.log(`  New: ${path.basename(newFile)}\n`);
+
+  if (added.length === 0 && removed.length === 0) {
+    console.log("✅ No changes detected.");
+    return;
+  }
+
+  if (removed.length > 0) {
+    console.log("❌ Removed:");
+    removed.forEach((line) => console.log(`  - ${line}`));
+  }
+
+  if (added.length > 0) {
+    console.log("✅ Added:");
+    added.forEach((line) => console.log(`  + ${line}`));
+  }
+}
+
+const oldFile = process.argv[2];
+const newFile = process.argv[3];
+
+if (!oldFile || !newFile) {
+  console.error("❌ Usage: node diff-spec.js <old-file> <new-file>");
+  process.exit(1);
+}
+
+simpleDiff(path.resolve(oldFile), path.resolve(newFile));

package/scripts/diff-version.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd();
+const sdriveRoot = path.join(projectRoot, ".sdrive");
+
+const featureName = process.argv[2];
+const versionA = process.argv[3];
+const versionB = process.argv[4];
+
+if (!featureName || !versionA || !versionB) {
+  console.error("❌ Usage: node diff-version.js <feature> <v1> <v2>");
+  process.exit(1);
+}
+
+function findFile(baseDir, version, fileName) {
+  const candidate = path.join(baseDir, featureName, version, fileName);
+
+  if (fs.existsSync(candidate)) {
+    return candidate;
+  }
+
+  return null;
+}
+
+function readLines(filePath) {
+  return fs.readFileSync(filePath, "utf8").split("\n");
+}
+
+function simpleDiff(oldLines, newLines) {
+  const added = [];
+  const removed = [];
+  const unchanged = [];
+
+  const oldSet = new Set(oldLines);
+  const newSet = new Set(newLines);
+
+  newLines.forEach((line) => {
+    if (oldSet.has(line)) {
+      unchanged.push(line);
+    } else {
+      added.push(line);
+    }
+  });
+
+  oldLines.forEach((line) => {
+    if (!newSet.has(line)) {
+      removed.push(line);
+    }
+  });
+
+  return { added, removed, unchanged };
+}
+
+function diffFile(fileName, label) {
+  const specA = findFile(path.join(sdriveRoot, "specs", "ongoing"), versionA, fileName);
+  const specB = findFile(path.join(sdriveRoot, "specs", "ongoing"), versionB, fileName);
+
+  if (!specA || !specB) {
+    console.log(`\n⚠️  ${label}: not both versions have this file. Skipping.`);
+    return;
+  }
+
+  const oldLines = readLines(specA);
+  const newLines = readLines(specB);
+  const { added, removed } = simpleDiff(oldLines, newLines);
+
+  console.log(`\n📄 ${label} (${versionA} → ${versionB})`);
+
+  if (added.length === 0 && removed.length === 0) {
+    console.log("   ✅ No changes.");
+    return;
+  }
+
+  if (removed.length > 0) {
+    console.log("   ❌ Removed:");
+    removed.forEach((line) => console.log(`     - ${line}`));
+  }
+
+  if (added.length > 0) {
+    console.log("   ✅ Added:");
+    added.forEach((line) => console.log(`     + ${line}`));
+  }
+}
+
+function main() {
+  console.log(`\n🔍 Diff: ${featureName} (${versionA} → ${versionB})`);
+
+  diffFile("spec.md", "Specification");
+  diffFile("plan.md", "Plan");
+  diffFile("tasks.md", "Tasks");
+}
+
+main();