graftapp 0.2.0

package/dist/auth-QTBHG3BR.js

@@ -0,0 +1,10 @@
+import {
+  clearAuth,
+  loadAuth,
+  saveAuth
+} from "./chunk-IFQ6DFWT.js";
+export {
+  clearAuth,
+  loadAuth,
+  saveAuth
+};

package/dist/chunk-FGCUN3GX.js

@@ -0,0 +1,137 @@
+// src/scanners/react-router.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+var ReactRouterScanner = class {
+  constructor() {
+    this.cwd = process.cwd();
+  }
+  async scan() {
+    const routes = [];
+    const routerFiles = [
+      "src/router.ts",
+      "src/router.tsx",
+      "src/routes.ts",
+      "src/routes.tsx",
+      "src/router/index.ts",
+      "src/router/index.tsx",
+      "src/App.tsx",
+      "src/App.ts",
+      "src/app.tsx",
+      "src/app.ts"
+    ];
+    for (const file of routerFiles) {
+      const filePath = join(this.cwd, file);
+      if (existsSync(filePath)) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const extractedRoutes = this.extractRoutes(content);
+          routes.push(...extractedRoutes);
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    const uniqueRoutes = this.deduplicateRoutes(routes);
+    return {
+      routes: uniqueRoutes,
+      framework: "react-router"
+    };
+  }
+  /**
+   * Extract routes from file content using regex patterns
+   * Looks for:
+   * - path: "/some/path"
+   * - path="/some/path"
+   * - path='/some/path'
+   * - <Route path="/some/path" />
+   */
+  extractRoutes(content) {
+    const routes = [];
+    if (!this.usesReactRouter(content)) {
+      return routes;
+    }
+    const colonPattern = /path:\s*["']([^"']+)["']/g;
+    let match;
+    while ((match = colonPattern.exec(content)) !== null) {
+      const path = match[1];
+      if (this.isValidRoutePath(path)) {
+        routes.push({
+          path: this.normalizePath(path),
+          isDynamic: this.isDynamicRoute(path),
+          framework: "react-router"
+        });
+      }
+    }
+    const equalsPattern = /path\s*=\s*["']([^"']+)["']/g;
+    while ((match = equalsPattern.exec(content)) !== null) {
+      const path = match[1];
+      if (this.isValidRoutePath(path)) {
+        routes.push({
+          path: this.normalizePath(path),
+          isDynamic: this.isDynamicRoute(path),
+          framework: "react-router"
+        });
+      }
+    }
+    return routes;
+  }
+  /**
+   * Check if the file content uses react-router
+   */
+  usesReactRouter(content) {
+    return content.includes("react-router-dom") || content.includes("react-router") || content.includes("createBrowserRouter") || content.includes("createHashRouter") || content.includes("BrowserRouter") || content.includes("HashRouter") || content.includes("<Route");
+  }
+  /**
+   * Check if a path is a valid route path (not a variable or complex expression)
+   */
+  isValidRoutePath(path) {
+    if (!path.startsWith("/")) {
+      return false;
+    }
+    if (path.includes("${") || path.includes("`")) {
+      return false;
+    }
+    if (path.includes(" ")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Normalize the path to ensure consistency
+   */
+  normalizePath(path) {
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+      path = path.slice(0, -1);
+    }
+    return path;
+  }
+  /**
+   * Check if a route path contains dynamic segments
+   * React Router uses :param for dynamic segments
+   */
+  isDynamicRoute(path) {
+    return path.includes(":") || path.includes("*");
+  }
+  /**
+   * Remove duplicate routes
+   */
+  deduplicateRoutes(routes) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const route of routes) {
+      if (!seen.has(route.path)) {
+        seen.add(route.path);
+        unique.push(route);
+      }
+    }
+    return unique;
+  }
+};
+
+export {
+  ReactRouterScanner
+};

package/dist/chunk-IFQ6DFWT.js

@@ -0,0 +1,30 @@
+// src/utils/auth.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, unlink, mkdir } from "fs/promises";
+var CONFIG_DIR = join(homedir(), ".config", "graft");
+var AUTH_FILE = join(CONFIG_DIR, "auth.json");
+async function saveAuth(auth) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(AUTH_FILE, JSON.stringify(auth, null, 2));
+}
+async function loadAuth() {
+  try {
+    const content = await readFile(AUTH_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function clearAuth() {
+  try {
+    await unlink(AUTH_FILE);
+  } catch {
+  }
+}
+
+export {
+  saveAuth,
+  loadAuth,
+  clearAuth
+};

package/dist/chunk-JAQFRDWK.js

@@ -0,0 +1,30 @@
+// src/utils/config.ts
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var CONFIG_FILE = "graft.config.json";
+async function loadConfig() {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveConfig(config) {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+}
+function configExists() {
+  return existsSync(join(process.cwd(), CONFIG_FILE));
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  configExists
+};

package/dist/chunk-JKWWL7J3.js

@@ -0,0 +1,182 @@
+// src/scanners/next.ts
+import { readdir } from "fs/promises";
+import { join, sep } from "path";
+import { existsSync } from "fs";
+var NextScanner = class {
+  constructor() {
+    this.cwd = process.cwd();
+  }
+  async scan() {
+    const routes = [];
+    const appDir = join(this.cwd, "app");
+    if (existsSync(appDir)) {
+      const appRoutes = await this.scanAppRouter(appDir);
+      routes.push(...appRoutes);
+    }
+    const pagesDir = join(this.cwd, "pages");
+    if (existsSync(pagesDir)) {
+      const pageRoutes = await this.scanPagesRouter(pagesDir);
+      routes.push(...pageRoutes);
+    }
+    return {
+      routes,
+      framework: "next"
+    };
+  }
+  /**
+   * Scan Next.js App Router (app directory)
+   * Looks for page.tsx, page.ts, page.jsx, page.js files
+   */
+  async scanAppRouter(appDir) {
+    const routes = [];
+    await this.walkDirectory(appDir, async (filePath, relativePath) => {
+      const fileName = filePath.split(sep).pop() || "";
+      if (!fileName.match(/^page\.(tsx?|jsx?)$/)) {
+        return;
+      }
+      const routePath = this.convertAppRouterPath(relativePath);
+      if (routePath) {
+        routes.push({
+          path: routePath,
+          isDynamic: this.isDynamicRoute(routePath),
+          framework: "next"
+        });
+      }
+    });
+    return routes;
+  }
+  /**
+   * Scan Next.js Pages Router (pages directory)
+   * Looks for .tsx, .ts, .jsx, .js files
+   */
+  async scanPagesRouter(pagesDir) {
+    const routes = [];
+    await this.walkDirectory(pagesDir, async (filePath, relativePath) => {
+      const fileName = filePath.split(sep).pop() || "";
+      if (fileName.match(/^(_app|_document|_error)\.(tsx?|jsx?)$/)) {
+        return;
+      }
+      if (relativePath.startsWith("api" + sep) || relativePath.startsWith("api/")) {
+        return;
+      }
+      if (!fileName.match(/\.(tsx?|jsx?)$/)) {
+        return;
+      }
+      const routePath = this.convertPagesRouterPath(relativePath);
+      if (routePath) {
+        routes.push({
+          path: routePath,
+          isDynamic: this.isDynamicRoute(routePath),
+          framework: "next"
+        });
+      }
+    });
+    return routes;
+  }
+  /**
+   * Convert App Router file path to route path
+   * Examples:
+   * - "page.tsx" → "/"
+   * - "dashboard/page.tsx" → "/dashboard"
+   * - "users/[id]/page.tsx" → "/users/:id"
+   * - "blog/[...slug]/page.tsx" → "/blog/*"
+   * - "shop/[[...slug]]/page.tsx" → "/shop/*?"
+   * - "(auth)/login/page.tsx" → "/login" (route groups removed)
+   * - "@modal/photo/page.tsx" → skipped (parallel routes)
+   * - "_components/card.tsx" → skipped (private folders)
+   */
+  convertAppRouterPath(relativePath) {
+    let path = relativePath.replace(/\/?page\.(tsx?|jsx?)$/, "");
+    const segments = path ? path.split(sep) : [];
+    const processedSegments = [];
+    for (const segment of segments) {
+      if (segment.startsWith("_")) {
+        continue;
+      }
+      if (segment.startsWith("@")) {
+        return null;
+      }
+      if (segment.startsWith("(") && segment.endsWith(")")) {
+        continue;
+      }
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        const param = segment.slice(1, -1);
+        if (param.startsWith("...")) {
+          processedSegments.push("*");
+        } else if (param.startsWith("[...") && param.endsWith("]")) {
+          processedSegments.push("*?");
+        } else {
+          processedSegments.push(":" + param);
+        }
+      } else {
+        processedSegments.push(segment);
+      }
+    }
+    return "/" + processedSegments.join("/");
+  }
+  /**
+   * Convert Pages Router file path to route path
+   * Examples:
+   * - "index.tsx" → "/"
+   * - "about.tsx" → "/about"
+   * - "blog/index.tsx" → "/blog"
+   * - "blog/[slug].tsx" → "/blog/:slug"
+   * - "blog/[...slug].tsx" → "/blog/*"
+   */
+  convertPagesRouterPath(relativePath) {
+    let path = relativePath.replace(/\.(tsx?|jsx?)$/, "");
+    if (path === "index") {
+      return "/";
+    }
+    path = path.replace(/\/index$/, "");
+    const segments = path.split(sep);
+    const processedSegments = [];
+    for (const segment of segments) {
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        const param = segment.slice(1, -1);
+        if (param.startsWith("...")) {
+          processedSegments.push("*");
+        } else {
+          processedSegments.push(":" + param);
+        }
+      } else {
+        processedSegments.push(segment);
+      }
+    }
+    return "/" + processedSegments.join("/");
+  }
+  /**
+   * Check if a route path contains dynamic segments
+   */
+  isDynamicRoute(path) {
+    return path.includes(":") || path.includes("*");
+  }
+  /**
+   * Recursively walk a directory and call the callback for each file
+   */
+  async walkDirectory(dir, callback) {
+    const walk = async (currentDir, basePath = "") => {
+      try {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(currentDir, entry.name);
+          const relativePath = basePath ? join(basePath, entry.name) : entry.name;
+          if (entry.isDirectory()) {
+            await walk(fullPath, relativePath);
+          } else if (entry.isFile()) {
+            await callback(fullPath, relativePath);
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code !== "ENOENT" && error.code !== "EACCES") {
+          throw error;
+        }
+      }
+    };
+    await walk(dir);
+  }
+};
+
+export {
+  NextScanner
+};

package/dist/chunk-OSSL5LKZ.js

@@ -0,0 +1,204 @@
+// src/scanners/vue-router.ts
+import { readFile, readdir } from "fs/promises";
+import { join, sep } from "path";
+import { existsSync } from "fs";
+var VueRouterScanner = class {
+  constructor() {
+    this.cwd = process.cwd();
+  }
+  async scan() {
+    const routes = [];
+    const routerFiles = [
+      "src/router/index.ts",
+      "src/router/index.js",
+      "src/router.ts",
+      "src/router.js",
+      "router/index.ts",
+      "router/index.js"
+    ];
+    let foundRouterConfig = false;
+    for (const file of routerFiles) {
+      const filePath = join(this.cwd, file);
+      if (existsSync(filePath)) {
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const extractedRoutes = this.extractRoutesFromConfig(content);
+          routes.push(...extractedRoutes);
+          foundRouterConfig = true;
+        } catch (error) {
+          continue;
+        }
+      }
+    }
+    if (!foundRouterConfig) {
+      const pagesRoutes = await this.scanPagesDirectory();
+      routes.push(...pagesRoutes);
+    }
+    const uniqueRoutes = this.deduplicateRoutes(routes);
+    return {
+      routes: uniqueRoutes,
+      framework: "vue"
+    };
+  }
+  /**
+   * Extract routes from Vue Router configuration file
+   * Looks for path: '/some/path' patterns
+   */
+  extractRoutesFromConfig(content) {
+    const routes = [];
+    if (!this.usesVueRouter(content)) {
+      return routes;
+    }
+    const pathPattern = /path:\s*["'`]([^"'`]+)["'`]/g;
+    let match;
+    while ((match = pathPattern.exec(content)) !== null) {
+      const path = match[1];
+      if (this.isValidRoutePath(path)) {
+        routes.push({
+          path: this.normalizePath(path),
+          isDynamic: this.isDynamicRoute(path),
+          framework: "vue"
+        });
+      }
+    }
+    return routes;
+  }
+  /**
+   * Scan Nuxt-style pages directory for routes
+   */
+  async scanPagesDirectory() {
+    const routes = [];
+    const pagesDir = join(this.cwd, "pages");
+    if (!existsSync(pagesDir)) {
+      return routes;
+    }
+    await this.walkDirectory(pagesDir, async (filePath, relativePath) => {
+      const fileName = filePath.split(sep).pop() || "";
+      if (!fileName.match(/\.vue$/)) {
+        return;
+      }
+      const routePath = this.convertNuxtPagePath(relativePath);
+      if (routePath) {
+        routes.push({
+          path: routePath,
+          isDynamic: this.isDynamicRoute(routePath),
+          framework: "vue"
+        });
+      }
+    });
+    return routes;
+  }
+  /**
+   * Convert Nuxt pages file path to route path
+   * Examples:
+   * - "index.vue" → "/"
+   * - "about.vue" → "/about"
+   * - "users/index.vue" → "/users"
+   * - "users/[id].vue" → "/users/:id"
+   * - "blog/[...slug].vue" → "/blog/*"
+   */
+  convertNuxtPagePath(relativePath) {
+    let path = relativePath.replace(/\.vue$/, "");
+    if (path === "index") {
+      return "/";
+    }
+    path = path.replace(/\/index$/, "");
+    const segments = path.split(sep);
+    const processedSegments = [];
+    for (const segment of segments) {
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        const param = segment.slice(1, -1);
+        if (param.startsWith("...")) {
+          processedSegments.push("*");
+        } else {
+          processedSegments.push(":" + param);
+        }
+      } else {
+        processedSegments.push(segment);
+      }
+    }
+    return "/" + processedSegments.join("/");
+  }
+  /**
+   * Check if the file content uses vue-router
+   */
+  usesVueRouter(content) {
+    return content.includes("vue-router") || content.includes("createRouter") || content.includes("VueRouter") || content.includes("RouteRecordRaw");
+  }
+  /**
+   * Check if a path is a valid route path
+   */
+  isValidRoutePath(path) {
+    if (!path.startsWith("/")) {
+      return false;
+    }
+    if (path.includes("${") || path.includes("`")) {
+      return false;
+    }
+    if (path.includes(" ")) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Normalize the path to ensure consistency
+   */
+  normalizePath(path) {
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+      path = path.slice(0, -1);
+    }
+    return path;
+  }
+  /**
+   * Check if a route path contains dynamic segments
+   * Vue Router uses :param for dynamic segments
+   */
+  isDynamicRoute(path) {
+    return path.includes(":") || path.includes("*");
+  }
+  /**
+   * Remove duplicate routes
+   */
+  deduplicateRoutes(routes) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const route of routes) {
+      if (!seen.has(route.path)) {
+        seen.add(route.path);
+        unique.push(route);
+      }
+    }
+    return unique;
+  }
+  /**
+   * Recursively walk a directory and call the callback for each file
+   */
+  async walkDirectory(dir, callback) {
+    const walk = async (currentDir, basePath = "") => {
+      try {
+        const entries = await readdir(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(currentDir, entry.name);
+          const relativePath = basePath ? join(basePath, entry.name) : entry.name;
+          if (entry.isDirectory()) {
+            await walk(fullPath, relativePath);
+          } else if (entry.isFile()) {
+            await callback(fullPath, relativePath);
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code !== "ENOENT" && error.code !== "EACCES") {
+          throw error;
+        }
+      }
+    };
+    await walk(dir);
+  }
+};
+
+export {
+  VueRouterScanner
+};

package/dist/chunk-SYWI4LAM.js

@@ -0,0 +1,99 @@
+// src/scanners/remix.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+var RemixScanner = class {
+  constructor() {
+    this.cwd = process.cwd();
+  }
+  async scan() {
+    const routes = [];
+    const routesDir = join(this.cwd, "app", "routes");
+    if (!existsSync(routesDir)) {
+      return {
+        routes,
+        framework: "remix"
+      };
+    }
+    try {
+      const entries = await readdir(routesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) {
+          continue;
+        }
+        const fileName = entry.name;
+        if (!fileName.match(/\.(tsx?|jsx?)$/)) {
+          continue;
+        }
+        const routePath = this.convertRemixRoute(fileName);
+        if (routePath) {
+          routes.push({
+            path: routePath,
+            isDynamic: this.isDynamicRoute(routePath),
+            framework: "remix"
+          });
+        }
+      }
+    } catch (error) {
+      return {
+        routes,
+        framework: "remix"
+      };
+    }
+    return {
+      routes,
+      framework: "remix"
+    };
+  }
+  /**
+   * Convert Remix flat file route convention to route path
+   * Examples:
+   * - "_index.tsx" → "/"
+   * - "about.tsx" → "/about"
+   * - "dashboard.users.tsx" → "/dashboard/users"
+   * - "$userId.tsx" → "/:userId"
+   * - "blog.$slug.tsx" → "/blog/:slug"
+   * - "$.tsx" → "/*" (splat route)
+   * - "_layout.tsx" → null (layout file, not a route)
+   * - "posts._index.tsx" → "/posts"
+   */
+  convertRemixRoute(fileName) {
+    let name = fileName.replace(/\.(tsx?|jsx?)$/, "");
+    if (name.startsWith("_") && name !== "_index") {
+      return null;
+    }
+    if (name === "_index") {
+      return "/";
+    }
+    const segments = name.split(".");
+    const processedSegments = [];
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (segment === "_index") {
+        continue;
+      }
+      if (segment === "$") {
+        processedSegments.push("*");
+        continue;
+      }
+      if (segment.startsWith("$")) {
+        const param = segment.slice(1);
+        processedSegments.push(":" + param);
+        continue;
+      }
+      processedSegments.push(segment);
+    }
+    const path = "/" + processedSegments.join("/");
+    return path;
+  }
+  /**
+   * Check if a route path contains dynamic segments
+   */
+  isDynamicRoute(path) {
+    return path.includes(":") || path.includes("*");
+  }
+};
+
+export {
+  RemixScanner
+};