generate_build_zon

Instructions

Implementation Reference

• src/index.ts:301-328 (registration)

  Tool registration in ListToolsRequestSchema handler — defines the 'generate_build_zon' tool name, description, and inputSchema with projectName and dependencies.

  {
    name: 'generate_build_zon',
    description: 'Generate a build.zig.zon file for dependency management',
    inputSchema: {
      type: 'object',
      properties: {
        projectName: {
          type: 'string',
          description: 'Name of the project',
          default: 'my-project',
        },
        dependencies: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              name: { type: 'string' },
              url: { type: 'string' },
            },
            required: ['name', 'url'],
          },
          description: 'List of dependencies with their URLs',
          default: [],
        },
      },
      required: [],
    },
  },

• src/index.ts:406-414 (handler)

  Tool dispatch in CallToolRequestSchema switch — calls this.generateBuildZon(args || {}) for 'generate_build_zon' case.

  case 'generate_build_zon':
    return {
      content: [
        {
          type: 'text',
          text: this.generateBuildZon(args || {}),
        },
      ],
    };

• src/index.ts:1225-1270 (helper)

  Private method generateBuildZon on ZigServer — extracts projectName/dependencies from args, calls ZigBuildSystemHelper.generateBuildZon(), and wraps result in a markdown response with instructions.

    private generateBuildZon(args: Record<string, any>): string {
      Logger.debug('Generating build.zig.zon file');
  
      const _projectName = args.projectName || 'my-project';
      const dependencies = Array.isArray(args.dependencies) ? args.dependencies : [];
  
      const buildZonContent = ZigBuildSystemHelper.generateBuildZon(dependencies);
  
      return `
  # Generated build.zig.zon
  
  \`\`\`zig
  ${buildZonContent}
  \`\`\`
  
  ## Dependency Management Instructions:
  
  1. **Add a new dependency:**
     - Add the dependency to the .dependencies section
     - Run \`zig build --fetch\` to download and validate
  
  2. **Update dependency hashes:**
     - Zig will provide the correct hash when a mismatch is detected
     - Copy the hash from the error message to build.zig.zon
  
  3. **Use dependencies in build.zig:**
     \`\`\`zig
     const my_dep = b.dependency("my_dep", .{
         .target = target,
         .optimize = optimize,
     });
     exe.linkLibrary(my_dep.artifact("my_dep"));
     \`\`\`
  
  ## Popular Zig Dependencies:
  ${Object.entries(ZigBuildSystemHelper.getExampleDependencies())
    .map(([_key, dep]) => `- **${dep.name}**: ${dep.url}`)
    .join('\n')}
  
  ## Best Practices:
  - Keep dependencies minimal and well-maintained
  - Pin to specific versions or commits for reproducible builds
  - Regularly update dependencies for security fixes
  - Document why each dependency is needed
      `.trim();
    }

• src/zig-build.ts:104-134 (handler)

  Static method ZigBuildSystemHelper.generateBuildZon — generates the raw build.zig.zon file content with .name, .version, .dependencies (mapped from ZigModuleDependency[]), and .paths.

    /**
     * Generates a build.zig.zon file for dependency management
     */
    static generateBuildZon(dependencies: ZigModuleDependency[]): string {
      return `.{
      .name = "my-project",
      .version = "0.1.0",
      .minimum_zig_version = "0.15.2",
      
      .dependencies = .{
  ${dependencies
    .map(
      dep => `        .${dep.name} = .{
              .url = "${dep.url || `https://github.com/example/${dep.name}`}",
              .hash = "1220000000000000000000000000000000000000000000000000000000000000",
          },`
    )
    .join('\n')}
      },
      
      .paths = .{
          "build.zig",
          "build.zig.zon",
          "src",
          // "examples",
          // "test",
          // "README.md",
          // "LICENSE",
      },
  }`;
    }

• src/types.ts:73-78 (schema)

  ZigModuleDependency interface — defines the type used for dependency entries with name, path, version?, and url? fields.

  export interface ZigModuleDependency {
    name: string;
    path: string;
    version?: string;
    url?: string;
  }