@pixelbyte-software/pixcode 1.47.0 → 1.47.2

package/scripts/smoke/git-install-update.mjs

@@ -0,0 +1,141 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const serverIndex = fs.readFileSync('server/index.js', 'utf8');
+const modal = fs.readFileSync('src/components/version-upgrade/view/VersionUpgradeModal.tsx', 'utf8');
+const updater = fs.readFileSync('scripts/update-git-install.mjs', 'utf8');
+const updaterPath = path.resolve('scripts/update-git-install.mjs');
+
+assert.match(
+  serverIndex,
+  /update-git-install\.mjs/,
+  'Git install updates should use the safe updater script instead of raw git pull.',
+);
+
+assert.doesNotMatch(
+  serverIndex,
+  /git checkout main && git pull && npm install/,
+  'Server update command should not use the brittle raw git checkout/pull/install chain.',
+);
+
+assert.match(
+  modal,
+  /node scripts\/update-git-install\.mjs/,
+  'Version modal should show the safe git updater command.',
+);
+
+assert.match(
+  updater,
+  /stash[\s\S]*push[\s\S]*--include-untracked[\s\S]*--message/,
+  'Safe updater should stash dirty tracked and untracked files before updating.',
+);
+
+assert.match(
+  updater,
+  /branch[\s\S]*backupBranch/,
+  'Safe updater should preserve divergent local commits in a backup branch.',
+);
+
+assert.match(
+  updater,
+  /reset[\s\S]*--hard[\s\S]*origin\/main/,
+  'Safe updater should be able to normalize a divergent install checkout after preserving it.',
+);
+
+assert.match(
+  updater,
+  /npm[\s\S]*install[\s\S]*--no-audit[\s\S]*--no-fund/,
+  'Safe updater should reinstall dependencies after updating source files.',
+);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pixcode-git-update-'));
+const origin = path.join(tempRoot, 'origin.git');
+const source = path.join(tempRoot, 'source');
+const install = path.join(tempRoot, 'install');
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Pixcode Smoke',
+      GIT_AUTHOR_EMAIL: 'smoke@pixcode.local',
+      GIT_COMMITTER_NAME: 'Pixcode Smoke',
+      GIT_COMMITTER_EMAIL: 'smoke@pixcode.local',
+    },
+  });
+
+  assert.equal(
+    result.status,
+    0,
+    `${command} ${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+
+  return result.stdout.trim();
+}
+
+function writePackage(version) {
+  fs.writeFileSync(
+    path.join(source, 'package.json'),
+    JSON.stringify({ name: 'pixcode-update-smoke', version }, null, 2),
+  );
+  fs.writeFileSync(
+    path.join(source, 'package-lock.json'),
+    JSON.stringify({
+      name: 'pixcode-update-smoke',
+      version,
+      lockfileVersion: 3,
+      requires: true,
+      packages: {
+        '': {
+          name: 'pixcode-update-smoke',
+          version,
+        },
+      },
+    }, null, 2),
+  );
+}
+
+fs.mkdirSync(source, { recursive: true });
+run('git', ['init', '--bare', origin], tempRoot);
+run('git', ['init', '-b', 'main'], source);
+writePackage('1.0.0');
+fs.writeFileSync(path.join(source, 'tracked.txt'), 'old\n');
+run('git', ['add', '.'], source);
+run('git', ['commit', '-m', 'initial'], source);
+run('git', ['remote', 'add', 'origin', origin], source);
+run('git', ['push', '-u', 'origin', 'main'], source);
+run('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], origin);
+run('git', ['clone', origin, install], tempRoot);
+
+writePackage('1.0.1');
+fs.writeFileSync(path.join(source, 'tracked.txt'), 'new\n');
+run('git', ['add', '.'], source);
+run('git', ['commit', '-m', 'update'], source);
+run('git', ['push', 'origin', 'main'], source);
+
+fs.writeFileSync(path.join(install, 'tracked.txt'), 'local dirty change\n');
+fs.writeFileSync(path.join(install, 'untracked.txt'), 'local untracked change\n');
+run(process.execPath, [updaterPath], install);
+
+assert.equal(
+  JSON.parse(fs.readFileSync(path.join(install, 'package.json'), 'utf8')).version,
+  '1.0.1',
+  'Safe updater should fast-forward the install checkout.',
+);
+assert.equal(
+  fs.readFileSync(path.join(install, 'tracked.txt'), 'utf8'),
+  'new\n',
+  'Safe updater should apply the remote tracked file after stashing local edits.',
+);
+assert.match(
+  run('git', ['stash', 'list'], install),
+  /pixcode-auto-update-/,
+  'Safe updater should leave local dirty files recoverable in git stash.',
+);
+
+console.log('git install update smoke passed');

package/scripts/smoke/vscode-workbench-polish.mjs

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+
+const read = (path) => fs.readFileSync(path, 'utf8');
+
+const workbench = read('src/components/vscode-workbench/view/VSCodeWorkbench.tsx');
+const projectType = read('src/types/app.ts');
+const projectsServer = read('server/projects.js');
+const mainState = read('src/components/main-content/view/subcomponents/MainContentStateView.tsx');
+const chatInterface = read('src/components/chat/view/ChatInterface.tsx');
+const chatComposer = read('src/components/chat/view/subcomponents/ChatComposer.tsx');
+const workerSlots = read('src/components/chat/view/subcomponents/WorkerSlotsControl.tsx');
+const wizard = read('src/components/project-creation-wizard/ProjectCreationWizard.tsx');
+const sidebar = read('src/components/sidebar/view/Sidebar.tsx');
+
+assert.match(
+  workbench,
+  /function WorkbenchMenuBar/,
+  'VS Code workbench should render a top menu bar.',
+);
+
+for (const item of ['File', 'Edit', 'Selection', 'View', 'Go', 'Run', 'Terminal', 'Help']) {
+  assert.match(workbench, new RegExp(`label: '${item}'`), `Workbench menu should include ${item}.`);
+}
+
+assert.match(
+  workbench,
+  /type:\s*'existing'/,
+  'File > Open Project should dispatch the existing-folder project wizard flow.',
+);
+
+assert.match(
+  workbench,
+  /type:\s*'new'/,
+  'File > Clone From GitHub should dispatch the GitHub clone project wizard flow.',
+);
+
+assert.match(
+  workbench,
+  /function WorkbenchProjectsPanel/,
+  'Projects activity should use a dedicated project-directory panel.',
+);
+
+assert.doesNotMatch(
+  workbench,
+  /return <Sidebar \{\.\.\.sidebarProps\} isMobile=\{false\} \/>/,
+  'Projects activity should not render the chat-history sidebar.',
+);
+
+assert.match(
+  workbench,
+  /formatProjectPath/,
+  'Projects panel should render a shortened path instead of dumping the full directory.',
+);
+
+assert.match(
+  workbench,
+  /formatFileCount/,
+  'Projects panel should show file counts.',
+);
+
+assert.match(projectType, /fileCount\?: number/, 'Project type should expose optional fileCount metadata.');
+assert.match(projectsServer, /async function countProjectFiles/, 'Backend should count project files for the workbench project list.');
+
+assert.match(
+  mainState,
+  /repeat\(auto-fit,\s*minmax\(min\(100%,\s*11rem\),\s*1fr\)\)/,
+  'Start workspace cards should auto-fit instead of forcing cramped fixed columns.',
+);
+
+assert.doesNotMatch(
+  workbench,
+  /<main className="min-w-\[360px\]/,
+  'Workbench center panel should be allowed to shrink with narrow three-pane layouts.',
+);
+
+assert.match(
+  workbench,
+  /compactComposer/,
+  'Workbench should request compact composer behavior in the right CLI pane.',
+);
+
+assert.match(
+  workbench,
+  /activeTab === 'chat' && activityPanel === 'projects'/,
+  'Projects activity should stay selected while the center chat tab is active.',
+);
+
+assert.match(chatInterface, /compactComposer\?: boolean/, 'ChatInterface should expose compactComposer for narrow workbench panes.');
+assert.match(chatComposer, /compact\?: boolean/, 'ChatComposer should expose a compact prop.');
+assert.match(chatComposer, /flex-wrap/, 'ChatComposer footer should wrap controls in narrow panes.');
+assert.match(workerSlots, /panelClassName\?: string/, 'WorkerSlotsControl should allow a compact panel width override.');
+assert.match(chatComposer, /panelClassName=\{compact/, 'Compact composer should constrain the worker-slot panel.');
+
+assert.match(
+  wizard,
+  /initialWorkspaceType\?: WorkspaceType/,
+  'Project wizard should accept an initial workspace type from the workbench File menu.',
+);
+
+assert.match(
+  sidebar,
+  /event as CustomEvent<\{ workspaceType\?: WorkspaceType \}>/,
+  'Sidebar create-project event should forward the requested workspace type into the wizard.',
+);
+
+console.log('vscode workbench polish smoke passed');

package/scripts/update-git-install.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const repoRoot = process.cwd();
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+const stashMessage = `pixcode-auto-update-${timestamp}`;
+const backupBranch = `pixcode-backup-before-update-${timestamp}`;
+
+function log(message) {
+  process.stdout.write(`${message}\n`);
+}
+
+function run(command, args, options = {}) {
+  const {
+    allowFailure = false,
+    collectOutput = false,
+    env = process.env,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    log(`$ ${[command, ...args].join(' ')}`);
+    const child = spawn(command, args, {
+      cwd: repoRoot,
+      env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      process.stdout.write(text);
+    });
+
+    child.stderr?.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      const result = { code, stdout, stderr };
+      if (code === 0 || allowFailure) {
+        resolve(collectOutput ? result : code);
+        return;
+      }
+
+      const error = new Error(`${command} ${args.join(' ')} exited with code ${code}`);
+      error.result = result;
+      reject(error);
+    });
+  });
+}
+
+async function getOutput(command, args, options = {}) {
+  const result = await run(command, args, { ...options, collectOutput: true });
+  return result.stdout.trim();
+}
+
+async function main() {
+  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
+    throw new Error(`Git metadata not found in ${repoRoot}`);
+  }
+
+  log('Pixcode safe git update started.');
+  log(`Repository: ${repoRoot}`);
+
+  await run('git', ['rev-parse', '--is-inside-work-tree']);
+  await run('git', ['fetch', 'origin', 'main']);
+
+  const status = await getOutput('git', ['status', '--porcelain', '--untracked-files=all']);
+  if (status) {
+    log('Local checkout has modified or untracked files.');
+    log(`Saving them to git stash: ${stashMessage}`);
+    await run('git', [
+      '-c',
+      'user.name=Pixcode Updater',
+      '-c',
+      'user.email=updater@pixcode.local',
+      'stash',
+      'push',
+      '--include-untracked',
+      '--message',
+      stashMessage,
+    ]);
+    log('Local changes are preserved in git stash.');
+  } else {
+    log('Working tree is clean.');
+  }
+
+  const checkoutMain = await run('git', ['checkout', 'main'], { allowFailure: true, collectOutput: true });
+  if (checkoutMain.code !== 0) {
+    log('Local main branch checkout failed; recreating main from origin/main.');
+    await run('git', ['checkout', '-B', 'main', 'origin/main']);
+  }
+
+  const isAncestor = await run('git', ['merge-base', '--is-ancestor', 'HEAD', 'origin/main'], {
+    allowFailure: true,
+    collectOutput: true,
+  });
+
+  if (isAncestor.code === 0) {
+    await run('git', ['merge', '--ff-only', 'origin/main']);
+  } else if (isAncestor.code === 1) {
+    log(`Local main has commits that are not on origin/main. Preserving them in branch: ${backupBranch}`);
+    await run('git', ['branch', backupBranch]);
+    await run('git', ['reset', '--hard', 'origin/main']);
+  } else {
+    throw new Error('Could not compare local main with origin/main.');
+  }
+
+  const packageVersion = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8')).version;
+  log(`Repository updated to Pixcode ${packageVersion}.`);
+
+  await run('npm', ['install', '--no-audit', '--no-fund']);
+  log('Pixcode git install update completed.');
+}
+
+main().catch((error) => {
+  process.stderr.write(`Pixcode git install update failed: ${error.message}\n`);
+  process.exit(1);
+});

package/server/index.js

@@ -482,18 +482,21 @@ app.use(express.static(path.join(APP_ROOT, 'public'), {
 //      npm tarball, extracts it to the writable runtime dir, and triggers
 //      a server restart so the Electron wrapper respawns with new code.
 //      ~4 MB download, ~10 s; no npm/git/shell required on the host.
-//   2. installMode === 'git' → `git pull && npm install` in-place.
+//   2. installMode === 'git' → safe git updater script. It stashes dirty
+//      checkout state before pulling so source installs do not fail on local
+//      modified files left by older releases or manual edits.
 //   3. fallback → `npm install -g …` (classic npm-distributed install).
 app.post('/api/system/update', authenticateToken, async (req, res) => {
     const projectRoot = APP_ROOT;
     console.log('Starting system update from directory:', projectRoot);
 
     const runtimeDir = process.env.PIXCODE_RUNTIME_DIR || null;
+    const gitUpdateScript = path.join(projectRoot, 'scripts', 'update-git-install.mjs');
 
     const updateCommand = IS_PLATFORM
         ? 'npm run update:platform'
         : installMode === 'git'
-            ? 'git checkout main && git pull && npm install'
+            ? `${JSON.stringify(process.execPath)} ${JSON.stringify(gitUpdateScript)}`
             : 'npm install -g @pixelbyte-software/pixcode@latest';
 
     const updateCwd = IS_PLATFORM || installMode === 'git'
@@ -738,8 +741,9 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
     // Short-circuit for "already on latest" in the npm-global path so
     // users don't accidentally crash their own daemon by clicking Update
     // while already up to date. The runtime-dir branch above already has
-    // this guard (line ~504); replicate it for npm mode. Git mode skips
-    // this since `git pull` is harmless when already up to date.
+    // this guard (line ~504); replicate it for npm mode. Git mode still
+    // runs because users may be on the latest package version but behind
+    // the source branch or have a dirty checkout that needs normalization.
     if (!IS_PLATFORM && installMode === 'npm') {
         try {
             send('log', { stream: 'meta', chunk: 'Querying registry for latest version…\n' });

package/server/projects.js

@@ -68,6 +68,74 @@ import Database from 'better-sqlite3';
 import sessionManager from './sessionManager.js';
 import { applyCustomSessionNames } from './database/db.js';
 
+const FILE_COUNT_LIMIT = 20000;
+const FILE_COUNT_IGNORED_DIRECTORIES = new Set([
+  '.cache',
+  '.git',
+  '.hg',
+  '.next',
+  '.npm',
+  '.pnpm-store',
+  '.svn',
+  '.turbo',
+  '.vite',
+  'build',
+  'coverage',
+  'dist',
+  'dist-server',
+  'node_modules',
+  'out',
+  'target',
+  'vendor'
+]);
+
+async function countProjectFiles(projectPath, maxFiles = FILE_COUNT_LIMIT) {
+  if (!projectPath || typeof projectPath !== 'string') {
+    return undefined;
+  }
+
+  try {
+    const stats = await fs.stat(projectPath);
+    if (!stats.isDirectory()) {
+      return undefined;
+    }
+  } catch {
+    return undefined;
+  }
+
+  let count = 0;
+  const pendingDirectories = [projectPath];
+
+  while (pendingDirectories.length > 0) {
+    const currentDirectory = pendingDirectories.pop();
+    let entries = [];
+
+    try {
+      entries = await fs.readdir(currentDirectory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!FILE_COUNT_IGNORED_DIRECTORIES.has(entry.name)) {
+          pendingDirectories.push(path.join(currentDirectory, entry.name));
+        }
+        continue;
+      }
+
+      if (entry.isFile() || entry.isSymbolicLink()) {
+        count += 1;
+        if (count >= maxFiles) {
+          return count;
+        }
+      }
+    }
+  }
+
+  return count;
+}
+
 // Import TaskMaster detection functions
 async function detectTaskMasterFolder(projectPath) {
   try {
@@ -691,6 +759,7 @@ async function getProjects(progressCallback = null) {
       path: actualProjectDir,
       displayName: customName || autoDisplayName,
       fullPath: actualProjectDir,
+      fileCount: await countProjectFiles(actualProjectDir),
       isCustomName: !!customName,
       isManuallyAdded,
       autoDiscovered: isAutoDiscovered,
@@ -832,6 +901,7 @@ async function getProjects(progressCallback = null) {
         path: actualProjectDir,
         displayName: projectConfig.displayName || await generateDisplayName(projectName, actualProjectDir),
         fullPath: actualProjectDir,
+        fileCount: await countProjectFiles(actualProjectDir),
         isCustomName: !!projectConfig.displayName,
         isManuallyAdded,
         autoDiscovered: isAutoDiscovered,
@@ -1557,6 +1627,7 @@ async function addProjectManually(projectPath, displayName = null) {
       path: absolutePath,
       fullPath: absolutePath,
       displayName: displayName || await generateDisplayName(projectName, absolutePath),
+      fileCount: await countProjectFiles(absolutePath),
       isManuallyAdded: true,
       sessions: [],
       cursorSessions: []
@@ -1584,6 +1655,7 @@ async function addProjectManually(projectPath, displayName = null) {
     path: absolutePath,
     fullPath: absolutePath,
     displayName: displayName || await generateDisplayName(projectName, absolutePath),
+    fileCount: await countProjectFiles(absolutePath),
     isManuallyAdded: true,
     sessions: [],
     cursorSessions: []