@a5gard/asgard 0.0.1 → 0.0.3

package/src/git/sync-repo.js

@@ -2,15 +2,200 @@ import fs from 'fs-extra';
 import path from 'path';
 import simpleGit from 'simple-git';
 import { execSync } from 'child_process';
+import { Pwsh } from '../git/helpers.js'
+import inquirer from 'inquirer';
+import { fileURLToPath } from 'url';
+import 'dotenv/config';
 
-export async function syncRepo() {
+const CONFIG_PATH = path.join(process.cwd(), 'config.asgard');
+
+export async function promptConfig() {
+  let existingConfig = {};
+
+  if (fs.existsSync(CONFIG_PATH)) {
+    existingConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  }
+  const currentDir = process.cwd();
+  const questions = [
+    {
+      type: 'input',
+      name: 'owner',
+      message: 'GitHub Owner (Username or Org):',
+      default: existingConfig.owner,
+      validate: (input) => input ? true : 'Owner is required',
+    },
+    {
+      type: 'input',
+      name: 'repo',
+      message: 'GitHub Repository Name:',
+      default: existingConfig.repo,
+      validate: (input) => input ? true : 'Repo is required',
+    },
+    {
+      type: 'list',
+      name: 'pkgMgr',
+      message: 'Package Manager:',
+      choices: ['npm', 'yarn', 'pnpm', 'bun'],
+      default: existingConfig.pkgMgr || 'npm',
+    },
+    {
+      type: 'input',
+      name: 'branch',
+      message: 'Default Branch:',
+      default: existingConfig.branch || 'main',
+    },
+    {
+      type: 'input',
+      name: 'workspacePath',
+      message: 'Confirm Workspace Root Path:',
+      default: currentDir, // Just defaults to where you are
+    },
+    {
+      type: 'confirm',
+      name: 'icons',
+      message: 'Enable Icons?',
+      default: existingConfig.icons || false,
+    },
+    {
+      type: 'confirm',
+      name: 'uiComps',
+      message: 'Enable UI Components?',
+      default: existingConfig.uiComps || false,
+    }
+  ];
+
+const answers = await inquirer.prompt(questions);
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(answers, null, 2));
+  return {
+    ...answers,
+    token: process.env.GITHUB_TOKEN,
+  };
+}
+export async function syncRepo1() {
   try {
     const cwd = process.cwd();
-    execSync('git add .', { cwd, stdio: 'inherit' });
-    execSync('git commit -m "Syncing local repo with remote" || true', { cwd, stdio: 'inherit' });
-    execSync('git pull --rebase', { cwd, stdio: 'inherit' });
-    execSync('git push', { cwd, stdio: 'inherit' });
+    await Pwsh('git add *');
+    await Pwsh('git diff --cached --quiet || git commit -m "Syncing local repo with remote"');
+    await Pwsh('git pull --rebase');
+    await Pwsh('git push');
   } catch (error) {
     throw new Error(`Sync failed on branch detection/sync: ${error.message}`);
   }
+}
+
+const configasgard = {
+  repo: '',
+  owner: '',
+  pkgMgr: '',
+  branch: '',
+  workspacePath: '',
+  icons: false,
+  uiComps: false,
+}
+export async function getLocalFiles(dir, baseDir = dir) {
+  const files = fs.readdirSync(dir);
+  let results = [];
+
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      results = results.concat(await this.getLocalFiles(fullPath, baseDir));
+    } else {
+      const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+      const content = fs.readFileSync(fullPath, { encoding: 'base64' });
+      results.push({ path: relativePath, content });
+    }
+  }
+  return results;
+}
+
+export async function pushChanges(okit, owner, repo, branch, files, message) {
+  const { data: refData } = await okit.rest.git.getRef({ owner, repo, ref: `heads/${branch}` });
+  const currentCommitSha = refData.object.sha;
+
+  const { data: commitData } = await okit.rest.git.getCommit({ owner, repo, commit_sha: currentCommitSha });
+
+  const tree = files.map(file => ({
+    path: file.path,
+    mode: '100644',
+    type: 'blob',
+    content: Buffer.from(file.content, 'base64').toString('utf-8')
+  }));
+
+  const { data: treeData } = await okit.rest.git.createTree({
+    owner, repo, tree, base_tree: commitData.tree.sha
+  });
+
+  const { data: newCommitData } = await okit.rest.git.createCommit({
+    owner, repo, message, tree: treeData.sha, parents: [currentCommitSha]
+  });
+
+  await okit.rest.git.updateRef({
+    owner, repo, ref: `heads/${branch}`, sha: newCommitData.sha
+  });
+}
+
+export async function pullLatestChanges(okit, owner, repo, branch, workspacePath) {
+  try {
+    const refResponse = await okit.rest.git.getRef({ owner, repo, ref: `heads/${branch}` });
+    const latestCommitSha = refResponse.data.object.sha;
+
+    const commitResponse = await okit.rest.git.getCommit({ owner, repo, commit_sha: latestCommitSha });
+
+    const treeResponse = await okit.rest.git.getTree({
+      owner,
+      repo,
+      tree_sha: commitResponse.data.tree.sha,
+      recursive: 'true'
+    });
+
+    for (const item of treeResponse.data.tree) {
+      if (item.type === 'blob' && item.path) {
+        if (!item.sha) continue;
+
+        const blobResponse = await okit.rest.git.getBlob({ owner, repo, file_sha: item.sha });
+        const content = Buffer.from(blobResponse.data.content, 'base64').toString('utf-8');
+
+        const filePath = path.join(workspacePath, item.path);
+        const fileDir = path.dirname(filePath);
+
+        if (!fs.existsSync(fileDir)) {
+          fs.mkdirSync(fileDir, { recursive: true });
+        }
+
+        fs.writeFileSync(filePath, content);
+      }
+    }
+    console.log('Successfully pulled latest changes');
+  } catch (error) {
+    if (error.status === 404) {
+      console.log('Branch does not exist on remote');
+    } else {
+      console.error('Error pulling changes:', error.message);
+      throw error;
+    }
+  }
+}
+
+export async function syncRepo(ctx) {
+  const { token, owner, repo, branch, workspacePath } = ctx;
+  const okit = new Octokit({ auth: token });
+
+  try {
+    console.log("Syncing via Octokit...");
+
+    // 1. Pull logic (using your existing snippet)
+    await pullLatestChanges(okit, owner, repo, branch, workspacePath);
+
+    // 2. Scan and Push
+    const localFiles = await getLocalFiles(workspacePath);
+    if (localFiles.length > 0) {
+      await pushChanges(okit, owner, repo, branch, localFiles, "Syncing local repo with remote");
+      console.log("Push successful.");
+    } else {
+      console.log("Nothing to push.");
+    }
+  } catch (error) {
+    console.error(`Sync failed: ${error.message}`);
+  }
 }