srcpack 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "srcpack",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Zero-config CLI for bundling code into LLM-optimized context files",
   "keywords": [
     "llm",
@@ -31,6 +31,10 @@
   "license": "MIT",
   "homepage": "https://kriasoft.com/srcpack/",
   "repository": "github:kriasoft/srcpack",
+  "bugs": "https://github.com/kriasoft/srcpack/issues",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "type": "module",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -48,13 +52,13 @@
     "schema.json"
   ],
   "scripts": {
-    "build": "bun build ./src/cli.ts ./src/index.ts --outdir ./dist --target bun && tsc",
-    "typecheck": "tsc -p tsconfig.check.json",
+    "build": "bun build ./src/cli.ts ./src/index.ts --outdir ./dist --target node && tsc",
     "check": "tsc -p tsconfig.check.json",
     "test": "bun test tests/unit/ tests/e2e/",
     "test:unit": "bun test tests/unit/",
     "test:e2e": "bun test tests/e2e/",
-    "test:login": "bun test --env-file .env.local tests/manual/",
+    "test:login": "bun test --env-file .env.local tests/manual/login.test.ts",
+    "test:upload": "bun test --env-file .env.local tests/manual/upload.test.ts",
     "test:all": "bun test --env-file .env.local tests/",
     "test:watch": "bun test tests/unit/ tests/e2e/ --watch",
     "docs:dev": "vitepress dev",
@@ -64,16 +68,23 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@googleapis/drive": "^20.0.0",
     "cosmiconfig": "^9.0.0",
+    "fast-glob": "^3.3.3",
+    "google-auth-library": "^10.5.0",
     "ignore": "^7.0.5",
     "oauth-callback": "^1.2.5",
+    "ora": "^9.0.0",
+    "picomatch": "^4.0.2",
     "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bun": "^1.3.6",
+    "@types/picomatch": "^4.0.2",
     "gh-pages": "^6.3.0",
     "prettier": "^3.8.0",
     "typescript": "^5.9.3",
-    "vitepress": "^2.0.0-alpha.15"
+    "vitepress": "^2.0.0-alpha.15",
+    "vitepress-plugin-llms": "^1.10.0"
   }
 }

package/src/bundle.ts

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: MIT
 
+import { open, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { Glob } from "bun";
+import { glob } from "fast-glob";
+import picomatch from "picomatch";
 import ignore, { type Ignore } from "ignore";
 import type { BundleConfigInput } from "./config.ts";
 
@@ -9,12 +11,17 @@ import type { BundleConfigInput } from "./config.ts";
 const BINARY_CHECK_SIZE = 8192;
 
 async function isBinary(filePath: string): Promise<boolean> {
-  const file = Bun.file(filePath);
-  const size = file.size;
-  if (size === 0) return false;
+  const stats = await stat(filePath);
+  if (stats.size === 0) return false;
 
-  const chunk = await file.slice(0, Math.min(size, BINARY_CHECK_SIZE)).bytes();
-  return chunk.includes(0);
+  const fd = await open(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(Math.min(stats.size, BINARY_CHECK_SIZE));
+    await fd.read(buffer, 0, buffer.length, 0);
+    return buffer.includes(0);
+  } finally {
+    await fd.close();
+  }
 }
 
 export interface FileEntry {
@@ -30,11 +37,15 @@ export interface BundleResult {
 }
 
 /**
- * Normalize BundleConfig to arrays of include/exclude patterns
+ * Normalize BundleConfig to arrays of include/exclude/force patterns.
+ * - Regular patterns: included, filtered by .gitignore
+ * - `!pattern`: excluded from results
+ * - `+pattern`: force-included, bypasses .gitignore
  */
 function normalizePatterns(config: BundleConfigInput): {
   include: string[];
   exclude: string[];
+  force: string[];
 } {
   let patterns: string[];
 
@@ -50,29 +61,28 @@ function normalizePatterns(config: BundleConfigInput): {
 
   const include: string[] = [];
   const exclude: string[] = [];
+  const force: string[] = [];
 
   for (const p of patterns) {
     if (p.startsWith("!")) {
       exclude.push(p.slice(1));
+    } else if (p.startsWith("+")) {
+      force.push(p.slice(1));
     } else {
       include.push(p);
     }
   }
 
-  return { include, exclude };
+  return { include, exclude, force };
 }
 
+type Matcher = (path: string) => boolean;
+
 /**
- * Check if a path matches any of the exclusion patterns
+ * Check if a path matches any of the exclusion matchers
  */
-function isExcluded(filePath: string, excludePatterns: string[]): boolean {
-  for (const pattern of excludePatterns) {
-    const glob = new Glob(pattern);
-    if (glob.match(filePath)) {
-      return true;
-    }
-  }
-  return false;
+function isExcluded(filePath: string, matchers: Matcher[]): boolean {
+  return matchers.some((match) => match(filePath));
 }
 
 /**
@@ -83,7 +93,7 @@ async function loadGitignore(cwd: string): Promise<Ignore> {
   const gitignorePath = join(cwd, ".gitignore");
 
   try {
-    const content = await Bun.file(gitignorePath).text();
+    const content = await readFile(gitignorePath, "utf-8");
     ig.add(content);
   } catch {
     // No .gitignore file, return empty ignore instance
@@ -94,20 +104,37 @@ async function loadGitignore(cwd: string): Promise<Ignore> {
 
 /**
  * Resolve bundle config to a list of file paths.
- * Respects .gitignore patterns in the working directory.
+ * - Regular patterns respect .gitignore
+ * - Force patterns (+prefix) bypass .gitignore
+ * - Exclude patterns (!prefix) filter both
  */
 export async function resolvePatterns(
   config: BundleConfigInput,
   cwd: string,
 ): Promise<string[]> {
-  const { include, exclude } = normalizePatterns(config);
+  const { include, exclude, force } = normalizePatterns(config);
+  const excludeMatchers = exclude.map((p) => picomatch(p));
   const gitignore = await loadGitignore(cwd);
   const files = new Set<string>();
 
-  for (const pattern of include) {
-    const glob = new Glob(pattern);
-    for await (const match of glob.scan({ cwd, onlyFiles: true })) {
-      if (!isExcluded(match, exclude) && !gitignore.ignores(match)) {
+  // Regular includes: respect .gitignore
+  if (include.length > 0) {
+    const matches = await glob(include, { cwd, onlyFiles: true, dot: true });
+    for (const match of matches) {
+      if (!isExcluded(match, excludeMatchers) && !gitignore.ignores(match)) {
+        const fullPath = join(cwd, match);
+        if (!(await isBinary(fullPath))) {
+          files.add(match);
+        }
+      }
+    }
+  }
+
+  // Force includes: bypass .gitignore
+  if (force.length > 0) {
+    const matches = await glob(force, { cwd, onlyFiles: true, dot: true });
+    for (const match of matches) {
+      if (!isExcluded(match, excludeMatchers)) {
         const fullPath = join(cwd, match);
         if (!(await isBinary(fullPath))) {
           files.add(match);
@@ -184,7 +211,7 @@ export async function createBundle(
   for (let i = 0; i < files.length; i++) {
     const filePath = files[i]!;
     const fullPath = join(cwd, filePath);
-    const content = await Bun.file(fullPath).text();
+    const content = await readFile(fullPath, "utf-8");
     const lines = countLines(content);
 
     // Separator takes 1 line, then content starts on next line

package/src/cli.ts

@@ -1,11 +1,23 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 // SPDX-License-Identifier: MIT
 
-import { mkdir } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import ora from "ora";
 import { bundleOne, type BundleResult } from "./bundle.ts";
-import { loadConfig, type BundleConfig, type UploadConfig } from "./config.ts";
-import { ensureAuthenticated, login, OAuthError } from "./gdrive.ts";
+import {
+  ConfigError,
+  loadConfig,
+  type BundleConfig,
+  type UploadConfig,
+} from "./config.ts";
+import {
+  ensureAuthenticated,
+  login,
+  OAuthError,
+  uploadFile,
+  type UploadResult,
+} from "./gdrive.ts";
 import { runInit } from "./init.ts";
 
 interface BundleOutput {
@@ -36,13 +48,15 @@ srcpack - Bundle and upload tool
 Usage:
   npx srcpack              Bundle all, upload if configured
   npx srcpack web api      Bundle specific bundles only
-  npx srcpack --dry-run    Bundle without upload (preview)
+  npx srcpack --dry-run    Preview bundles without writing files
+  npx srcpack --no-upload  Bundle only, skip upload
   npx srcpack init         Interactive config setup
   npx srcpack login        Authenticate with Google Drive
 
 Options:
-  --dry-run    Preview bundles without uploading
-  -h, --help   Show this help message
+  --dry-run     Preview bundles without writing files
+  --no-upload   Skip uploading to cloud storage
+  -h, --help    Show this help message
 `);
     return;
   }
@@ -58,6 +72,7 @@ Options:
   }
 
   const dryRun = args.includes("--dry-run");
+  const noUpload = args.includes("--no-upload");
   const subcommands = ["init", "login"];
   const requestedBundles = args.filter(
     (arg) => !arg.startsWith("-") && !subcommands.includes(arg),
@@ -93,14 +108,23 @@ Options:
   const cwd = process.cwd();
   const outputs: BundleOutput[] = [];
 
-  // Process all bundles
-  for (const name of bundleNames) {
+  // Process all bundles with progress
+  const bundleSpinner = ora({
+    text: `Bundling ${bundleNames[0]}...`,
+    color: "cyan",
+  }).start();
+
+  for (let i = 0; i < bundleNames.length; i++) {
+    const name = bundleNames[i]!;
+    bundleSpinner.text = `Bundling ${name}... (${i + 1}/${bundleNames.length})`;
     const bundleConfig = config.bundles[name]!;
     const result = await bundleOne(name, bundleConfig, cwd);
     const outfile = getOutfile(bundleConfig, name, config.outDir);
     outputs.push({ name, outfile, result });
   }
 
+  bundleSpinner.stop();
+
   // Calculate column widths for aligned output
   const maxNameLen = Math.max(...outputs.map((o) => o.name.length));
   const maxFilesLen = Math.max(
@@ -130,7 +154,7 @@ Options:
       }
     } else {
       await mkdir(dirname(outPath), { recursive: true });
-      await Bun.write(outPath, result.content);
+      await writeFile(outPath, result.content);
       console.log(
         `  ${nameCol}  ${filesCol} ${plural(fileCount, "file")}  ${linesCol} ${plural(lineCount, "line")}  → ${outfile}`,
       );
@@ -151,18 +175,18 @@ Options:
     );
   } else {
     console.log(
-      `Done: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
+      `Bundled: ${outputs.length} ${bundleWord}, ${formatNumber(totalFiles)} ${fileWord}, ${formatNumber(totalLines)} ${lineWord}`,
     );
 
-    // Handle upload if configured
-    if (config.upload) {
+    // Handle upload if configured and not disabled
+    if (config.upload && !noUpload) {
       const uploads = Array.isArray(config.upload)
         ? config.upload
         : [config.upload];
 
       for (const uploadConfig of uploads) {
         if (isGdriveConfigured(uploadConfig)) {
-          await handleGdriveUpload(uploadConfig, outputs);
+          await handleGdriveUpload(uploadConfig, outputs, cwd);
         }
       }
     }
@@ -188,7 +212,16 @@ function getGdriveConfig(config: {
 }
 
 async function runLogin(): Promise<void> {
-  const config = await loadConfig();
+  let config;
+  try {
+    config = await loadConfig();
+  } catch (error) {
+    if (error instanceof ConfigError && error.message.includes("upload")) {
+      printUploadConfigHelp();
+      process.exit(1);
+    }
+    throw error;
+  }
 
   if (!config) {
     console.error(
@@ -197,19 +230,25 @@ async function runLogin(): Promise<void> {
     process.exit(1);
   }
 
-  const uploadConfig = getGdriveConfig(config);
-  if (!uploadConfig) {
-    console.error("No Google Drive upload configured.");
-    console.error(
-      "Add upload config with clientId and clientSecret to your srcpack.config.ts",
-    );
+  if (!config.upload) {
+    printUploadConfigHelp();
+    process.exit(1);
+  }
+
+  const uploads = Array.isArray(config.upload)
+    ? config.upload
+    : [config.upload];
+  const gdriveConfig = uploads.find((u) => u.provider === "gdrive");
+
+  if (!gdriveConfig) {
+    console.error('No upload config with provider: "gdrive" found.');
     process.exit(1);
   }
 
   try {
     console.log("Opening browser for authentication...");
-    await login(uploadConfig);
-    console.log("Login successful. Tokens saved to ~/.srcpack/tokens.json");
+    await login(gdriveConfig);
+    console.log("Login successful.");
   } catch (error) {
     if (error instanceof OAuthError) {
       console.error(`OAuth error: ${error.error}`);
@@ -222,22 +261,59 @@ async function runLogin(): Promise<void> {
   }
 }
 
+function printUploadConfigHelp(): void {
+  console.error("Upload configuration incomplete or missing.");
+  console.error("Add to srcpack.config.ts:");
+  console.error(`
+  upload: {
+    provider: "gdrive",
+    folderId: "...",      // optional - Google Drive folder ID
+    clientId: "...",      // required - OAuth 2.0 client ID
+    clientSecret: "...",  // required - OAuth 2.0 client secret
+  }
+`);
+}
+
 async function handleGdriveUpload(
   uploadConfig: UploadConfig,
-  _outputs: BundleOutput[],
+  outputs: BundleOutput[],
+  cwd: string,
 ): Promise<void> {
   try {
     await ensureAuthenticated(uploadConfig);
 
-    // TODO: Upload bundles to Google Drive using tokens
+    const uploadSpinner = ora({
+      text: `Uploading to Google Drive...`,
+      color: "cyan",
+    }).start();
+
+    const results: UploadResult[] = [];
+
+    for (let i = 0; i < outputs.length; i++) {
+      const output = outputs[i]!;
+      const filePath = join(cwd, output.outfile);
+      uploadSpinner.text = `Uploading ${output.name}... (${i + 1}/${outputs.length})`;
+      const result = await uploadFile(filePath, uploadConfig);
+      results.push(result);
+    }
+
+    uploadSpinner.stop();
+
+    // Print upload summary
     console.log();
-    console.log("Authenticated with Google Drive.");
-    if (uploadConfig.folder) {
-      console.log(`Ready to upload to folder: ${uploadConfig.folder}`);
+    const uploadWord = plural(results.length, "file");
+    console.log(`Uploaded: ${results.length} ${uploadWord} to Google Drive`);
+
+    for (const result of results) {
+      if (result.webViewLink) {
+        console.log(`  ${result.name} → ${result.webViewLink}`);
+      } else {
+        console.log(`  ${result.name}`);
+      }
     }
   } catch (error) {
     if (error instanceof OAuthError) {
-      console.error(`OAuth error: ${error.error}`);
+      console.error(`\nOAuth error: ${error.error}`);
       if (error.error_description) {
         console.error(`  ${error.error_description}`);
       }

package/src/config.ts

@@ -29,7 +29,7 @@ const BundleConfigSchema = z.union([
 
 const UploadConfigSchema = z.object({
   provider: z.literal("gdrive"),
-  folder: z.string().optional(),
+  folderId: z.string().optional(),
   clientId: z.string().min(1),
   clientSecret: z.string().min(1),
 });

package/src/gdrive.ts

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: MIT
 
-import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, basename } from "node:path";
+import { drive as createDrive, type drive_v3 } from "@googleapis/drive";
+import { OAuth2Client } from "google-auth-library";
 import { getAuthCode, OAuthError } from "oauth-callback";
 import type { UploadConfig } from "./config.ts";
 
@@ -10,7 +13,12 @@ const GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
 const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
 const SCOPES = ["https://www.googleapis.com/auth/drive.file"];
 const REDIRECT_URI = "http://localhost:3000/callback";
-const TOKENS_PATH = join(homedir(), ".srcpack", "tokens.json");
+const CREDENTIALS_PATH = join(
+  homedir(),
+  ".config",
+  "srcpack",
+  "credentials.json",
+);
 
 export interface Tokens {
   access_token: string;
@@ -28,35 +36,52 @@ interface TokenResponse {
   scope: string;
 }
 
-/**
- * Loads stored tokens from disk.
- * Returns null if no tokens exist or they cannot be read.
- */
-export async function loadTokens(): Promise<Tokens | null> {
+// Credentials keyed by provider, then by clientId for multi-destination support
+interface CredentialsFile {
+  gdrive?: Record<string, Tokens>;
+}
+
+async function readCredentials(): Promise<CredentialsFile> {
   try {
-    const data = await readFile(TOKENS_PATH, "utf-8");
-    return JSON.parse(data) as Tokens;
+    const data = await readFile(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(data) as CredentialsFile;
   } catch {
-    return null;
+    return {};
   }
 }
 
+async function writeCredentials(creds: CredentialsFile): Promise<void> {
+  await mkdir(dirname(CREDENTIALS_PATH), { recursive: true });
+  await writeFile(CREDENTIALS_PATH, JSON.stringify(creds, null, 2));
+}
+
 /**
- * Saves tokens to disk for later use.
+ * Loads stored tokens for a specific OAuth client.
+ * Returns null if no tokens exist or they cannot be read.
  */
-async function saveTokens(tokens: Tokens): Promise<void> {
-  await mkdir(dirname(TOKENS_PATH), { recursive: true });
-  await writeFile(TOKENS_PATH, JSON.stringify(tokens, null, 2));
+export async function loadTokens(config: UploadConfig): Promise<Tokens | null> {
+  const creds = await readCredentials();
+  return creds.gdrive?.[config.clientId] ?? null;
 }
 
 /**
- * Removes stored tokens from disk.
+ * Saves tokens for a specific OAuth client.
  */
-export async function clearTokens(): Promise<void> {
-  try {
-    await unlink(TOKENS_PATH);
-  } catch {
-    // Ignore if file doesn't exist
+async function saveTokens(tokens: Tokens, config: UploadConfig): Promise<void> {
+  const creds = await readCredentials();
+  creds.gdrive ??= {};
+  creds.gdrive[config.clientId] = tokens;
+  await writeCredentials(creds);
+}
+
+/**
+ * Removes stored tokens for a specific OAuth client.
+ */
+export async function clearTokens(config: UploadConfig): Promise<void> {
+  const creds = await readCredentials();
+  if (creds.gdrive?.[config.clientId]) {
+    delete creds.gdrive[config.clientId];
+    await writeCredentials(creds);
   }
 }
 
@@ -101,7 +126,7 @@ async function refreshAccessToken(
     scope: data.scope,
   };
 
-  await saveTokens(tokens);
+  await saveTokens(tokens, config);
   return tokens;
 }
 
@@ -112,7 +137,7 @@ async function refreshAccessToken(
 export async function getValidTokens(
   config: UploadConfig,
 ): Promise<Tokens | null> {
-  const tokens = await loadTokens();
+  const tokens = await loadTokens(config);
   if (!tokens) return null;
 
   if (isExpired(tokens) && tokens.refresh_token) {
@@ -180,7 +205,7 @@ export async function login(config: UploadConfig): Promise<Tokens> {
     scope: data.scope,
   };
 
-  await saveTokens(tokens);
+  await saveTokens(tokens, config);
   return tokens;
 }
 
@@ -197,4 +222,121 @@ export async function ensureAuthenticated(
   return login(config);
 }
 
+/**
+ * Creates an authenticated OAuth2 client from tokens.
+ */
+function createAuthClient(tokens: Tokens, config: UploadConfig): OAuth2Client {
+  const client = new OAuth2Client(config.clientId, config.clientSecret);
+  client.setCredentials({
+    access_token: tokens.access_token,
+    refresh_token: tokens.refresh_token,
+  });
+  return client;
+}
+
+/**
+ * Creates an authenticated Google Drive client.
+ */
+function createDriveClient(
+  tokens: Tokens,
+  config: UploadConfig,
+): drive_v3.Drive {
+  const auth = createAuthClient(tokens, config);
+  return createDrive({ version: "v3", auth });
+}
+
+/**
+ * Finds a file by name in a specific folder (or root).
+ * Returns the file ID if found, null otherwise.
+ */
+async function findFile(
+  drive: drive_v3.Drive,
+  name: string,
+  folderId?: string,
+): Promise<string | null> {
+  const parent = folderId ?? "root";
+  const query = `name = '${name}' and '${parent}' in parents and trashed = false`;
+
+  const res = await drive.files.list({
+    q: query,
+    fields: "files(id, name)",
+    spaces: "drive",
+  });
+
+  return res.data.files?.[0]?.id ?? null;
+}
+
+export interface UploadResult {
+  fileId: string;
+  name: string;
+  webViewLink?: string;
+}
+
+/**
+ * Uploads a file to Google Drive. Updates existing file if found with same name.
+ */
+export async function uploadFile(
+  filePath: string,
+  config: UploadConfig,
+): Promise<UploadResult> {
+  const tokens = await ensureAuthenticated(config);
+  const drive = createDriveClient(tokens, config);
+  const fileName = basename(filePath);
+
+  // Check if file already exists in target folder
+  const existingId = await findFile(drive, fileName, config.folderId);
+
+  const media = {
+    mimeType: "text/plain",
+    body: createReadStream(filePath),
+  };
+
+  let res: { data: drive_v3.Schema$File };
+
+  if (existingId) {
+    // Update existing file
+    res = await drive.files.update({
+      fileId: existingId,
+      media,
+      fields: "id, name, webViewLink",
+    });
+  } else {
+    // Create new file
+    const requestBody: drive_v3.Schema$File = {
+      name: fileName,
+    };
+
+    if (config.folderId) {
+      requestBody.parents = [config.folderId];
+    }
+
+    res = await drive.files.create({
+      requestBody,
+      media,
+      fields: "id, name, webViewLink",
+    });
+  }
+
+  return {
+    fileId: res.data.id!,
+    name: res.data.name!,
+    webViewLink: res.data.webViewLink ?? undefined,
+  };
+}
+
+/**
+ * Uploads multiple files to Google Drive.
+ */
+export async function uploadFiles(
+  filePaths: string[],
+  config: UploadConfig,
+): Promise<UploadResult[]> {
+  const results: UploadResult[] = [];
+  for (const filePath of filePaths) {
+    const result = await uploadFile(filePath, config);
+    results.push(result);
+  }
+  return results;
+}
+
 export { OAuthError };