@anvil-works/anvil-cli 0.7.6 → 0.7.7

package/dist/cli.js

@@ -14388,274 +14388,6 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             return true;
         }
     }
-    const ANVIL_DEPS_DIR = ".anvil/deps";
-    const ANVIL_DEPS_MANIFEST = "manifest.json";
-    const DEPS_MANIFEST_VERSION = 1;
-    function formatFetchError(prefix, status, errorBody) {
-        if (!errorBody) return `${prefix}: ${status}`;
-        try {
-            const parsed = JSON.parse(errorBody);
-            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
-        } catch  {}
-        return `${prefix}: ${status} ${errorBody}`;
-    }
-    async function fetchAllDependencies(appId, anvilUrl = resolveAnvilUrl(), options = {}) {
-        const { commit, includeDocs = true, knownDependencies = [] } = options;
-        const token = await auth_getValidAuthToken(anvilUrl, options.username);
-        const body = {
-            include_docs: includeDocs,
-            known_dependencies: knownDependencies
-        };
-        if (commit) body.commit = commit;
-        const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/resolved-dependencies`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(body)
-        });
-        if (!resp.ok) {
-            const errorBody = await resp.text();
-            throw new Error(formatFetchError("Failed to fetch dependencies", resp.status, errorBody));
-        }
-        return await resp.json();
-    }
-    async function refreshDependencyCache(projectRoot, appId, anvilUrl = resolveAnvilUrl(), options = {}) {
-        const includeDocs = options.includeDocs ?? true;
-        const knownDependencies = await getKnownDependenciesForCache(projectRoot, includeDocs);
-        const response = await fetchAllDependencies(appId, anvilUrl, {
-            username: options.username,
-            commit: options.commit,
-            includeDocs,
-            knownDependencies
-        });
-        if (!response.resolved_dependencies.length) {
-            await clearDepsCache(projectRoot);
-            return {
-                response,
-                addedGitignoreEntry: false
-            };
-        }
-        const addedGitignoreEntry = await ensureProjectGitignoreIgnoresAnvilDir(projectRoot);
-        await writeAllDepsToCache(projectRoot, response, {
-            includeDocs
-        });
-        return {
-            response,
-            addedGitignoreEntry
-        };
-    }
-    function depsDir(projectRoot) {
-        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
-    }
-    function depsManifestPath(projectRoot) {
-        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
-    }
-    function isResolvedDependencyManifestEntry(value) {
-        if (!value || "object" != typeof value) return false;
-        const entry = value;
-        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
-    }
-    function isCachedDependencyManifestEntry(value) {
-        if (!isResolvedDependencyManifestEntry(value)) return false;
-        const entry = value;
-        return "string" == typeof entry.package_name && entry.package_name.length > 0;
-    }
-    function isDepsCacheManifest(value) {
-        if (!value || "object" != typeof value) return false;
-        const manifest = value;
-        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
-    }
-    async function readDepsCacheManifest(projectRoot) {
-        try {
-            const raw = await promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
-            const parsed = JSON.parse(raw);
-            return isDepsCacheManifest(parsed) ? parsed : void 0;
-        } catch  {
-            return;
-        }
-    }
-    async function getKnownDependenciesForCache(projectRoot, includeDocs) {
-        const manifest = await readDepsCacheManifest(projectRoot);
-        if (!manifest || manifest.includeDocs !== includeDocs) return [];
-        return manifest.resolved_dependencies.map(({ app_id, commit_id })=>({
-                app_id,
-                commit_id
-            }));
-    }
-    function getDependencyWatchSubscriptionsFromManifest(manifest) {
-        if (!manifest) return [];
-        const cachedByAppId = new Map(manifest.cached_dependencies.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        return manifest.resolved_dependencies.flatMap((dep)=>{
-            if (!dep.branch) return [];
-            return [
-                {
-                    appId: dep.app_id,
-                    branch: dep.branch,
-                    packageName: cachedByAppId.get(dep.app_id)?.package_name
-                }
-            ];
-        });
-    }
-    function normalizeAnvilYamlDependenciesFromContent(content) {
-        const parsed = external_js_yaml_default().load(content);
-        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
-        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
-    }
-    function normalizeAnvilYamlDependenciesValue(value) {
-        if (!Array.isArray(value)) return [];
-        return normalizeForComparison(value);
-    }
-    async function readAnvilYamlDependencies(projectRoot) {
-        try {
-            const content = await promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
-            return normalizeAnvilYamlDependenciesFromContent(content);
-        } catch  {
-            return [];
-        }
-    }
-    function anvilYamlDependenciesEqual(left, right) {
-        return deepEqual(left, right);
-    }
-    function normalizeForComparison(value) {
-        if (Array.isArray(value)) return value.map(normalizeForComparison);
-        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
-                key,
-                normalizeForComparison(entryValue)
-            ]));
-        return value;
-    }
-    function cachedManifestEntry(dep, packageName) {
-        return {
-            app_id: dep.app_id,
-            commit_id: dep.commit_id,
-            ...dep.branch ? {
-                branch: dep.branch
-            } : {},
-            package_name: packageName
-        };
-    }
-    function safeDependencyPath(filePath, kind) {
-        const normalizedPath = external_path_default().normalize(filePath);
-        if (external_path_default().isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) throw new Error(`Invalid dependency ${kind} path: ${filePath}`);
-        return normalizedPath;
-    }
-    async function writeDepToCache(projectRoot, dep) {
-        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
-        await promises_default().rm(depDir, {
-            recursive: true,
-            force: true
-        });
-        await promises_default().mkdir(external_path_default().join(depDir, "client_code"), {
-            recursive: true
-        });
-        await promises_default().mkdir(external_path_default().join(depDir, "server_code"), {
-            recursive: true
-        });
-        await promises_default().writeFile(external_path_default().join(depDir, "anvil.yaml"), external_js_yaml_default().dump({
-            package_name: dep.package_name
-        }));
-        for (const mod of dep.modules ?? [])if (mod.is_package) {
-            const modDir = external_path_default().join(depDir, "client_code", mod.name);
-            await promises_default().mkdir(modDir, {
-                recursive: true
-            });
-            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
-        } else await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${mod.name}.py`), mod.code);
-        for (const form of dep.forms ?? []){
-            const { code, class_name, is_package, ...formTemplate } = form;
-            if (is_package) {
-                const formDir = external_path_default().join(depDir, "client_code", class_name);
-                await promises_default().mkdir(formDir, {
-                    recursive: true
-                });
-                await promises_default().writeFile(external_path_default().join(formDir, "__init__.py"), code);
-                await promises_default().writeFile(external_path_default().join(formDir, "form_template.yaml"), external_js_yaml_default().dump(formTemplate));
-            } else {
-                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.py`), code);
-                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.yaml`), external_js_yaml_default().dump(formTemplate));
-            }
-        }
-        for (const mod of dep.server_modules ?? [])if (mod.is_package) {
-            const modDir = external_path_default().join(depDir, "server_code", mod.name);
-            await promises_default().mkdir(modDir, {
-                recursive: true
-            });
-            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
-        } else await promises_default().writeFile(external_path_default().join(depDir, "server_code", `${mod.name}.py`), mod.code);
-        for (const asset of dep.assets ?? []){
-            const targetPath = external_path_default().join(depDir, "theme", "assets", safeDependencyPath(asset.name, "asset"));
-            await promises_default().mkdir(external_path_default().dirname(targetPath), {
-                recursive: true
-            });
-            await promises_default().writeFile(targetPath, Buffer.from(asset.content, "base64"));
-        }
-        for (const doc of dep.docs ?? []){
-            const targetPath = external_path_default().join(depDir, safeDependencyPath(doc.path, "doc"));
-            await promises_default().mkdir(external_path_default().dirname(targetPath), {
-                recursive: true
-            });
-            await promises_default().writeFile(targetPath, doc.content);
-        }
-    }
-    async function writeAllDepsToCache(projectRoot, response, options = {}) {
-        const includeDocs = options.includeDocs ?? true;
-        const manifest = await readDepsCacheManifest(projectRoot);
-        const canReuseExistingCache = manifest?.includeDocs === includeDocs;
-        if (!canReuseExistingCache) await clearDepsCache(projectRoot);
-        const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
-        const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
-        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
-            recursive: true,
-            force: true
-        });
-        for (const dep of response.dependencies)await writeDepToCache(projectRoot, dep);
-        const returnedByAppId = new Map(response.dependencies.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        const previousByAppId = new Map(previousCached.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        const cachedDependencies = response.resolved_dependencies.map((dep)=>{
-            const returned = returnedByAppId.get(dep.app_id);
-            if (returned) return cachedManifestEntry(returned, returned.package_name);
-            const previous = previousByAppId.get(dep.app_id);
-            if (!previous) return;
-            return cachedManifestEntry(dep, previous.package_name);
-        }).filter((dep)=>void 0 !== dep);
-        const newManifest = {
-            version: DEPS_MANIFEST_VERSION,
-            includeDocs,
-            resolved_dependencies: response.resolved_dependencies,
-            cached_dependencies: cachedDependencies
-        };
-        await promises_default().mkdir(depsDir(projectRoot), {
-            recursive: true
-        });
-        await promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
-    }
-    async function clearDepsCache(projectRoot) {
-        await promises_default().rm(depsDir(projectRoot), {
-            recursive: true,
-            force: true
-        });
-    }
-    async function getCachedPackages(projectRoot) {
-        try {
-            const entries = await promises_default().readdir(depsDir(projectRoot), {
-                withFileTypes: true
-            });
-            return entries.filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
-        } catch  {
-            return [];
-        }
-    }
     const external_timers_promises_namespaceObject = require("timers/promises");
     const WANT_NOT_VALID_RE = /\bwant\s+[0-9a-f]{7,40}\s+not valid\b/i;
     const FETCH_RETRY_DELAY_MS = 200;
@@ -15020,90 +14752,359 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 throw errors_createGitError.commandFailed("merge --ff-only", e.message);
             }
         }
-        async deleteRef(ref) {
-            try {
-                await this.git.raw([
-                    "update-ref",
-                    "-d",
-                    ref
-                ]);
-            } catch (e) {}
+        async deleteRef(ref) {
+            try {
+                await this.git.raw([
+                    "update-ref",
+                    "-d",
+                    ref
+                ]);
+            } catch (e) {}
+        }
+        async getRemotes() {
+            try {
+                const remotes = await this.git.getRemotes(true);
+                return remotes.map((r)=>({
+                        name: r.name,
+                        fetchUrl: r.refs.fetch
+                    }));
+            } catch (e) {
+                throw errors_createGitError.commandFailed("remote", e.message);
+            }
+        }
+        async isGitInitialized() {
+            const gitPath = external_path_default().join(this.repoPath, ".git");
+            return external_fs_.existsSync(gitPath);
+        }
+        async removeEmptyDirectories(removedFiles) {
+            const directoriesToCheck = new Set();
+            for (const file of removedFiles){
+                let dir = external_path_default().dirname(file);
+                while(dir && "." !== dir){
+                    directoriesToCheck.add(dir);
+                    const parentDir = external_path_default().dirname(dir);
+                    if (parentDir === dir) break;
+                    dir = parentDir;
+                }
+            }
+            const sortedDirs = Array.from(directoriesToCheck).sort((a, b)=>b.split("/").length - a.split("/").length);
+            for (const dir of sortedDirs)try {
+                const dirPath = external_path_default().join(this.repoPath, dir);
+                if (!external_fs_.existsSync(dirPath)) continue;
+                const entries = await external_fs_.promises.readdir(dirPath);
+                if (0 === entries.length) await external_fs_.promises.rmdir(dirPath);
+            } catch (error) {}
+        }
+    }
+    async function getStagedFileChanges(git, gitService) {
+        try {
+            const status = await git.status();
+            const renames = status.renamed || [];
+            const stagedFiles = status.files.filter((f)=>" " !== f.index && "?" !== f.index);
+            const stagedModeOnlyPaths = new Set(gitService ? await gitService.discardStagedModeOnlyChanges(stagedFiles.filter((f)=>"R" !== f.index && "D" !== f.index).map((f)=>f.path)) : []);
+            const stagedRenames = [];
+            for (const f of stagedFiles)if ("R" === f.index) {
+                const rename = renames.find((r)=>r.to === f.path);
+                if (rename) stagedRenames.push({
+                    path: rename.to,
+                    type: "rename",
+                    from: rename.from
+                });
+            }
+            const stagedRenamedFromPaths = new Set(stagedRenames.map((r)=>r.from));
+            const stagedRenamedToPaths = new Set(stagedRenames.map((r)=>r.path));
+            const changes = [];
+            for (const f of stagedFiles){
+                if ("R" !== f.index) {
+                    if (!stagedModeOnlyPaths.has(f.path)) {
+                        if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
+                            path: f.path,
+                            type: "unlink"
+                        });
+                        else if ("A" === f.index || "?" === f.index) changes.push({
+                            path: f.path,
+                            type: "add"
+                        });
+                        else changes.push({
+                            path: f.path,
+                            type: "change"
+                        });
+                    }
+                }
+            }
+            changes.push(...stagedRenames);
+            return changes;
+        } catch (e) {
+            throw errors_createGitError.commandFailed("status", e.message);
+        }
+    }
+    const ANVIL_DEPS_DIR = ".anvil/deps";
+    const ANVIL_DEPS_MANIFEST = "manifest.json";
+    const DEPS_MANIFEST_VERSION = 1;
+    function formatFetchError(prefix, status, errorBody) {
+        if (!errorBody) return `${prefix}: ${status}`;
+        try {
+            const parsed = JSON.parse(errorBody);
+            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
+        } catch  {}
+        return `${prefix}: ${status} ${errorBody}`;
+    }
+    async function fetchAllDependencies(appId, anvilUrl = resolveAnvilUrl(), options = {}) {
+        const { commit, includeDocs = true, knownDependencies = [] } = options;
+        const token = await auth_getValidAuthToken(anvilUrl, options.username);
+        const body = {
+            include_docs: includeDocs,
+            known_dependencies: knownDependencies
+        };
+        if (commit) body.commit = commit;
+        const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/resolved-dependencies`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+            const errorBody = await resp.text();
+            throw new Error(formatFetchError("Failed to fetch dependencies", resp.status, errorBody));
+        }
+        return await resp.json();
+    }
+    async function refreshDependencyCache(projectRoot, appId, anvilUrl = resolveAnvilUrl(), options = {}) {
+        const includeDocs = options.includeDocs ?? true;
+        const commit = options.commit ?? await new GitService(projectRoot).getCommitId();
+        const knownDependencies = await getKnownDependenciesForCache(projectRoot, includeDocs);
+        const response = await fetchAllDependencies(appId, anvilUrl, {
+            username: options.username,
+            commit,
+            includeDocs,
+            knownDependencies
+        });
+        if (!response.resolved_dependencies.length) {
+            await clearDepsCache(projectRoot);
+            return {
+                response,
+                addedGitignoreEntry: false
+            };
+        }
+        const addedGitignoreEntry = await ensureProjectGitignoreIgnoresAnvilDir(projectRoot);
+        await writeAllDepsToCache(projectRoot, response, {
+            includeDocs
+        });
+        return {
+            response,
+            addedGitignoreEntry
+        };
+    }
+    function depsDir(projectRoot) {
+        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
+    }
+    function depsManifestPath(projectRoot) {
+        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
+    }
+    function isResolvedDependencyManifestEntry(value) {
+        if (!value || "object" != typeof value) return false;
+        const entry = value;
+        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
+    }
+    function isCachedDependencyManifestEntry(value) {
+        if (!isResolvedDependencyManifestEntry(value)) return false;
+        const entry = value;
+        return "string" == typeof entry.package_name && entry.package_name.length > 0;
+    }
+    function isDepsCacheManifest(value) {
+        if (!value || "object" != typeof value) return false;
+        const manifest = value;
+        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
+    }
+    async function readDepsCacheManifest(projectRoot) {
+        try {
+            const raw = await promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
+            const parsed = JSON.parse(raw);
+            return isDepsCacheManifest(parsed) ? parsed : void 0;
+        } catch  {
+            return;
+        }
+    }
+    async function getKnownDependenciesForCache(projectRoot, includeDocs) {
+        const manifest = await readDepsCacheManifest(projectRoot);
+        if (!manifest || manifest.includeDocs !== includeDocs) return [];
+        return manifest.resolved_dependencies.map(({ app_id, commit_id })=>({
+                app_id,
+                commit_id
+            }));
+    }
+    function getDependencyWatchSubscriptionsFromManifest(manifest) {
+        if (!manifest) return [];
+        const cachedByAppId = new Map(manifest.cached_dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        return manifest.resolved_dependencies.flatMap((dep)=>{
+            if (!dep.branch) return [];
+            return [
+                {
+                    appId: dep.app_id,
+                    branch: dep.branch,
+                    packageName: cachedByAppId.get(dep.app_id)?.package_name
+                }
+            ];
+        });
+    }
+    function normalizeAnvilYamlDependenciesFromContent(content) {
+        const parsed = external_js_yaml_default().load(content);
+        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
+        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
+    }
+    function normalizeAnvilYamlDependenciesValue(value) {
+        if (!Array.isArray(value)) return [];
+        return normalizeForComparison(value);
+    }
+    async function readAnvilYamlDependencies(projectRoot) {
+        try {
+            const content = await promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
+            return normalizeAnvilYamlDependenciesFromContent(content);
+        } catch  {
+            return [];
         }
-        async getRemotes() {
-            try {
-                const remotes = await this.git.getRemotes(true);
-                return remotes.map((r)=>({
-                        name: r.name,
-                        fetchUrl: r.refs.fetch
-                    }));
-            } catch (e) {
-                throw errors_createGitError.commandFailed("remote", e.message);
+    }
+    function anvilYamlDependenciesEqual(left, right) {
+        return deepEqual(left, right);
+    }
+    function normalizeForComparison(value) {
+        if (Array.isArray(value)) return value.map(normalizeForComparison);
+        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
+                key,
+                normalizeForComparison(entryValue)
+            ]));
+        return value;
+    }
+    function cachedManifestEntry(dep, packageName) {
+        return {
+            app_id: dep.app_id,
+            commit_id: dep.commit_id,
+            ...dep.branch ? {
+                branch: dep.branch
+            } : {},
+            package_name: packageName
+        };
+    }
+    function safeDependencyPath(filePath, kind) {
+        const normalizedPath = external_path_default().normalize(filePath);
+        if (external_path_default().isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) throw new Error(`Invalid dependency ${kind} path: ${filePath}`);
+        return normalizedPath;
+    }
+    async function writeDepToCache(projectRoot, dep) {
+        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
+        await promises_default().rm(depDir, {
+            recursive: true,
+            force: true
+        });
+        await promises_default().mkdir(external_path_default().join(depDir, "client_code"), {
+            recursive: true
+        });
+        await promises_default().mkdir(external_path_default().join(depDir, "server_code"), {
+            recursive: true
+        });
+        await promises_default().writeFile(external_path_default().join(depDir, "anvil.yaml"), external_js_yaml_default().dump({
+            package_name: dep.package_name
+        }));
+        for (const mod of dep.modules ?? [])if (mod.is_package) {
+            const modDir = external_path_default().join(depDir, "client_code", mod.name);
+            await promises_default().mkdir(modDir, {
+                recursive: true
+            });
+            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
+        } else await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${mod.name}.py`), mod.code);
+        for (const form of dep.forms ?? []){
+            const { code, class_name, is_package, ...formTemplate } = form;
+            if (is_package) {
+                const formDir = external_path_default().join(depDir, "client_code", class_name);
+                await promises_default().mkdir(formDir, {
+                    recursive: true
+                });
+                await promises_default().writeFile(external_path_default().join(formDir, "__init__.py"), code);
+                await promises_default().writeFile(external_path_default().join(formDir, "form_template.yaml"), external_js_yaml_default().dump(formTemplate));
+            } else {
+                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.py`), code);
+                await promises_default().writeFile(external_path_default().join(depDir, "client_code", `${class_name}.yaml`), external_js_yaml_default().dump(formTemplate));
             }
         }
-        async isGitInitialized() {
-            const gitPath = external_path_default().join(this.repoPath, ".git");
-            return external_fs_.existsSync(gitPath);
+        for (const mod of dep.server_modules ?? [])if (mod.is_package) {
+            const modDir = external_path_default().join(depDir, "server_code", mod.name);
+            await promises_default().mkdir(modDir, {
+                recursive: true
+            });
+            await promises_default().writeFile(external_path_default().join(modDir, "__init__.py"), mod.code);
+        } else await promises_default().writeFile(external_path_default().join(depDir, "server_code", `${mod.name}.py`), mod.code);
+        for (const asset of dep.assets ?? []){
+            const targetPath = external_path_default().join(depDir, "theme", "assets", safeDependencyPath(asset.name, "asset"));
+            await promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await promises_default().writeFile(targetPath, Buffer.from(asset.content, "base64"));
         }
-        async removeEmptyDirectories(removedFiles) {
-            const directoriesToCheck = new Set();
-            for (const file of removedFiles){
-                let dir = external_path_default().dirname(file);
-                while(dir && "." !== dir){
-                    directoriesToCheck.add(dir);
-                    const parentDir = external_path_default().dirname(dir);
-                    if (parentDir === dir) break;
-                    dir = parentDir;
-                }
-            }
-            const sortedDirs = Array.from(directoriesToCheck).sort((a, b)=>b.split("/").length - a.split("/").length);
-            for (const dir of sortedDirs)try {
-                const dirPath = external_path_default().join(this.repoPath, dir);
-                if (!external_fs_.existsSync(dirPath)) continue;
-                const entries = await external_fs_.promises.readdir(dirPath);
-                if (0 === entries.length) await external_fs_.promises.rmdir(dirPath);
-            } catch (error) {}
+        for (const doc of dep.docs ?? []){
+            const targetPath = external_path_default().join(depDir, safeDependencyPath(doc.path, "doc"));
+            await promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await promises_default().writeFile(targetPath, doc.content);
         }
     }
-    async function getStagedFileChanges(git, gitService) {
+    async function writeAllDepsToCache(projectRoot, response, options = {}) {
+        const includeDocs = options.includeDocs ?? true;
+        const manifest = await readDepsCacheManifest(projectRoot);
+        const canReuseExistingCache = manifest?.includeDocs === includeDocs;
+        if (!canReuseExistingCache) await clearDepsCache(projectRoot);
+        const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
+        const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
+        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
+            recursive: true,
+            force: true
+        });
+        for (const dep of response.dependencies)await writeDepToCache(projectRoot, dep);
+        const returnedByAppId = new Map(response.dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const previousByAppId = new Map(previousCached.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const cachedDependencies = response.resolved_dependencies.map((dep)=>{
+            const returned = returnedByAppId.get(dep.app_id);
+            if (returned) return cachedManifestEntry(returned, returned.package_name);
+            const previous = previousByAppId.get(dep.app_id);
+            if (!previous) return;
+            return cachedManifestEntry(dep, previous.package_name);
+        }).filter((dep)=>void 0 !== dep);
+        const newManifest = {
+            version: DEPS_MANIFEST_VERSION,
+            includeDocs,
+            resolved_dependencies: response.resolved_dependencies,
+            cached_dependencies: cachedDependencies
+        };
+        await promises_default().mkdir(depsDir(projectRoot), {
+            recursive: true
+        });
+        await promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
+    }
+    async function clearDepsCache(projectRoot) {
+        await promises_default().rm(depsDir(projectRoot), {
+            recursive: true,
+            force: true
+        });
+    }
+    async function getCachedPackages(projectRoot) {
         try {
-            const status = await git.status();
-            const renames = status.renamed || [];
-            const stagedFiles = status.files.filter((f)=>" " !== f.index && "?" !== f.index);
-            const stagedModeOnlyPaths = new Set(gitService ? await gitService.discardStagedModeOnlyChanges(stagedFiles.filter((f)=>"R" !== f.index && "D" !== f.index).map((f)=>f.path)) : []);
-            const stagedRenames = [];
-            for (const f of stagedFiles)if ("R" === f.index) {
-                const rename = renames.find((r)=>r.to === f.path);
-                if (rename) stagedRenames.push({
-                    path: rename.to,
-                    type: "rename",
-                    from: rename.from
-                });
-            }
-            const stagedRenamedFromPaths = new Set(stagedRenames.map((r)=>r.from));
-            const stagedRenamedToPaths = new Set(stagedRenames.map((r)=>r.path));
-            const changes = [];
-            for (const f of stagedFiles){
-                if ("R" !== f.index) {
-                    if (!stagedModeOnlyPaths.has(f.path)) {
-                        if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
-                            path: f.path,
-                            type: "unlink"
-                        });
-                        else if ("A" === f.index || "?" === f.index) changes.push({
-                            path: f.path,
-                            type: "add"
-                        });
-                        else changes.push({
-                            path: f.path,
-                            type: "change"
-                        });
-                    }
-                }
-            }
-            changes.push(...stagedRenames);
-            return changes;
-        } catch (e) {
-            throw errors_createGitError.commandFailed("status", e.message);
+            const entries = await promises_default().readdir(depsDir(projectRoot), {
+                withFileTypes: true
+            });
+            return entries.filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+        } catch  {
+            return [];
         }
     }
     const external_chokidar_namespaceObject = require("chokidar");
@@ -23060,7 +23061,7 @@ print(json.dumps({"issues": issues}))
     }
     function registerDepsCommand(program) {
         const deps = program.command("deps").description("Manage app dependencies");
-        deps.command("fetch").description("Fetch dependencies into .anvil/deps/").option("--commit <commit>", "Fetch deps at specific commit").option("--exclude-docs", "Exclude dependency docs from .anvil/deps/").action(async (options)=>{
+        deps.command("fetch").description("Fetch dependencies for checkout HEAD into .anvil/deps/").option("--commit <commit>", "Fetch deps at a specific app commit instead of checkout HEAD").option("--exclude-docs", "Exclude dependency docs from .anvil/deps/").action(async (options)=>{
             try {
                 const projectRoot = process.cwd();
                 const anvilUrl = resolveAnvilUrl();